tessl/pypi-polyfactory

Mock data generation factories for Python types with support for dataclasses, Pydantic, SQLAlchemy, and more

—

Pending

Overview

Eval results

Files

Specialized Factories

Name: tessl/pypi-polyfactory
Author: tessl

Type-specific factory implementations optimized for different Python object modeling libraries. Each factory class is designed to work with the specific features and constraints of its target type system.

Capabilities

Dataclass Factory

Factory implementation for Python dataclasses with support for all dataclass features including default values, field metadata, and inheritance.

class DataclassFactory(BaseFactory[T]):
    """
    Base factory for Python dataclass types.
    
    Automatically handles dataclass field types, defaults, and metadata.
    Supports inheritance and complex nested dataclass structures.
    """

Usage Example:

from dataclasses import dataclass, field
from polyfactory.factories import DataclassFactory

@dataclass
class Address:
    street: str
    city: str
    zip_code: str

@dataclass
class Person:
    name: str
    age: int = 25
    addresses: list[Address] = field(default_factory=list)

class PersonFactory(DataclassFactory[Person]):
    __model__ = Person

# Generates Person with Address objects in the addresses list
person = PersonFactory.build()

TypedDict Factory

Factory implementation for TypedDict types with support for total/partial typing and inheritance.

class TypedDictFactory(BaseFactory[TypedDictT]):
    """
    Base factory for TypedDict types.
    
    Handles required and optional keys based on TypedDict total setting.
    Supports TypedDict inheritance and nested structures.
    """

Usage Example:

from typing import TypedDict, NotRequired
from polyfactory.factories import TypedDictFactory

class UserDict(TypedDict):
    id: int
    name: str
    email: NotRequired[str]  # Optional field

class UserDictFactory(TypedDictFactory[UserDict]):
    __model__ = UserDict

user = UserDictFactory.build()  # May or may not include 'email'

Pydantic Model Factory

Factory implementation for Pydantic models with support for both v1 and v2, including validators, field constraints, and computed fields.

class ModelFactory(BaseFactory[T]):
    """
    Base factory for Pydantic models (v1 and v2 compatible).
    
    Respects Pydantic field constraints, validators, and default values.
    Handles nested models, unions, and complex validation scenarios.
    """

Usage Example:

from pydantic import BaseModel, EmailStr, Field
from polyfactory.factories.pydantic_factory import ModelFactory

class User(BaseModel):
    name: str = Field(min_length=2, max_length=50)
    email: EmailStr
    age: int = Field(ge=0, le=120)

class UserFactory(ModelFactory[User]):
    __model__ = User

# Generates valid User respecting all Pydantic constraints
user = UserFactory.build()

SQLAlchemy Factory

Factory implementation for SQLAlchemy ORM models with support for relationships, constraints, and database-specific types.

class SQLAlchemyFactory(BaseFactory[T]):
    """
    Base factory for SQLAlchemy ORM models.
    
    Handles SQLAlchemy column types, relationships, and constraints.
    Integrates with persistence handlers for database operations.
    """

Usage Example:

from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from polyfactory.factories.sqlalchemy_factory import SQLAlchemyFactory

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    posts = relationship("Post", back_populates="author")

class Post(Base):
    __tablename__ = 'posts'
    id = Column(Integer, primary_key=True)
    title = Column(String(100))
    author_id = Column(Integer, ForeignKey('users.id'))
    author = relationship("User", back_populates="posts")

class UserFactory(SQLAlchemyFactory[User]):
    __model__ = User

class PostFactory(SQLAlchemyFactory[Post]):
    __model__ = Post

user = UserFactory.build()  # Generates User with related Posts

Attrs Factory

Factory implementation for attrs classes with support for validators, converters, and metadata.

class AttrsFactory(BaseFactory[T]):
    """
    Base factory for attrs classes.
    
    Handles attrs field definitions, validators, converters, and default values.
    Supports attrs inheritance and complex attribute configurations.
    """

Usage Example:

import attrs
from polyfactory.factories.attrs_factory import AttrsFactory

@attrs.define
class Person:
    name: str
    age: int = attrs.field(validator=attrs.validators.instance_of(int))
    email: str = attrs.field(converter=str.lower)

class PersonFactory(AttrsFactory[Person]):
    __model__ = Person

person = PersonFactory.build()  # Respects attrs validators and converters

Msgspec Factory

Factory implementation for msgspec structs with support for constraints and custom encoders/decoders.

class MsgspecFactory(BaseFactory[T]):
    """
    Base factory for msgspec structs.
    
    Handles msgspec field constraints and type annotations.
    Supports msgspec's high-performance serialization features.
    """

Usage Example:

import msgspec
from polyfactory.factories.msgspec_factory import MsgspecFactory

class User(msgspec.Struct):
    name: str
    age: int
    email: str

class UserFactory(MsgspecFactory[User]):
    __model__ = User

user = UserFactory.build()

Beanie Document Factory

Factory implementation for Beanie ODM documents with support for MongoDB-specific features and validation.

class BeanieDocumentFactory(ModelFactory[T]):
    """
    Factory for Beanie ODM documents.
    
    Extends ModelFactory with Beanie-specific document features.
    Handles MongoDB ObjectId generation and document relationships.
    """

Usage Example:

from beanie import Document
from polyfactory.factories.beanie_odm_factory import BeanieDocumentFactory

class User(Document):
    name: str
    email: str
    age: int

class UserFactory(BeanieDocumentFactory[User]):
    __model__ = User

user = UserFactory.build()  # Includes valid ObjectId

Odmantic Model Factory

Factory implementation for Odmantic ODM models with support for MongoDB integration through Pydantic.

class OdmanticModelFactory(ModelFactory[T]):
    """
    Factory for Odmantic ODM models.
    
    Extends ModelFactory with Odmantic-specific model features.
    Handles MongoDB document generation and model relationships.
    """

Usage Example:

from odmantic import Model
from polyfactory.factories.odmantic_odm_factory import OdmanticModelFactory

class User(Model):
    name: str
    email: str
    age: int

class UserFactory(OdmanticModelFactory[User]):
    __model__ = User

user = UserFactory.build()

Factory Configuration

All specialized factories inherit common configuration attributes from BaseFactory:

# Common configuration attributes
__model__: type  # Required: The model type for the factory
__faker__: Faker  # Faker instance for generating realistic data
__random__: Random  # Random instance for deterministic generation
__randomize_collection_length__: bool  # Randomize collection sizes
__min_collection_length__: int  # Minimum collection size
__max_collection_length__: int  # Maximum collection size
__allow_none_optionals__: bool  # Allow None values for optional fields
__use_defaults__: bool  # Use model default values when available
__check_model__: bool  # Validate generated instances

Install with Tessl CLI