Support type hinting?

[pgcd]

I can't seem to have PyCharm play nice with the objects generated by Factory Boy; it would be nice to either automatically support type hinting somehow (ideally, it would simply be the model defined as a base for the factory) or at least add some documentation to explain how to have type checkers understand that,
after p = PersonFactory(), variuable p is actually an instance of Person rather than of PersonFactory.

(Note: I'm not submitting a PR because I haven't figured out a solution)

[rbarrois]

Yep, that would be a great idea! But I'm not sure how this could be easily done.

A simple workaround could be to use p = PersonFactory.create() — it does the same as PersonFactory(), but shouldn't trigger the same paths in PyCharm.

[ktosiek]

for me PyCharm can't even find the PersonFactory.create() (I guess because of the call to FactoryMetaClass?), so some hints would probably help.

As for the PersonFactory() syntax, there might be no way to make it work at the moment: python/mypy#1020

[therefromhere]

I haven't tried this with Mypy, but this will get the case of p = PersonFactory() to type hint correctly in Pycharm:

class PersonFactory(factory.Factory):
    class Meta:
        model = Person

    # Type hinting PersonFactory()
    def __new__(cls, *args, **kwargs) -> "PersonFactory.Meta.model":
        return super().__new__(*args, **kwargs)

Currently I'm doing this for each factory as a quick and dirty fix. Hopefully it's possible to move this up to the parent Factory class, maybe using Generics? (https://mypy.readthedocs.io/en/stable/generics.html )

[ProProgrammer]

Has anyone tried type hinting with a DjangoModelFactory that derives from another factory whose Meta.abstract value is set to True

E.g.

@factory.django.mute_signals(signals.pre_save, signals.post_save)
class AnimalFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Animal
        abstract = True

    # Some fields that might include foreign key in which case we use factory.SubFactory
    creature_type = 'animal'

    ## As mentioned by @therefromhere 
    def __new__(cls, *args, **kwargs) -> "AnimalFactory.Meta.model":
        return super().__new__(*args, **kwargs)

@factory.django.mute_signals(signals.pre_save, signals.post_save)
class DogFactory(AnimalFactory):
    class Meta:
        model = Dog

    # Some fields as defined in Dog Class that inherits from Animal class.
    # Since in reality, Dog class inherits from Animal class, the Dog class would have Animal classes attributes (methods, properties) too
    creature_species = 'dog'

    # As mentioned by @therefromhere 
    def __new__(cls, *args, **kwargs) -> "DogFactory.Meta.model":
        return super().__new__(*args, **kwargs)

Now the problem that I face here is, in the __new__ for DogFactory, PyCharm shows InspectionWarning for return super().__new__(*args, **kwargs) because I have mentioned the return type as DogFactory.Meta.model whereas super() here references the AnimalFactory from which the DogFactory derives itself.

So how should we handle this?

[michaeloliverx]

Typing support would be really nice!

[kamilglod]

my workaround for missing General protocol is as follow:

T = TypeVar("T")


class BaseFactory(Generic[T], factory.Factory):
    @classmethod
    def create(cls, **kwargs) -> T:
        return super().create(**kwargs)


class RoleFactory(BaseFactory[Role]):
    class Meta:
        model = Role

    id = factory.Sequence(lambda n: n)
    name = factory.Sequence(lambda n: f"Role {n}")

one drawback of this solution is that you always need to use Factory.create() instead of Factory() as it's not possible (at least I didn't find a proper solution) to override __new__() method with TypeVar.

[nyk510]

@kamilglod I think it's a great workaround! Thank you!

[Ragura]

Thanks @kamilglod for the excellent workaround. There's still the issue of the @factory.post_generation decorated functions thinking the first parameter of the function is the factory instance and not an instance of the recently created object. Do you happen to have a solution for this as well (aside from manually annotating the first argument)?

[kamilglod]

@Ragura good question. All ideas that comes to my mind are equally complicated as manually typing first argument each time new method is added. It might be possible on python 3.10 which comes with better params typing support (https://docs.python.org/3.10/library/typing.html#typing.ParamSpec) but I do not have enough spare time to dig into it. I was trying to override post_generation class like this:

class post_generation(Generic[T]):
    def __init__(self, func: Callable[[BaseFactory[T], Callable, bool], str]):
        self.func = func

    def __call__(self) -> Callable[[T, Callable, bool], str]:
        return factory.post_generation(self.func)

but mypy still does not see obj as with overwritten type:

class RoleFactory(BaseFactory[Role]):
    class Meta:
        model = Role

    id = factory.Sequence(lambda n: n)
    name = factory.Sequence(lambda n: f"Role {n}")

    @post_generation
    def mbox(obj, create, extracted, **kwargs):
        reveal_type(obj)  # Type of "obj" is "RoleFactory"
        return "foo"

[yunuscanemre]

I'm using this trick currently which seems to play nice with the (Pylance) type checker in vscode.

from typing import Generic, TypeVar

import factory

T = TypeVar('T')

class BaseMetaFactory(Generic[T], factory.base.FactoryMetaClass):
    def __call__(cls, *args, **kwargs) -> T:
        return super().__call__(*args, **kwargs)

class MyModel:
    pass

class MyModelFactory(factory.Factory, metaclass=BaseMetaFactory[MyModel]):
    class Meta:
        model = MyModel

test_model = MyModelFactory()

[tgross35]

As far as what changes could actually be implemented in this library - FactoryBoy just needs to aim for mypy compliance. This really wouldn't be terrible, adding type hints is always relatively quick. I'd assume the maintainers would be open to a related PR.

The trickiest problem is what's discussed here, binding a "generic" type to the type of a meta class member. To my knowledge this unfortunately isn't directly possible. That means using the generics (per @kamilglod) is the most accurate way to accomplish this, to my knowledge. The downside is, of course, that the user must then specify the model in two places (in the base class generic binding, and in the metaclass) but at least having this option would be huge, and would mean that FactoryBoy could reach mypy compliance using generics until (if) a better binding method is discovered.

I am currently on a hunt to figure out if there's a better way to bind typevars to class members or metaclass members (for something unrelated), currently with 0 luck. My stackoverflow question is as-of now unsuccessful, I'm still hoping for a response on the python discord as a fallback.

[n1ngu]

I am currently on a hunt to figure out if there's a better way to bind typevars to class members or metaclass members

@tgross35 My actual factory declarations are most usually defined with string values in their meta model, either future references or keys for a class registry to avoid import-time troubles while an application / DB connection are not ready. The get_model_class method from the factory options will lazily return the actual model at runtime, but statically it might be not accessible. The generics way feels like the correct solution to me. Pursuing that typevar-member binding is an interesting study field, but unsuitable for factory_boy IMHO.

I'm using this trick currently which seems to play nice with the (Pylance) type checker in vscode.

@yunuscanemre Just watch out for the tricky StubObject that can potentially be returned from any factory declared with strategy = "stub". Not a common use case as far as I know, but I'd rather stick to the explicit .create, .build and .stub methods and their _batch counterparts than use the meta __call__. Less meta magic and quite more semantic code along a simpler execution path.