Correct way to generate dynamic factories based on Input

[dmsfabiano]

First of all, love polyfactory. I had a major pain point with factory_boy, where it's difficult to generate different objects based on parameters, and after reading the polyfactory docs, i couldn't find anythign on how to laverage this.

My use case is simple:
I have a pydantic base model that all it does is to ensure that that it has a class method defined, which is a dict version of the model (the reason why I am not just using pydantic_model.dict is outside of the scope of polyfactory, I have a few issues on pydantic repo that are pending fixes)

class ModelIO(BaseModel):
    @classmethod
    @abstractmethod
    def example(cls) -> Dict:
        ...

Now, all I want to do is generated ModelIO objects that have one field, the field can be either a list of intergers, a random dataframe, or numpy array of integers.

On factory_boy, I would have to do something like this

class ObjectNativeType(BaseModel):
    inner_param: list

class ObjectNDType(BaseModel):
    inner_param: ndarray

    class Config:
        arbitrary_types_allowed = True

class ObjectDFType(BaseModel):
    inner_param: DataFrame

    class Config:
        arbitrary_types_allowed = True

 
class ObjectNativeFactory(factory.Factory):
    class Meta:
        model = ObjectNativeType
    inner_param = factory.Faker("pylist", value_types=[int, float, str])

 
class ObjectNDFactory(factory.Factory):
    class Meta:
        model = ObjectNDType

    @factory.lazy_attribute
    def inner_param(self):
        return asarray(factory.Faker("pylist", value_types=[int]))

class ObjectDFFactory(factory.Factory):
    class Meta:
        model = ObjectDFType

    @factory.lazy_attribute
    def inner_param(self):
        return DataFrame.from_dict(factory.Faker("pydict", value_types=[int, float, str]))

after this, I would have to make specific ModelIO classes for each of this scenarios and after that, i would have to make a factory for all of those 3 🤯 mainly because factory_boy doesnt allow easily to set the class Meta.model dynamically

my dream scenario would be to do something like factory(native=true) which would generate ModelIO object where the field is a list or something like factory(cls_type=ndarray)

This is an over simplified example of my use case, but it pretty much applies to any dynamically created classes/objects from an abstract class that validates certain requirements.

I am more than happy to contribute with an example in the documentation after I understand a bit more if polyfactory has some tools to handle these scenarios

[Goldziher]

Hi. You can override the factory's process_kwargs method to achieve what you want.

[dmsfabiano]

Thank you for the super quick feedback - Could you elaborate with a small snippet?

[Goldziher]

So, something like this

from typing import Generic
from polyfactory.factories.pydantic_factory import ModelFactory, T

class MyModelFactory(ModelFactory[T], Generic[T]):
    __base_factory__ = True

    @classmethod
    def process_kwargs(cls, **kwargs: Any) -> dict[str, Any]:
        if inner_param := getattr(cls.__model__, "inner_param", None):
            # do something here
        super().process_kwargs(**kwargs)

[ivan-koverdyaev]

I have a slightly different case, but quite similar. I need to set values for fairly nested factories and doing it explicitly is not very convenient.
If you do this

from polyfactory import BaseFactory
from polyfactory.factories.pydantic_factory import ModelFactory as BaseModelFactory, T
from pydantic import BaseModel


class ModelFactory(BaseModelFactory, Generic[T], BaseFactory[T]):
    __delimiter = '__'
    __model__ = BaseModel

    @classmethod
    def _get_nested_model_class(cls, field_name) -> Type[BaseModel]:
        return cls.__model__.__fields__[field_name].annotation

    @classmethod
    def _process_nested_model_kwargs(cls, nested_model_name: str, **kwargs: dict[str, Any]) -> BaseModel:
        nested_model_class = cls._get_nested_model_class(nested_model_name)
        nested_factory = cls.create_factory(model=nested_model_class)
        return nested_factory.build(**kwargs)

    @classmethod
    def process_kwargs(cls, **kwargs: dict[str, Any]) -> dict[str, Any]:
        _kwargs = {}
        nested_kwargs = defaultdict(dict)
        for key, value in kwargs.items():
            if cls.__delimiter in key:
                sub_key, nested_key = key.split(cls.__delimiter, maxsplit=1)
                nested_kwargs[sub_key][nested_key] = value
            else:
                _kwargs[key] = value
        for nested_model_name, nested_model_kwargs in nested_kwargs.items():
            nested_model = cls._process_nested_model_kwargs(nested_model_name, **nested_model_kwargs)
            _kwargs[nested_model_name] = nested_model
        return super().process_kwargs(**_kwargs)

you can set the parameters of nested models on the fly like that

class DeeplyNestedModel(BaseModel):
    buz: int

class NestedModel(BaseModel):
    bar: str
    nested: DeeplyNestedModel

class MainModel(BaseModel):
    foo: str
    nested: NestedModel

class MainModelFactory(ModelFactory[MainModel]):
    __model__ = MainModel
    
MainModelFactory.build(
    nested__bar='test',
    nested__nested__buz=42,
)

It turned out to be a little dirty, but it works for me. I hope it will be useful to someone else.

[aleksei-dolzhenkov]

@ivan-koverdyaev Nice work)

Instead of having __model__ = BaseModel in new ModelFactory, just set __is_base_factory__ = True