refactor!: remove deprecated elements (#703)f

Author: adhtruong

docs/examples/library_factories/sqlalchemy_factory/test_example_2.py

@@ -28,16 +28,16 @@ class Book(Base):
 class AuthorFactory(SQLAlchemyFactory[Author]): ...
 
 
-class AuthorFactoryWithRelationship(SQLAlchemyFactory[Author]):
-    __set_relationships__ = True
+class AuthorFactoryWithoutRelationship(SQLAlchemyFactory[Author]):
+    __set_relationships__ = False
 
 
 def test_sqla_factory() -> None:
     author = AuthorFactory.build()
-    assert author.books == []
-
-
-def test_sqla_factory_with_relationship() -> None:
-    author = AuthorFactoryWithRelationship.build()
     assert isinstance(author, Author)
     assert isinstance(author.books[0], Book)
+
+
+def test_sqla_factory_without_relationship() -> None:
+    author = AuthorFactoryWithoutRelationship.build()
+    assert author.books == []

docs/examples/library_factories/sqlalchemy_factory/test_example_association_proxy.py

@@ -41,7 +41,9 @@ class Keyword(Base):
     keyword: Mapped[str]
 
 
-class UserFactory(SQLAlchemyFactory[User]): ...
+class UserFactory(SQLAlchemyFactory[User]):
+    __set_relationships__ = False
+    __set_association_proxy__ = False
 
 
 class UserFactoryWithAssociation(SQLAlchemyFactory[User]):

docs/usage/library_factories/sqlalchemy_factory.rst

@@ -19,7 +19,7 @@ SQLAlchemyFactory allows to override some configuration attributes so that a des
 Relationship
 ++++++++++++
 
-By default, ``__set_relationships__`` is set to ``False``. If it is ``True``, all fields with the SQLAlchemy `relationship() <relationship()_>`_ will be included in the result created by ``build`` method.
+By default, ``__set_relationships__`` is set to ``True``. If it is ``True``, all fields with the SQLAlchemy `relationship() <relationship()_>`_ will be included in the result created by ``build`` method.
 
 .. literalinclude:: /examples/library_factories/sqlalchemy_factory/test_example_2.py
     :caption: Setting relationships
@@ -34,7 +34,7 @@ By default, ``__set_relationships__`` is set to ``False``. If it is ``True``, al
 Association Proxy
 +++++++++++++++++
 
-By default, ``__set_association_proxy__`` is set to ``False``. If it is ``True``, all SQLAlchemy fields mapped to ORM `Association Proxy <Association Proxy_>`_ class will be included in the result created by ``build`` method.
+By default, ``__set_association_proxy__`` is set to ``True``. If it is ``True``, all SQLAlchemy fields mapped to ORM `Association Proxy <Association Proxy_>`_ class will be included in the result created by ``build`` method.
 
 .. literalinclude:: /examples/library_factories/sqlalchemy_factory/test_example_association_proxy.py
     :caption: Setting association_proxy

polyfactory/__init__.py

@@ -1,13 +1,12 @@
 from .exceptions import ConfigurationException
 from .factories import BaseFactory
-from .fields import Fixture, Ignore, PostGenerated, Require, Use
+from .fields import Ignore, PostGenerated, Require, Use
 from .persistence import AsyncPersistenceProtocol, SyncPersistenceProtocol
 
 __all__ = (
     "AsyncPersistenceProtocol",
     "BaseFactory",
     "ConfigurationException",
-    "Fixture",
     "Ignore",
     "PostGenerated",
     "Require",

polyfactory/collection_extender.py

@@ -54,9 +54,7 @@
 )
 from polyfactory.exceptions import ConfigurationException, MissingBuildKwargException, ParameterException
 from polyfactory.field_meta import Null
-from polyfactory.fields import Fixture, Ignore, PostGenerated, Require, Use
-from polyfactory.utils._internal import is_attribute_overridden
-from polyfactory.utils.deprecation import warn_deprecation
+from polyfactory.fields import Ignore, PostGenerated, Require, Use
 from polyfactory.utils.helpers import (
     flatten_annotation,
     get_collection_type,
@@ -116,7 +114,7 @@ class BaseFactory(ABC, Generic[T]):
     The model for the factory.
     This attribute is required for non-base factories and an exception will be raised if it's not set. Can be automatically inferred from the factory generic argument.
     """
-    __check_model__: bool = False
+    __check_model__: bool = True
     """
     Flag dictating whether to check if fields defined on the factory exists on the model or not.
     If 'True', checks will be done against Use, PostGenerated, Ignore, Require constructs fields only.
@@ -202,7 +200,7 @@ class BaseFactory(ABC, Generic[T]):
     _extra_providers: dict[Any, Callable[[], Any]] | None = None
     """Used to copy providers from once base factory to another dynamically generated factory for a class"""
 
-    def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:  # noqa: C901, PLR0912
+    def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
         super().__init_subclass__(*args, **kwargs)
 
         if not hasattr(BaseFactory, "_base_factories"):
@@ -216,36 +214,10 @@ def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:  # noqa: C901, PL
 
         if cls.__min_collection_length__ > cls.__max_collection_length__:
             msg = "Minimum collection length shouldn't be greater than maximum collection length"
-            raise ConfigurationException(
-                msg,
-            )
+            raise ConfigurationException(msg)
 
         if "__is_base_factory__" not in cls.__dict__ or not cls.__is_base_factory__:
-            model: type[T] | None = getattr(cls, "__model__", None) or cls._infer_model_type()
-            if not model:
-                msg = f"required configuration attribute '__model__' is not set on {cls.__name__}"
-                raise ConfigurationException(
-                    msg,
-                )
-            cls.__model__ = model
-            if not cls.is_supported_type(model):
-                for factory in BaseFactory._base_factories:
-                    if factory.is_supported_type(model):
-                        msg = f"{cls.__name__} does not support {model.__name__}, but this type is supported by the {factory.__name__} base factory class. To resolve this error, subclass the factory from {factory.__name__} instead of {cls.__name__}"
-                        raise ConfigurationException(
-                            msg,
-                        )
-                    msg = f"Model type {model.__name__} is not supported. To support it, register an appropriate base factory and subclass it for your factory."
-                    raise ConfigurationException(
-                        msg,
-                    )
-            if is_attribute_overridden(BaseFactory, cls, "__check_model__"):
-                warn_deprecation(
-                    "v2.22.0",
-                    deprecated_name="__check_model__",
-                    kind="default",
-                    alternative="set to `False` explicitly to keep existing behaviour",
-                )
+            cls._init_model()
             if cls.__check_model__:
                 cls._check_declared_fields_exist_in_model()
         else:
@@ -258,6 +230,27 @@ def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:  # noqa: C901, PL
         if cls.__set_as_default_factory_for_type__ and hasattr(cls, "__model__"):
             BaseFactory._factory_type_mapping[cls.__model__] = cls
 
+    @classmethod
+    def _init_model(cls) -> None:
+        model: type[T] | None = getattr(cls, "__model__", None) or cls._infer_model_type()
+        if not model:
+            msg = f"required configuration attribute '__model__' is not set on {cls.__name__}"
+            raise ConfigurationException(
+                msg,
+            )
+        cls.__model__ = model
+        if not cls.is_supported_type(model):
+            for factory in BaseFactory._base_factories:
+                if factory.is_supported_type(model):
+                    msg = f"{cls.__name__} does not support {model.__name__}, but this type is supported by the {factory.__name__} base factory class. To resolve this error, subclass the factory from {factory.__name__} instead of {cls.__name__}"
+                    raise ConfigurationException(
+                        msg,
+                    )
+                msg = f"Model type {model.__name__} is not supported. To support it, register an appropriate base factory and subclass it for your factory."
+                raise ConfigurationException(
+                    msg,
+                )
+
     @classmethod
     def _get_build_context(cls, build_context: BuildContext | None) -> BuildContext:
         """Return a BuildContext instance.
@@ -323,7 +316,7 @@ def _get_async_persistence(cls) -> AsyncPersistenceProtocol[T]:
         )
 
     @classmethod
-    def _handle_factory_field(  # noqa: PLR0911
+    def _handle_factory_field(
         cls,
         field_value: Any,
         build_context: BuildContext,
@@ -350,9 +343,6 @@ def _handle_factory_field(  # noqa: PLR0911
         if isinstance(field_value, Use):
             return field_value.to_value()
 
-        if isinstance(field_value, Fixture):
-            return field_value.to_value()
-
         if callable(field_value):
             return field_value()
 
@@ -387,9 +377,6 @@ def _handle_factory_field_coverage(
         if isinstance(field_value, Use):
             return field_value.to_value()
 
-        if isinstance(field_value, Fixture):
-            return CoverageContainerCallable(field_value.to_value)
-
         return CoverageContainerCallable(field_value) if callable(field_value) else field_value
 
     @classmethod

polyfactory/factories/base.py

@@ -14,7 +14,6 @@
 from polyfactory.factories.base import BaseFactory, BuildContext
 from polyfactory.factories.base import BuildContext as BaseBuildContext
 from polyfactory.field_meta import Constraints, FieldMeta, Null
-from polyfactory.utils.deprecation import check_for_deprecated_parameters
 from polyfactory.utils.helpers import unwrap_new_type, unwrap_optional
 from polyfactory.utils.normalize_type import normalize_type
 from polyfactory.utils.predicates import is_annotated, is_optional, is_safe_subclass, is_union
@@ -90,7 +89,6 @@
 
 if TYPE_CHECKING:
     from collections import abc
-    from random import Random
     from typing import Callable, Sequence
 
     from typing_extensions import NotRequired, TypeGuard
@@ -120,7 +118,6 @@ def __init__(
         *,
         name: str,
         annotation: type,
-        random: Random | None = None,
         default: Any = ...,
         children: list[FieldMeta] | None = None,
         constraints: PydanticConstraints | None = None,
@@ -129,7 +126,6 @@ def __init__(
         super().__init__(
             name=name,
             annotation=annotation,
-            random=random,
             default=default,
             children=children,
             constraints=constraints,
@@ -142,32 +138,15 @@ def from_field_info(
         field_name: str,
         field_info: FieldInfo,
         use_alias: bool,
-        random: Random | None = None,
-        randomize_collection_length: bool | None = None,
-        min_collection_length: int | None = None,
-        max_collection_length: int | None = None,
     ) -> PydanticFieldMeta:
         """Create an instance from a pydantic field info.
 
         :param field_name: The name of the field.
         :param field_info: A pydantic FieldInfo instance.
         :param use_alias: Whether to use the field alias.
-        :param random: A random.Random instance.
-        :param randomize_collection_length: Whether to randomize collection length.
-        :param min_collection_length: Minimum collection length.
-        :param max_collection_length: Maximum collection length.
 
         :returns: A PydanticFieldMeta instance.
         """
-        check_for_deprecated_parameters(
-            "2.11.0",
-            parameters=(
-                ("randomize_collection_length", randomize_collection_length),
-                ("min_collection_length", min_collection_length),
-                ("max_collection_length", max_collection_length),
-                ("random", random),
-            ),
-        )
         field_info = FieldInfo.merge_field_infos(
             field_info, FieldInfo.from_annotation(normalize_type(field_info.annotation))
         )
@@ -240,32 +219,14 @@ def from_model_field(  # pragma: no cover
         cls,
         model_field: ModelField,  # pyright: ignore[reportGeneralTypeIssues]
         use_alias: bool,
-        randomize_collection_length: bool | None = None,
-        min_collection_length: int | None = None,
-        max_collection_length: int | None = None,
-        random: Random | None = None,
     ) -> PydanticFieldMeta:
         """Create an instance from a pydantic model field.
         :param model_field: A pydantic ModelField.
         :param use_alias: Whether to use the field alias.
-        :param randomize_collection_length: A boolean flag whether to randomize collections lengths
-        :param min_collection_length: Minimum number of elements in randomized collection
-        :param max_collection_length: Maximum number of elements in randomized collection
-        :param random: An instance of random.Random.
 
         :returns: A PydanticFieldMeta instance.
 
         """
-        check_for_deprecated_parameters(
-            "2.11.0",
-            parameters=(
-                ("randomize_collection_length", randomize_collection_length),
-                ("min_collection_length", min_collection_length),
-                ("max_collection_length", max_collection_length),
-                ("random", random),
-            ),
-        )
-
         if model_field.default is not Undefined:
             default_value = model_field.default
         elif callable(model_field.default_factory):
@@ -410,8 +371,9 @@ class PaymentFactory(ModelFactory[Payment]):
         "__use_examples__",
     )
 
-    def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
-        super().__init_subclass__(*args, **kwargs)
+    @classmethod
+    def _init_model(cls) -> None:
+        super()._init_model()
 
         model = getattr(cls, "__model__", None)
         if model is None: