Correct Way to Create Custom Factory with Constraints

[vkcku]

I tried creating a custom factory for msgspec and I parsed the constraints and passed them in via the FieldMeta.from_type method, but for some reason when the type is bytes, the constraint is not respected. A sample reproduction:

from polyfactory.factories.base import BaseFactory
from polyfactory.factories.base import T
from polyfactory.field_meta import FieldMeta
from typing import Any, Generic, Type, TypeGuard

class Foo:

    _is_x = True

    def __init__(self, x: bytes):

        self.x = x

    def __str__(self) -> str:
        return f"{self.x=}"

class FooBaseFactory(Generic[T], BaseFactory[T]):
    
    __is_base_factory__ = True

    @classmethod
    def is_supported_type(cls, value: Any) -> TypeGuard[Type[T]]:
        return hasattr(value, "_is_x")

    @classmethod
    def get_model_fields(cls) -> list[FieldMeta]:

        return [FieldMeta.from_type(bytes, name="x", constraints={"min_length": 1})]
    
class FooFactory(FooBaseFactory):

    __model__ = Foo

count = 0
while True:

    count += 1
    bar = FooFactory.build()
    assert len(bar.x), f"Length is zero - {bar.x=}"

    if count == 1000:
        break

If the type is str, this is not reproduced. Am I doing something wrong or is this a bug?

[Goldziher]

So, a few things.

First - you can check if a class is a msgspec.Struct rather than check for an _is_x attribute you invented.

Second - you should actually use a Struct as a base class.

Finally, if you want to enforce constraints in msgspec you need to use it's from_builtins and other utils. Otherwise it doesn't perform validation.

You can ask for guidance in their github.

[vkcku]

I think there's a misunderstanding here. I am able to parse the constraints from the Meta class. It's just that even when I do that and give the FieldMeta the constraints, in the case of bytes I'm getting an instance that doesn't follow the constraints.

That is, let's assume I have a property with a constraint of minimum length being 1 and the type being bytes and let's assume I've parsed these details correctly. To create the FieldMeta for that type I would do the following:

constraints = {"min_length": 1}
Field_meta = FieldMeta.from_type(bytes, "property_name", constraints=constraints)

When I do this, there are times when I get bytes that has a length of 0 even though the constraint specifies that the length must be at least 1. You can reproduce this by running that code I've shown in the beginning of the discussion. In that code, there should never be an assertion error since the assertion of the length of the property should never fail since the minimum length specified in the creation of the field meta is 1.

[Goldziher]

I think there's a misunderstanding here. I am able to parse the constraints from the Meta class. It's just that even when I do that and give the FieldMeta the constraints, in the case of bytes I'm getting an instance that doesn't follow the constraints.

That is, let's assume I have a property with a constraint of minimum length being 1 and the type being bytes and let's assume I've parsed these details correctly. To create the FieldMeta for that type I would do the following:

constraints = {"min_length": 1}
Field_meta = FieldMeta.from_type(bytes, "property_name", constraints=constraints)

When I do this, there are times when I get bytes that has a length of 0 even though the constraint specifies that the length must be at least 1. You can reproduce this by running that code I've shown in the beginning of the discussion. In that code, there should never be an assertion error since the assertion of the length of the property should never fail since the minimum length specified in the creation of the field meta is 1.

please submit a full MCVE

[vkcku]

@Goldziher, here's sample code that can reproduce the issue:

from inspect import isclass
from typing import Annotated, Any, Generic, Type

import msgspec
from msgspec import Struct, inspect
from msgspec.inspect import Field
from typing_extensions import TypeGuard

from polyfactory.factories import BaseFactory
from polyfactory.factories.base import T
from polyfactory.field_meta import Constraints, FieldMeta


class MsgspecStructFactory(Generic[T], BaseFactory[T]):
    """A factory for msgspec Structs."""

    __is_base_factory__ = True

    @classmethod
    def is_supported_type(cls, value: Any) -> TypeGuard[Type[T]]:
        return isclass(value) and hasattr(value, "__struct_fields__")

    @classmethod
    def get_model_fields(cls) -> list[FieldMeta]:
        type_info = inspect.type_info(cls.__model__)
        field_metas = [parse_msgspec_field(f) for f in type_info.fields]

        return field_metas


def parse_msgspec_field(f: Field) -> FieldMeta:
    field_type = f.type

    constraints: Constraints = {}
    if isinstance(field_type, inspect.StrType):
        if field_type.min_length is not None:
            constraints["min_length"] = field_type.min_length
        if field_type.max_length is not None:
            constraints["max_length"] = field_type.max_length
        if field_type.pattern is not None:
            constraints["pattern"] = field_type.pattern

        return FieldMeta.from_type(str, f.name, constraints=constraints or None)

    if isinstance(field_type, inspect.BytesType):
        if field_type.min_length is not None:
            constraints["min_length"] = field_type.min_length
        if field_type.max_length is not None:
            constraints["max_length"] = field_type.max_length

        return FieldMeta.from_type(bytes, f.name, constraints=constraints or None)

    msg = "unsupported type"
    raise RuntimeError(msg)

MIN_LENGTH = 10000

class Foo(Struct):
    # min_length is kept at a relatively high number so that the bug is more
    # easily reproducible
    bar: Annotated[bytes, msgspec.Meta(min_length=MIN_LENGTH)]


class FooFactory(MsgspecStructFactory):
    __model__ = Foo


foo: Foo = FooFactory.build()

assert len(foo.bar) >= MIN_LENGTH, f"inavlid length - {len(foo.bar)}"

I looked into it in a bit more detail and the reason for this is that bytes is not included in the tuple here.

[Goldziher]

@Goldziher, here's sample code that can reproduce the issue:

from inspect import isclass
from typing import Annotated, Any, Generic, Type

import msgspec
from msgspec import Struct, inspect
from msgspec.inspect import Field
from typing_extensions import TypeGuard

from polyfactory.factories import BaseFactory
from polyfactory.factories.base import T
from polyfactory.field_meta import Constraints, FieldMeta


class MsgspecStructFactory(Generic[T], BaseFactory[T]):
    """A factory for msgspec Structs."""

    __is_base_factory__ = True

    @classmethod
    def is_supported_type(cls, value: Any) -> TypeGuard[Type[T]]:
        return isclass(value) and hasattr(value, "__struct_fields__")

    @classmethod
    def get_model_fields(cls) -> list[FieldMeta]:
        type_info = inspect.type_info(cls.__model__)
        field_metas = [parse_msgspec_field(f) for f in type_info.fields]

        return field_metas


def parse_msgspec_field(f: Field) -> FieldMeta:
    field_type = f.type

    constraints: Constraints = {}
    if isinstance(field_type, inspect.StrType):
        if field_type.min_length is not None:
            constraints["min_length"] = field_type.min_length
        if field_type.max_length is not None:
            constraints["max_length"] = field_type.max_length
        if field_type.pattern is not None:
            constraints["pattern"] = field_type.pattern

        return FieldMeta.from_type(str, f.name, constraints=constraints or None)

    if isinstance(field_type, inspect.BytesType):
        if field_type.min_length is not None:
            constraints["min_length"] = field_type.min_length
        if field_type.max_length is not None:
            constraints["max_length"] = field_type.max_length

        return FieldMeta.from_type(bytes, f.name, constraints=constraints or None)

    msg = "unsupported type"
    raise RuntimeError(msg)

MIN_LENGTH = 10000

class Foo(Struct):
    # min_length is kept at a relatively high number so that the bug is more
    # easily reproducible
    bar: Annotated[bytes, msgspec.Meta(min_length=MIN_LENGTH)]


class FooFactory(MsgspecStructFactory):
    __model__ = Foo


foo: Foo = FooFactory.build()

assert len(foo.bar) >= MIN_LENGTH, f"inavlid length - {len(foo.bar)}"

I looked into it in a bit more detail and the reason for this is that bytes is not included in the tuple here.

Thanks 🙏

Why not submit a fix PR with a unit test? If you already identified the issue.

Also, it would be great to have a PR with your msgspec factory too.

[vkcku]

Yupp I'd love to get those PRs ready. As for the PR with the msgspec factory, I'll create a draft PR for it since I would greatly appreciate if you could just make sure that my approach is correct and if there are any improvements I could make.