Merge branch 'master' into upgrade-workflows

Author: Luc1412

.github/workflows/lint.yml

@@ -21,4 +21,28 @@ jobs:
       - name: Run Ruff linter
         uses: astral-sh/ruff-action@v3
         with:
-          version: ${{ steps.ruff-version.outputs.version }}
+          version: ${{ steps.ruff-version.outputs.version }}
+  pyright:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [ '3.10', '3.x' ]
+    name: pyright ${{ matrix.python-version }}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Setup Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "pip" # Cache the pip packages to speed up the workflow
+      - name: Set up UV
+        uses: astral-sh/setup-uv@v6
+      - name: Install Dependencies and Package
+        run: uv sync --all-extras
+      - name: Run Pyright
+        uses: jakebailey/pyright-action@v2
+        with:
+          version: '1.1.407'
+          annotate: ${{ matrix.python-version != '3.x' }}
+          python-path: '.venv/bin/python'

docs/changelog.rst

@@ -18,6 +18,7 @@ Bug Fixes
 ~~~~~~~~~
 - Fixed an issue that caused :class:`fortnite_api.Asset.resize` to raise :class:`TypeError` instead of :class:`ValueError` when the given size isn't a power of 2.
 - Fixed an issue that caused :class:`fortnite_api.ServiceUnavailable` to be raised with a static message as a fallback for all unhandled http status codes. Instead :class:`fortnite_api.HTTPException` is raised with the proper error message.
+- Fixed typing of our internal "Enum-like" classes. They are now typed as a :class:`py:enum.Enum`.
 
 Miscellaneous
 ~~~~~~~~~~~~~

fortnite_api/abc.py

@@ -25,7 +25,7 @@
 from __future__ import annotations
 
 import copy
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, overload
 
 from .http import HTTPClient, HTTPClientT, SyncHTTPClient
 

fortnite_api/enums.py

@@ -27,7 +27,7 @@
 
 import types
 from collections.abc import Iterator, Mapping
-from typing import TYPE_CHECKING, Any, ClassVar, NamedTuple, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 
 from typing_extensions import Self
 
@@ -53,32 +53,51 @@
 
 
 def _create_value_cls(name: str, comparable: bool) -> type[NewValue]:
-    class _EnumValue(NamedTuple):
-        # Denotes an internal marker used to create the value class. The definition
-        # of this must be localized in this function because its methods
-        # are changed multiple times at runtime. This is exposed outside of this
-        # function as a type "NewValue", which denotes the type of the value class.
-        name: str
-        value: Any
-
-    cls = _EnumValue
-    cls.__name__ = '_EnumValue_' + name
-    cls.__repr__ = lambda self: f'<{name}.{self.name}: {self.value!r}>'
-    cls.__str__ = lambda self: f'{name}.{self.name}'
-    if comparable:
-        cls.__le__ = lambda self, other: isinstance(other, self.__class__) and self.value <= other.value
-        cls.__ge__ = lambda self, other: isinstance(other, self.__class__) and self.value >= other.value
-        cls.__lt__ = lambda self, other: isinstance(other, self.__class__) and self.value < other.value
-        cls.__gt__ = lambda self, other: isinstance(other, self.__class__) and self.value > other.value
-
-    return cls
+    # All the type ignores here are due to the type checker being unable to recognise
+    # Runtime type creation without exploding.
+
+    class EnumValue:
+        __slots__ = ("name", "value")
+
+        def __init__(self, name: str, value: EnumValue) -> None:
+            self.name: str = name
+            self.value: EnumValue = value
+
+        def __repr__(self) -> str:
+            return f'<{name}.{self.name}: {self.value!r}>'
+
+        def __str__(self) -> str:
+            return f'{name}.{self.name}'
+
+        if comparable:
+
+            def __le__(self, other: object) -> bool:
+                return isinstance(other, self.__class__) and self.value <= other.value
+
+            def __ge__(self, other: object) -> bool:
+                return isinstance(other, self.__class__) and self.value >= other.value
+
+            def __lt__(self, other: object) -> bool:
+                return isinstance(other, self.__class__) and self.value < other.value
+
+            def __gt__(self, other: object) -> bool:
+                return isinstance(other, self.__class__) and self.value > other.value
+
+    EnumValue.__name__ = '_EnumValue_' + name
+    return EnumValue
 
 
 def _is_descriptor(obj: type[object]) -> bool:
     return hasattr(obj, '__get__') or hasattr(obj, '__set__') or hasattr(obj, '__delete__')
 
 
 class EnumMeta(type):
+    if TYPE_CHECKING:
+        _enum_member_names_: ClassVar[list[str]]
+        _enum_member_map_: ClassVar[dict[str, NewValue]]
+        _enum_value_map_: ClassVar[dict[OldValue, NewValue]]
+        _enum_value_cls_: ClassVar[type[NewValue]]
+
     def __new__(
         cls,
         name: str,
@@ -124,29 +143,29 @@ def __new__(
         value_cls._actual_enum_cls_ = actual_cls
         return actual_cls
 
-    def __iter__(cls: type[Enum]) -> Iterator[Any]:
+    def __iter__(cls) -> Iterator[Any]:
         return (cls._enum_member_map_[name] for name in cls._enum_member_names_)
 
-    def __reversed__(cls: type[Enum]) -> Iterator[Any]:
+    def __reversed__(cls) -> Iterator[Any]:
         return (cls._enum_member_map_[name] for name in reversed(cls._enum_member_names_))
 
-    def __len__(cls: type[Enum]) -> int:
+    def __len__(cls) -> int:
         return len(cls._enum_member_names_)
 
     def __repr__(cls) -> str:
         return f'<enum {cls.__name__}>'
 
     @property
-    def __members__(cls: type[Enum]) -> Mapping[str, Any]:
+    def __members__(cls) -> Mapping[str, Any]:
         return types.MappingProxyType(cls._enum_member_map_)
 
-    def __call__(cls: type[Enum], value: str) -> Any:
+    def __call__(cls, value: str) -> Any:
         try:
             return cls._enum_value_map_[value]
         except (KeyError, TypeError):
-            raise ValueError(f"{value!r} is not a valid {cls.__name__}")
+            raise ValueError(f'{value!r} is not a valid {cls.__name__}')
 
-    def __getitem__(cls: type[Enum], key: str) -> Any:
+    def __getitem__(cls, key: str) -> Any:
         return cls._enum_member_map_[key]
 
     def __setattr__(cls, name: str, value: Any) -> None:
@@ -164,21 +183,17 @@ def __instancecheck__(self, instance: Any) -> bool:
             return False
 
 
-class Enum(metaclass=EnumMeta):
-    if TYPE_CHECKING:
-        # Set in the metaclass when __new__ is called. The newly
-        # created cls has these attributes set.
-        _enum_member_names_: ClassVar[list[str]]
-        _enum_member_map_: ClassVar[dict[str, NewValue]]
-        _enum_value_map_: ClassVar[dict[OldValue, NewValue]]
-        _enum_value_cls_: ClassVar[type[NewValue]]
+if TYPE_CHECKING:
+    from enum import Enum
+else:
 
-    @classmethod
-    def try_value(cls, value: Any) -> Any:
-        try:
-            return cls._enum_value_map_[value]
-        except (KeyError, TypeError):
-            return value
+    class Enum(metaclass=EnumMeta):
+        @classmethod
+        def try_value(cls, value: Any) -> Any:
+            try:
+                return cls._enum_value_map_[value]
+            except (KeyError, TypeError):
+                return value
 
 
 class KeyFormat(Enum):
@@ -580,9 +595,9 @@ def _from_str(cls: type[Self], string: str) -> Self:
 
 
 def create_unknown_value(cls: type[E], val: Any) -> NewValue:
-    value_cls = cls._enum_value_cls_
+    value_cls = cls._enum_value_cls_  # type: ignore # This is narrowed below
     name = f'UNKNOWN_{val}'
-    return value_cls(name=name, value=val)
+    return value_cls(name=name, value=val)  # type: ignore
 
 
 def try_enum(cls: type[E], val: Any) -> E:
@@ -591,6 +606,6 @@ def try_enum(cls: type[E], val: Any) -> E:
     If it fails it returns a proxy invalid value instead.
     """
     try:
-        return cls._enum_value_map_[val]
+        return cls._enum_value_map_[val]  # type: ignore # All errors are caught below
     except (KeyError, TypeError, AttributeError):
         return create_unknown_value(cls, val)

fortnite_api/new.py

@@ -25,7 +25,7 @@
 from __future__ import annotations
 
 import datetime
-from typing import Any, Generic
+from typing import Any, Generic, cast
 
 from .abc import ReconstructAble
 from .cosmetics import (
@@ -208,7 +208,7 @@ def _parse_new_cosmetic(
         internal_key: str,
         cosmetic_class: type[CosmeticT],
     ) -> NewCosmetic[CosmeticT]:
-        cosmetic_items: list[dict[str, Any]] = get_with_fallback(self._items, internal_key, list)
+        cosmetic_items = cast(list[dict[str, Any]], get_with_fallback(self._items, internal_key, list))
 
         last_addition_str = self._last_additions[internal_key]
         last_addition: datetime.datetime | None = last_addition_str and parse_time(last_addition_str)

fortnite_api/proxies.py

@@ -67,7 +67,7 @@ def _transform_at(self, index: SupportsIndex) -> T:
         data = super().__getitem__(index)
         if isinstance(data, dict):
             # Narrow the type of data to Dict[str, Any]
-            raw_data: dict[K_co, V_co] = data
+            raw_data = cast(dict[K_co, V_co], data)
             result = self._transform_data(raw_data)
             super().__setitem__(index, result)
         else:
@@ -78,7 +78,7 @@ def _transform_at(self, index: SupportsIndex) -> T:
     def _transform_all(self):
         for index, entry in enumerate(self):
             if isinstance(entry, dict):
-                raw_data: dict[K_co, V_co] = entry
+                raw_data = cast(dict[K_co, V_co], entry)
                 result = self._transform_data(raw_data)
                 super().__setitem__(index, result)
 

fortnite_api/utils.py

@@ -26,7 +26,7 @@
 
 import datetime
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 K_co = TypeVar('K_co', bound='Hashable', covariant=True)
 V_co = TypeVar('V_co', covariant=True)
@@ -36,7 +36,7 @@
     from collections.abc import Hashable
 
 try:
-    import orjson  # type: ignore
+    import orjson
 
     _has_orjson: bool = True
 except ImportError:
@@ -201,7 +201,7 @@ def _transform_dict_for_get_request(data: dict[str, Any]) -> dict[str, Any]:
             updated[key] = str(value).lower()
 
         elif isinstance(value, dict):
-            inner: dict[str, Any] = value  # narrow the dict type to pass it along (should always be [str, Any])
+            inner = cast(dict[str, Any], value)  # narrow the dict type to pass it along (should always be [str, Any])
             updated[key] = _transform_dict_for_get_request(inner)
 
         if '_' in key:

tests/client/test_client_hybrid.py

@@ -27,19 +27,20 @@
 import inspect
 import logging
 from collections.abc import Callable, Coroutine
-from typing import TYPE_CHECKING, Any, Concatenate, Generic, TypeAlias, TypeVar
+from typing import TYPE_CHECKING, Any, Concatenate, Generic, TypeAlias, TypeVar, cast
 
 import pytest
 import requests
 from typing_extensions import ParamSpec
 
 import fortnite_api
-from fortnite_api import ReconstructAble
 
 P = ParamSpec('P')
 T = TypeVar('T')
 
 if TYPE_CHECKING:
+    import fortnite_api.http
+
     Client: TypeAlias = fortnite_api.Client
     SyncClient = fortnite_api.SyncClient
 
@@ -77,8 +78,8 @@ def _validate_results(self, async_res: T, sync_res: T) -> None:
         if isinstance(async_res, fortnite_api.ReconstructAble):
             assert isinstance(sync_res, fortnite_api.ReconstructAble)
 
-            sync_res_narrowed: ReconstructAble[Any, fortnite_api.SyncHTTPClient] = sync_res
-            async_res_narrowed: ReconstructAble[Any, fortnite_api.HTTPClient] = async_res
+            sync_res_narrowed = cast(fortnite_api.ReconstructAble[Any, fortnite_api.http.SyncHTTPClient], sync_res)
+            async_res_narrowed = cast(fortnite_api.ReconstructAble[Any, fortnite_api.http.HTTPClient], async_res)
 
             async_raw_data = sync_res_narrowed.to_dict()
             sync_raw_data = sync_res_narrowed.to_dict()

tests/test_enum.py

@@ -47,9 +47,9 @@ def test_dummy_enum():
 
     # Test immutability
     with pytest.raises(TypeError):
-        DummyEnum.FOO = "new"
+        DummyEnum.FOO = "new"  # type: ignore # This should raise an error
     with pytest.raises(TypeError):
-        del DummyEnum.FOO
+        del DummyEnum.FOO  # type: ignore  # This should raise an error
 
     # Test try_enum functionality
     valid_value = "foo"