Merge pull request #247 from pytest-dev/remove-typing-any

Remove usages of `typing.Any`

Author: youtux

src/pytest_factoryboy/fixture.py

@@ -10,7 +10,7 @@
 from dataclasses import dataclass
 from inspect import signature
 from types import MethodType
-from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, cast, overload
+from typing import TYPE_CHECKING, Callable, Generic, TypeVar, cast, overload
 
 import factory
 import factory.enums
@@ -45,13 +45,13 @@
 
 
 @dataclass(eq=False)
-class DeferredFunction(Generic[T]):
+class DeferredFunction(Generic[T, U]):
     name: str
     factory: type[Factory[T]]
     is_related: bool
-    function: Callable[[SubRequest], Any]
+    function: Callable[[SubRequest], U]
 
-    def __call__(self, request: SubRequest) -> Any:
+    def __call__(self, request: SubRequest) -> U:
         return self.function(request)
 
 
@@ -76,21 +76,33 @@ def named_model(model_cls: type[T], name: str) -> type[T]:
 # @register
 # class AuthorFactory(Factory): ...
 @overload
-def register(factory_class: type[Factory[T]], _name: str | None = None, **kwargs: Any) -> type[Factory[T]]: ...
+def register(
+    factory_class: type[Factory[T]],
+    _name: str | None = ...,
+    *,
+    _caller_locals: Box[dict[str, object]] | None = ...,
+    **kwargs: object,
+) -> type[Factory[T]]: ...
 
 
 # @register(...)
 # class AuthorFactory(Factory): ...
 @overload
-def register(*, _name: str | None = None, **kwargs: Any) -> Callable[[type[Factory[T]]], type[Factory[T]]]: ...
+def register(
+    factory_class: None,
+    _name: str | None = ...,
+    *,
+    _caller_locals: Box[dict[str, object]] | None = ...,
+    **kwargs: object,
+) -> Callable[[type[Factory[T]]], type[Factory[T]]]: ...
 
 
 def register(
     factory_class: type[Factory[T]] | None = None,
     _name: str | None = None,
     *,
-    _caller_locals: Box[dict[str, Any]] | None = None,
-    **kwargs: Any,
+    _caller_locals: Box[dict[str, object]] | None = None,
+    **kwargs: object,
 ) -> type[Factory[T]] | Callable[[type[Factory[T]]], type[Factory[T]]]:
     r"""Register fixtures for the factory class.
 
@@ -141,9 +153,9 @@ def generate_fixtures(
     factory_class: type[Factory[T]],
     model_name: str,
     factory_name: str,
-    overrides: Mapping[str, Any],
-    caller_locals: Box[Mapping[str, Any]],
-) -> Iterable[tuple[str, Callable[..., Any]]]:
+    overrides: Mapping[str, object],
+    caller_locals: Box[Mapping[str, object]],
+) -> Iterable[tuple[str, Callable[..., object]]]:
     """Generate all the FixtureDefs for the given factory class."""
 
     related: list[str] = []
@@ -199,10 +211,10 @@ def create_fixture_with_related(
 
 def make_declaration_fixturedef(
     attr_name: str,
-    value: Any,
+    value: object,
     factory_class: type[Factory[T]],
     related: list[str],
-) -> Callable[..., Any]:
+) -> Callable[[SubRequest], object]:
     """Create the FixtureDef for a factory declaration."""
     if isinstance(value, (SubFactory, RelatedFactory)):
         subfactory_class: type[Factory[object]] = value.get_factory()
@@ -246,7 +258,7 @@ def make_declaration_fixturedef(
     )
 
 
-def inject_into_caller(name: str, function: Callable[..., Any], locals_: Box[dict[str, Any]]) -> None:
+def inject_into_caller(name: str, function: Callable[..., object], locals_: Box[dict[str, object]]) -> None:
     """Inject a function into the caller's locals, making sure that the function will work also within classes."""
     # We need to check if the caller frame is a class, since in that case the first argument is the class itself.
     # In that case, we can apply the staticmethod() decorator to the injected function, so that the first param
@@ -302,7 +314,7 @@ def get_deps(
     model_name = get_model_name(factory_class) if model_name is None else model_name
     parent_model_name = get_model_name(parent_factory_class) if parent_factory_class is not None else None
 
-    def is_dep(value: Any) -> bool:
+    def is_dep(value: object) -> bool:
         if isinstance(value, RelatedFactory):
             return False
         if isinstance(value, SubFactory):
@@ -325,7 +337,7 @@ def evaluate(request: SubRequest, value: LazyFixture[T] | T) -> T:
     return value.evaluate(request) if isinstance(value, LazyFixture) else value
 
 
-def noop(*args: Any, **kwargs: Any) -> None:
+def noop(*args: object, **kwargs: object) -> None:
     """No-op function."""
     pass
 
@@ -388,7 +400,7 @@ def model_fixture(request: SubRequest, factory_name: str) -> object:
     request._fixture_defs[fixture_name] = request._fixturedef
 
     # Defer post-generation declarations
-    deferred: list[DeferredFunction[object]] = []
+    deferred: list[DeferredFunction[object, object]] = []
 
     for attr in factory_class._meta.post_declarations.sorted():
         decl = factory_class._meta.post_declarations.declarations[attr]
@@ -427,7 +439,7 @@ def model_fixture(request: SubRequest, factory_name: str) -> object:
     return instance
 
 
-def make_deferred_related(factory: type[Factory[T]], fixture: str, attr: str) -> DeferredFunction[T]:
+def make_deferred_related(factory: type[Factory[T]], fixture: str, attr: str) -> DeferredFunction[T, object]:
     """Make deferred function for the related factory declaration.
 
     :param factory: Factory class.
@@ -438,7 +450,7 @@ def make_deferred_related(factory: type[Factory[T]], fixture: str, attr: str) ->
     """
     name = SEPARATOR.join((fixture, attr))
 
-    def deferred_impl(request: SubRequest) -> Any:
+    def deferred_impl(request: SubRequest) -> object:
         return request.getfixturevalue(name)
 
     return DeferredFunction(
@@ -453,11 +465,11 @@ def make_deferred_postgen(
     step: BuildStep,
     factory_class: type[Factory[T]],
     fixture: str,
-    instance: Any,
+    instance: T,
     attr: str,
     declaration: PostGenerationDeclaration,
     context: PostGenerationContext,
-) -> DeferredFunction[T]:
+) -> DeferredFunction[T, object]:
     """Make deferred function for the post-generation declaration.
 
     :param step: factory_boy builder step.
@@ -472,7 +484,7 @@ def make_deferred_postgen(
     """
     name = SEPARATOR.join((fixture, attr))
 
-    def deferred_impl(request: SubRequest) -> Any:
+    def deferred_impl(request: SubRequest) -> object:
         return declaration.call(instance, step, context)
 
     return DeferredFunction(
@@ -493,13 +505,13 @@ def attr_fixture(request: SubRequest, value: T) -> T:
     return value
 
 
-def subfactory_fixture(request: SubRequest, factory_class: type[Factory[object]]) -> Any:
+def subfactory_fixture(request: SubRequest, factory_class: type[Factory[object]]) -> object:
     """SubFactory/RelatedFactory fixture implementation."""
     fixture = inflection.underscore(factory_class._meta.model.__name__)
     return request.getfixturevalue(fixture)
 
 
-def get_caller_locals(depth: int = 0) -> dict[str, Any]:
+def get_caller_locals(depth: int = 0) -> dict[str, object]:
     """Get the local namespace of the caller frame."""
     return sys._getframe(depth + 2).f_locals
 

src/pytest_factoryboy/plugin.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any
 
 import pytest
 from _pytest.config import PytestPluginManager
@@ -25,12 +24,12 @@ class Request:
 
     def __init__(self) -> None:
         """Create pytest_factoryboy request."""
-        self.deferred: list[list[DeferredFunction[object]]] = []
-        self.results: dict[str, dict[str, Any]] = defaultdict(dict)
+        self.deferred: list[list[DeferredFunction[object, object]]] = []
+        self.results: dict[str, dict[str, object]] = defaultdict(dict)
         self.model_factories: dict[str, type[Factory[object]]] = {}
-        self.in_progress: set[DeferredFunction[object]] = set()
+        self.in_progress: set[DeferredFunction[object, object]] = set()
 
-    def defer(self, functions: list[DeferredFunction[object]]) -> None:
+    def defer(self, functions: list[DeferredFunction[object, object]]) -> None:
         """Defer post-generation declaration execution until the end of the test setup.
 
         :param functions: Functions to be deferred.
@@ -65,7 +64,10 @@ def get_current_deps(self, request: FixtureRequest | SubRequest) -> set[str]:
         return deps
 
     def execute(
-        self, request: SubRequest, function: DeferredFunction[object], deferred: list[DeferredFunction[object]]
+        self,
+        request: SubRequest,
+        function: DeferredFunction[object, object],
+        deferred: list[DeferredFunction[object, object]],
     ) -> None:
         """Execute deferred function and store the result."""
         if function in self.in_progress:

tests/test_factory_fixtures.py

@@ -12,8 +12,6 @@
 from pytest_factoryboy import LazyFixture, register
 
 if TYPE_CHECKING:
-    from typing import Any
-
     from factory.declarations import LazyAttribute
 
 
@@ -77,7 +75,7 @@ class Meta:
     register_user__password = "qwerty"  # Make sure fixture is generated
 
     @factory.post_generation
-    def register_user(author: Author, create: bool, username: str | None, **kwargs: Any) -> None:
+    def register_user(author: Author, create: bool, username: str | None, **kwargs: object) -> None:
         """Register author as a user in the system."""
         if username is not None:
             author.user = UserFactory(username=username, **kwargs)

tests/test_postgen_dependencies.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
@@ -12,8 +13,6 @@
 from pytest_factoryboy import register
 
 if TYPE_CHECKING:
-    from typing import Any
-
     from pytest_factoryboy.plugin import Request
 
 
@@ -34,7 +33,7 @@ def set_number(self, new_number: int = 987) -> None:
 
     # NOTE: following attributes are used internally only for assertions
     _create: bool | None = None
-    _postgeneration_results: dict[str, Any] = field(default_factory=dict)
+    _postgeneration_results: dict[str, object] = field(default_factory=dict)
 
 
 @dataclass
@@ -70,7 +69,7 @@ class Meta:
     number = factory.PostGenerationMethodCall("set_number")
 
     @factory.post_generation
-    def set1(foo: Foo, create: bool, value: Any, **kwargs: Any) -> str:
+    def set1(foo: Foo, create: bool, value: object, **kwargs: object) -> str:
         foo.value = 1
         return "set to 1"
 
@@ -82,7 +81,7 @@ def set2(foo, create, value, **kwargs):
             foo.value = value
 
     @classmethod
-    def _after_postgeneration(cls, obj: Foo, create: bool, results: dict[str, Any] | None = None) -> None:
+    def _after_postgeneration(cls, obj: Foo, create: bool, results: Mapping[str, object] | None = None) -> None:
         obj._postgeneration_results = results or {}
         obj._create = create
 
@@ -190,7 +189,7 @@ class Meta:
 
         @classmethod
         def _after_postgeneration(
-            cls, obj: dict[str, Any], create: bool, results: dict[str, Any] | None = None
+            cls, obj: Mapping[str, object], create: bool, results: Mapping[str, object] | None = None
         ) -> None:
             obj.setdefault("_after_postgeneration_calls", []).append((obj, create, results))
 
@@ -218,11 +217,11 @@ class Meta:
         model = Ordered
 
     @factory.post_generation
-    def zzz(obj: Ordered, create: bool, val: Any, **kwargs: Any) -> None:
+    def zzz(obj: Ordered, create: bool, val: object, **kwargs: object) -> None:
         obj.value = "zzz"
 
     @factory.post_generation
-    def aaa(obj: Ordered, create: bool, val: Any, **kwargs: Any) -> None:
+    def aaa(obj: Ordered, create: bool, val: object, **kwargs: object) -> None:
         obj.value = "aaa"