Creating "sub" factories with different configuration on the fly

[g0di]

Recently I wanted to restrict the list of possible values for one of my factory so I could get several factories producing objects which can have some properties with unique/non overlapping values.

The thing is, my factory already define several custom generators for various properties of my objects and I didn't wanted to duplicate those. Also, I wanted to be able to do it on the fly (imperative style) (for example on test cases)

For example, I would like to do the following

from polyfactory import Use
from polyfactory.factories.pydantic_factory import ModelFactory
from pydantic import BaseModel


class Foo(BaseModel):
    foo: int
    bar: str


class FooModelFactory(ModelFactory[Foo]):
    __model__ = Foo

    foo = Use(ModelFactory.__random__.choice, [1, 2, 3])


characters_foo_factory = FooModelFactory.use(
    bar=Use(ModelFactory.__random__choice, ["a", "b"])
)
digits_foo_factory = FooModelFactory.use(
    bar=Use(ModelFactory.__random__choice, ["1", "2"])
)

Here, both created "sub" factories will have the same generator for foo define in the FooModelFactory class but a different bargenerator.

I often encounter this case during my tests where I need my factory to produce unique objects or objects with some properties not having particular values (when you test filtering for some DAO for example).

At the moment, I've managed it by subclassing mysef the ModelFactory class but I'm wondering if it could be integrated in the library itself.

from typing import Any, Generic, Literal, TypeVar

from polyfactory import Use
from polyfactory.factories.pydantic_factory import ModelFactory
from pydantic import BaseModel

TBaseModel = TypeVar("TBaseModel", bound=BaseModel)


class MintModelFactory(Generic[TBaseModel], ModelFactory[TBaseModel]):
    __is_base_factory__ = True

    @classmethod
    def use(cls, **kwargs: Any) -> type[MintModelFactory[TBaseModel]]:
        """Subclass current factory with different configuration.

        This is particularly useful to create a sub factory with different values
        to use for generation.
        """
        return cls.create_factory(cls.__model__, **kwargs)

typings might not be accurate enough

Basically I'm just leveraging the create_factory function to create a factory, on the fly, inheriting the current factory and automatically reusing the same model. This is quicker to do than using the create_factory function directly and feels less awkward because you don"t have to pass again the model

# Current
sub_factory = FooModelFactory.create_factory(Foo, bar=Use(FooModelFactory.__random__choice, [1, 2, 3]))
# suggestion
sub_factory = FooModelFactory.use(bar=Use(FooModelFactory.__random__choice, [1, 2, 3]))

Note that I'm not sure if this could have any particular downsides

Maybe that could be done by simply updating the create_factory function to defaults model to the current __model__ if the factory is not an abstract factory.

Cheers

[guacs]

I think this is reasonable though I'm not in favor of adding a new API for this. Instead, I think we can go with the solution you mentioned of setting the default value to the model parameter in the create_factory class method. If you're willing to do this, please do raise a PR :) The only thing is that the change should be made in such a way that it does stays backwards compatible.

[g0di]

Thanks for your answer. I'm fine with sticking to the create_factory function. I do not guarantee I'll have time to do a PR, I'll do my best