Should we use DataclassFactory or ModelFactory for Pydantic dataclasses?

[bjmc]

Modern versions of Pydantic support adding validation on top of native Python dataclasses. If we're looking to use Polyfactory for testing in a codebase featuring these Pydantic data classes, what's the most appropriate Polyfactory factory type?

Should we be using the DataclassFactory or the ModelFactory?

[guacs]

You'll have to use DataclassFactory since it won't work with ModelFactory. However, if you use DataclassFactory, the constraints won't be respected. For example, the following will fail validation by pydantic:

from pydantic.dataclasses import Field, dataclass

from polyfactory.factories.dataclass_factory import DataclassFactory

@dataclass
class Foo:
    foo: int = Field(gt=10000)

class FooFactory(DataclassFactory[Foo]):
    __model__ = Foo

foo = FooFactory.build()

[bjmc]

Thanks for the quick reply! But also...oof. That's a pretty significant drawback, isn't it? Would you be open to a PR to improve that situation?

Or maybe I should be looking to replace all these dataclasses with native Pydantic models... 🤔

[guacs]

A PR would definitely be appreciated :)

Also, I agree that you should consider switching to Pydantic models (or even better, msgspec Structs). Out of curiosity, why did you go with pydantic dataclasses instead of Pydantic BaseModel?

[bjmc]

why did you go with pydantic dataclasses instead of Pydantic BaseModel?

There didn't seem to be any compelling advantages to BaseModel and using dataclasses keeps us closer to vanilla Python code if we ever decide we want to drop Pydantic.

msgspec Structs

Oh no, yet another choice! It seems like their main selling point is performance... but the Pydantic v2 core is in Rust and very fast.

[euri10]

Oh no, yet another choice! It seems like their main selling point is performance... but the Pydantic v2 core is in Rust and very fast.

that should keep you entertained :) https://jcristharif.com/msgspec/benchmarks.html#benchmarks

[Slyces]

This discussion is fairly old. However, in case someone decides to use pydantic dataclasses with polyfactory, for whatever reason (mine is that I already use pydantic for my REST layer but wanted validation on some dataclasses), here's a small piece of code that adds support for it (at least for my use-cases so far):

"""Extensions for the `polyfactory` library."""
from __future__ import annotations

from dataclasses import is_dataclass
from typing import TYPE_CHECKING
from typing import Any
from typing import TypeGuard

from polyfactory.factories.base import T
from polyfactory.factories.pydantic_factory import ModelFactory
from polyfactory.factories.pydantic_factory import PydanticFieldMeta
from polyfactory.field_meta import FieldMeta

if TYPE_CHECKING:
    from pydantic.dataclasses import PydanticDataclass


def _is_pydantic_dataclass(value: Any) -> TypeGuard[PydanticDataclass]:
    return bool(is_dataclass(value) and hasattr(value, "__pydantic_config__"))


class PydanticDataclassFactory(ModelFactory[T]):
    """Abstract factory building on top of Pydantic Model factory factory to
    provide support for pydantic dataclasses *including constraints*.
    """


    # Open discussion on this topic:
    # https://github.com/litestar-org/polyfactory/discussions/393

    __is_base_factory__ = True

    @classmethod
    def is_supported_type(cls, value: Any) -> TypeGuard[type[T]]:
        return _is_pydantic_dataclass(value)

    @classmethod
    def get_model_fields(cls) -> list[FieldMeta]:
        assert _is_pydantic_dataclass(cls.__model__)

        pydantic_fields = cls.__model__.__pydantic_fields__
        pydantic_config = cls.__model__.__pydantic_config__
        cls._fields_metadata = [
            PydanticFieldMeta.from_field_info(
                field_info=field_info,
                field_name=field_name,
                random=cls.__random__,
                use_alias=not pydantic_config.get(
                    "populate_by_name",
                    False,
                ),
            )
            for field_name, field_info in pydantic_fields.items()
        ]

        return cls._fields_metadata

[guacs]

@Slyces this looks great! If you'd be willing, I think a PR for this new factory would be greatly appreciated. I'm sure there are a lot of other people using pydantic dataclasses and using the pydantic APIs for that would be the best.

[Slyces]

#605