feat: autofill model argument when calling create_factory with receiving factory __model__

docs/examples/declaring_factories/test_example_8.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from polyfactory.factories import DataclassFactory
+
+
+class Species(str, Enum):
+    CAT = "Cat"
+    DOG = "Dog"
+    RABBIT = "Rabbit"
+    MOUSE = "Mouse"
+
+
+@dataclass
+class Pet:
+    name: str
+    species: Species
+    sound: str
+
+
+def test_imperative_sub_factory_creation() -> None:
+    pet_factory = DataclassFactory.create_factory(model=Pet)
+    cat_factory = pet_factory.create_factory(species=Species.CAT)
+    cat_instance = cat_factory.build()
+
+    assert isinstance(cat_instance, Pet)
+    assert cat_instance.species == Species.CAT

docs/usage/declaring_factories.rst

@@ -56,3 +56,11 @@ You can also use this method to create factories imperatively:
 .. literalinclude:: /examples/declaring_factories/test_example_6.py
     :caption: Imperative factory creation
     :language: python
+
+Eventually you can use this method on an existing concrete factory to create a sub factory overriding some parent configuration:
+
+.. literalinclude:: /examples/declaring_factories/test_example_8.py
+    :caption: Imperative sub factory creation
+    :language: python
+
+In this case you don't need to specify the `model` argument to the :meth:`create_factory <polyfactory.factories.base.BaseFactory.create_factory>` method. The one from the parent factory will be used.

polyfactory/factories/base.py

@@ -426,19 +426,26 @@ def _create_generic_fn() -> Callable:
     @classmethod
     def create_factory(
         cls: type[F],
-        model: type[T],
+        model: type[T] | None = None,
         bases: tuple[type[BaseFactory[Any]], ...] | None = None,
         **kwargs: Any,
     ) -> type[F]:
         """Generate a factory for the given type dynamically.
 
-        :param model: A type to model.
+        :param model: A type to model. Defaults to current factory __model__ if any.
+            Otherwise, raise an error
         :param bases: Base classes to use when generating the new class.
         :param kwargs: Any kwargs.
 
         :returns: A 'ModelFactory' subclass.
 
         """
+        with suppress(AttributeError):
+            model = model or cls.__model__
+        if model is None:
+            msg = "A 'model' argument is required when creating a new factory from a base one"
+            raise TypeError(msg)
+
         return cast(
             "Type[F]",
             type(

tests/test_base_factories.py

@@ -5,6 +5,7 @@
 from pydantic.main import BaseModel
 
 from polyfactory.factories import DataclassFactory
+from polyfactory.factories.base import BaseFactory
 from polyfactory.factories.pydantic_factory import ModelFactory
 
 
@@ -78,3 +79,19 @@ class MyFactory(FooModelFactory):
     # see https://github.com/litestar-org/polyfactory/issues/198
     ModelFactory._base_factories.remove(FooModelFactory)
     ModelFactory._base_factories.remove(DummyModelFactory)
+
+
+def test_create_factory_without_model_reuse_current_factory_model() -> None:
+    @dataclass
+    class Foo:
+        pass
+
+    factory = DataclassFactory.create_factory(model=Foo)
+    sub_factory = factory.create_factory()
+
+    assert sub_factory.__model__ == Foo
+
+
+def test_create_factory_from_base_factory_without_providing_a_model_raises_error() -> None:
+    with pytest.raises(TypeError):
+        BaseFactory.create_factory()