{"id":69719,"date":"2026-02-08T11:35:58","date_gmt":"2026-02-08T11:35:58","guid":{"rendered":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/"},"modified":"2026-02-08T11:35:58","modified_gmt":"2026-02-08T11:35:58","slug":"how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models","status":"publish","type":"post","link":"https:\/\/youzum.net\/it\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/","title":{"rendered":"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models"},"content":{"rendered":"

In this tutorial, we walk through an advanced, end-to-end exploration of Polyfactory<\/strong><\/a>, focusing on how we can generate rich, realistic mock data directly from Python type hints. We start by setting up the environment and progressively build factories for data classes, Pydantic models, and attrs-based classes, while demonstrating customization, overrides, calculated fields, and the generation of nested objects. As we move through each snippet, we show how we can control randomness, enforce constraints, and model real-world structures, making this tutorial directly applicable to testing, prototyping, and data-driven development workflows. Check out the\u00a0FULL CODES here<\/a><\/strong>.<\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
import subprocess\nimport sys\n\n\ndef install_package(package):\n   subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", package])\n\n\npackages = [\n   \"polyfactory\",\n   \"pydantic\",\n   \"email-validator\",\n   \"faker\",\n   \"msgspec\",\n   \"attrs\"\n]\n\n\nfor package in packages:\n   try:\n       install_package(package)\n       print(f\"\u2713 Installed {package}\")\n   except Exception as e:\n       print(f\"\u2717 Failed to install {package}: {e}\")\n\n\nprint(\"n\")\n\n\nprint(\"=\" * 80)\nprint(\"SECTION 2: Basic Dataclass Factories\")\nprint(\"=\" * 80)\n\n\nfrom dataclasses import dataclass\nfrom typing import List, Optional\nfrom datetime import datetime, date\nfrom uuid import UUID\nfrom polyfactory.factories import DataclassFactory\n\n\n@dataclass\nclass Address:\n   street: str\n   city: str\n   country: str\n   zip_code: str\n\n\n@dataclass\nclass Person:\n   id: UUID\n   name: str\n   email: str\n   age: int\n   birth_date: date\n   is_active: bool\n   address: Address\n   phone_numbers: List[str]\n   bio: Optional[str] = None\n\n\nclass PersonFactory(DataclassFactory[Person]):\n   pass\n\n\nperson = PersonFactory.build()\nprint(f\"Generated Person:\")\nprint(f\"  ID: {person.id}\")\nprint(f\"  Name: {person.name}\")\nprint(f\"  Email: {person.email}\")\nprint(f\"  Age: {person.age}\")\nprint(f\"  Address: {person.address.city}, {person.address.country}\")\nprint(f\"  Phone Numbers: {person.phone_numbers[:2]}\")\nprint()\n\n\npeople = PersonFactory.batch(5)\nprint(f\"Generated {len(people)} people:\")\nfor i, p in enumerate(people, 1):\n   print(f\"  {i}. {p.name} - {p.email}\")\nprint(\"n\")<\/code><\/pre>\n<\/div>\n<\/div>\n
We set up the environment and ensure all required dependencies are installed. We also introduce the core idea of using Polyfactory to generate mock data from type hints. By initializing the basic dataclass factories, we establish the foundation for all subsequent examples.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
print(\"=\" * 80)\nprint(\"SECTION 3: Customizing Factory Behavior\")\nprint(\"=\" * 80)\n\n\nfrom faker import Faker\nfrom polyfactory.fields import Use, Ignore\n\n\n@dataclass\nclass Employee:\n   employee_id: str\n   full_name: str\n   department: str\n   salary: float\n   hire_date: date\n   is_manager: bool\n   email: str\n   internal_notes: Optional[str] = None\n\n\nclass EmployeeFactory(DataclassFactory[Employee]):\n   __faker__ = Faker(locale=\"en_US\")\n   __random_seed__ = 42\n\n\n   @classmethod\n   def employee_id(cls) -> str:\n       return f\"EMP-{cls.__random__.randint(10000, 99999)}\"\n\n\n   @classmethod\n   def full_name(cls) -> str:\n       return cls.__faker__.name()\n\n\n   @classmethod\n   def department(cls) -> str:\n       departments = [\"Engineering\", \"Marketing\", \"Sales\", \"HR\", \"Finance\"]\n       return cls.__random__.choice(departments)\n\n\n   @classmethod\n   def salary(cls) -> float:\n       return round(cls.__random__.uniform(50000, 150000), 2)\n\n\n   @classmethod\n   def email(cls) -> str:\n       return cls.__faker__.company_email()\n\n\nemployees = EmployeeFactory.batch(3)\nprint(\"Generated Employees:\")\nfor emp in employees:\n   print(f\"  {emp.employee_id}: {emp.full_name}\")\n   print(f\"    Department: {emp.department}\")\n   print(f\"    Salary: ${emp.salary:,.2f}\")\n   print(f\"    Email: {emp.email}\")\n   print()\nprint()\n\n\nprint(\"=\" * 80)\nprint(\"SECTION 4: Field Constraints and Calculated Fields\")\nprint(\"=\" * 80)\n\n\n@dataclass\nclass Product:\n   product_id: str\n   name: str\n   description: str\n   price: float\n   discount_percentage: float\n   stock_quantity: int\n   final_price: Optional[float] = None\n   sku: Optional[str] = None\n\n\nclass ProductFactory(DataclassFactory[Product]):\n   @classmethod\n   def product_id(cls) -> str:\n       return f\"PROD-{cls.__random__.randint(1000, 9999)}\"\n\n\n   @classmethod\n   def name(cls) -> str:\n       adjectives = [\"Premium\", \"Deluxe\", \"Classic\", \"Modern\", \"Eco\"]\n       nouns = [\"Widget\", \"Gadget\", \"Device\", \"Tool\", \"Appliance\"]\n       return f\"{cls.__random__.choice(adjectives)} {cls.__random__.choice(nouns)}\"\n\n\n   @classmethod\n   def price(cls) -> float:\n       return round(cls.__random__.uniform(10.0, 1000.0), 2)\n\n\n   @classmethod\n   def discount_percentage(cls) -> float:\n       return round(cls.__random__.uniform(0, 30), 2)\n\n\n   @classmethod\n   def stock_quantity(cls) -> int:\n       return cls.__random__.randint(0, 500)\n\n\n   @classmethod\n   def build(cls, **kwargs):\n       instance = super().build(**kwargs)\n       if instance.final_price is None:\n           instance.final_price = round(\n               instance.price * (1 - instance.discount_percentage \/ 100), 2\n           )\n       if instance.sku is None:\n           name_part = instance.name.replace(\" \", \"-\").upper()[:10]\n           instance.sku = f\"{instance.product_id}-{name_part}\"\n       return instance\n\n\nproducts = ProductFactory.batch(3)\nprint(\"Generated Products:\")\nfor prod in products:\n   print(f\"  {prod.sku}\")\n   print(f\"    Name: {prod.name}\")\n   print(f\"    Price: ${prod.price:.2f}\")\n   print(f\"    Discount: {prod.discount_percentage}%\")\n   print(f\"    Final Price: ${prod.final_price:.2f}\")\n   print(f\"    Stock: {prod.stock_quantity} units\")\n   print()\nprint()<\/code><\/pre>\n<\/div>\n<\/div>\n
We focus on generating simple but realistic mock data using dataclasses and default Polyfactory behavior. We show how to quickly create single instances and batches without writing any custom logic. It helps us validate how Polyfactory automatically interprets type hints to populate nested structures.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
print(\"=\" * 80)\nprint(\"SECTION 6: Complex Nested Structures\")\nprint(\"=\" * 80)\n\n\nfrom enum import Enum\n\n\nclass OrderStatus(str, Enum):\n   PENDING = \"pending\"\n   PROCESSING = \"processing\"\n   SHIPPED = \"shipped\"\n   DELIVERED = \"delivered\"\n   CANCELLED = \"cancelled\"\n\n\n@dataclass\nclass OrderItem:\n   product_name: str\n   quantity: int\n   unit_price: float\n   total_price: Optional[float] = None\n\n\n@dataclass\nclass ShippingInfo:\n   carrier: str\n   tracking_number: str\n   estimated_delivery: date\n\n\n@dataclass\nclass Order:\n   order_id: str\n   customer_name: str\n   customer_email: str\n   status: OrderStatus\n   items: List[OrderItem]\n   order_date: datetime\n   shipping_info: Optional[ShippingInfo] = None\n   total_amount: Optional[float] = None\n   notes: Optional[str] = None\n\n\nclass OrderItemFactory(DataclassFactory[OrderItem]):\n   @classmethod\n   def product_name(cls) -> str:\n       products = [\"Laptop\", \"Mouse\", \"Keyboard\", \"Monitor\", \"Headphones\",\n                  \"Webcam\", \"USB Cable\", \"Phone Case\", \"Charger\", \"Tablet\"]\n       return cls.__random__.choice(products)\n\n\n   @classmethod\n   def quantity(cls) -> int:\n       return cls.__random__.randint(1, 5)\n\n\n   @classmethod\n   def unit_price(cls) -> float:\n       return round(cls.__random__.uniform(5.0, 500.0), 2)\n\n\n   @classmethod\n   def build(cls, **kwargs):\n       instance = super().build(**kwargs)\n       if instance.total_price is None:\n           instance.total_price = round(instance.quantity * instance.unit_price, 2)\n       return instance\n\n\nclass ShippingInfoFactory(DataclassFactory[ShippingInfo]):\n   @classmethod\n   def carrier(cls) -> str:\n       carriers = [\"FedEx\", \"UPS\", \"DHL\", \"USPS\"]\n       return cls.__random__.choice(carriers)\n\n\n   @classmethod\n   def tracking_number(cls) -> str:\n       return ''.join(cls.__random__.choices('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', k=12))\n\n\nclass OrderFactory(DataclassFactory[Order]):\n   @classmethod\n   def order_id(cls) -> str:\n       return f\"ORD-{datetime.now().year}-{cls.__random__.randint(100000, 999999)}\"\n\n\n   @classmethod\n   def items(cls) -> List[OrderItem]:\n       return OrderItemFactory.batch(cls.__random__.randint(1, 5))\n\n\n   @classmethod\n   def build(cls, **kwargs):\n       instance = super().build(**kwargs)\n       if instance.total_amount is None:\n           instance.total_amount = round(sum(item.total_price for item in instance.items), 2)\n       if instance.shipping_info is None and instance.status in [OrderStatus.SHIPPED, OrderStatus.DELIVERED]:\n           instance.shipping_info = ShippingInfoFactory.build()\n       return instance\n\n\norders = OrderFactory.batch(2)\nprint(\"Generated Orders:\")\nfor order in orders:\n   print(f\"n  Order {order.order_id}\")\n   print(f\"    Customer: {order.customer_name} ({order.customer_email})\")\n   print(f\"    Status: {order.status.value}\")\n   print(f\"    Items ({len(order.items)}):\")\n   for item in order.items:\n       print(f\"      - {item.quantity}x {item.product_name} @ ${item.unit_price:.2f} = ${item.total_price:.2f}\")\n   print(f\"    Total: ${order.total_amount:.2f}\")\n   if order.shipping_info:\n       print(f\"    Shipping: {order.shipping_info.carrier} - {order.shipping_info.tracking_number}\")\nprint(\"n\")<\/code><\/pre>\n<\/div>\n<\/div>\n
We build more complex domain logic by introducing calculated and dependent fields within factories. We show how we can derive values such as final prices, totals, and shipping details after object creation. This allows us to model realistic business rules directly inside our test data generators.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
print(\"=\" * 80)\nprint(\"SECTION 7: Attrs Integration\")\nprint(\"=\" * 80)\n\n\nimport attrs\nfrom polyfactory.factories.attrs_factory import AttrsFactory\n\n\n@attrs.define\nclass BlogPost:\n   title: str\n   author: str\n   content: str\n   views: int = 0\n   likes: int = 0\n   published: bool = False\n   published_at: Optional[datetime] = None\n   tags: List[str] = attrs.field(factory=list)\n\n\nclass BlogPostFactory(AttrsFactory[BlogPost]):\n   @classmethod\n   def title(cls) -> str:\n       templates = [\n           \"10 Tips for {}\",\n           \"Understanding {}\",\n           \"The Complete Guide to {}\",\n           \"Why {} Matters\",\n           \"Getting Started with {}\"\n       ]\n       topics = [\"Python\", \"Data Science\", \"Machine Learning\", \"Web Development\", \"DevOps\"]\n       template = cls.__random__.choice(templates)\n       topic = cls.__random__.choice(topics)\n       return template.format(topic)\n\n\n   @classmethod\n   def content(cls) -> str:\n       return \" \".join(Faker().sentences(nb=cls.__random__.randint(3, 8)))\n\n\n   @classmethod\n   def views(cls) -> int:\n       return cls.__random__.randint(0, 10000)\n\n\n   @classmethod\n   def likes(cls) -> int:\n       return cls.__random__.randint(0, 1000)\n\n\n   @classmethod\n   def tags(cls) -> List[str]:\n       all_tags = [\"python\", \"tutorial\", \"beginner\", \"advanced\", \"guide\",\n                  \"tips\", \"best-practices\", \"2024\"]\n       return cls.__random__.sample(all_tags, k=cls.__random__.randint(2, 5))\n\n\nposts = BlogPostFactory.batch(3)\nprint(\"Generated Blog Posts:\")\nfor post in posts:\n   print(f\"n  '{post.title}'\")\n   print(f\"    Author: {post.author}\")\n   print(f\"    Views: {post.views:,} | Likes: {post.likes:,}\")\n   print(f\"    Published: {post.published}\")\n   print(f\"    Tags: {', '.join(post.tags)}\")\n   print(f\"    Preview: {post.content[:100]}...\")\nprint(\"n\")\n\n\nprint(\"=\" * 80)\nprint(\"SECTION 8: Building with Specific Overrides\")\nprint(\"=\" * 80)\n\n\ncustom_person = PersonFactory.build(\n   name=\"Alice Johnson\",\n   age=30,\n   email=\"alice@example.com\"\n)\nprint(f\"Custom Person:\")\nprint(f\"  Name: {custom_person.name}\")\nprint(f\"  Age: {custom_person.age}\")\nprint(f\"  Email: {custom_person.email}\")\nprint(f\"  ID (auto-generated): {custom_person.id}\")\nprint()\n\n\nvip_customers = PersonFactory.batch(\n   3,\n   bio=\"VIP Customer\"\n)\nprint(\"VIP Customers:\")\nfor customer in vip_customers:\n   print(f\"  {customer.name}: {customer.bio}\")\nprint(\"n\")<\/code><\/pre>\n<\/div>\n<\/div>\n
We extend Polyfactory usage to validated Pydantic models and attrs-based classes. We demonstrate how we can respect field constraints, validators, and default behaviors while still generating valid data at scale. It ensures our mock data remains compatible with real application schemas.<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
print(\"=\" * 80)\nprint(\"SECTION 9: Field-Level Control with Use and Ignore\")\nprint(\"=\" * 80)\n\n\nfrom polyfactory.fields import Use, Ignore\n\n\n@dataclass\nclass Configuration:\n   app_name: str\n   version: str\n   debug: bool\n   created_at: datetime\n   api_key: str\n   secret_key: str\n\n\nclass ConfigFactory(DataclassFactory[Configuration]):\n   app_name = Use(lambda: \"MyAwesomeApp\")\n   version = Use(lambda: \"1.0.0\")\n   debug = Use(lambda: False)\n\n\n   @classmethod\n   def api_key(cls) -> str:\n       return f\"api_key_{''.join(cls.__random__.choices('0123456789abcdef', k=32))}\"\n\n\n   @classmethod\n   def secret_key(cls) -> str:\n       return f\"secret_{''.join(cls.__random__.choices('0123456789abcdef', k=64))}\"\n\n\nconfigs = ConfigFactory.batch(2)\nprint(\"Generated Configurations:\")\nfor config in configs:\n   print(f\"  App: {config.app_name} v{config.version}\")\n   print(f\"    Debug: {config.debug}\")\n   print(f\"    API Key: {config.api_key[:20]}...\")\n   print(f\"    Created: {config.created_at}\")\n   print()\nprint()\n\n\nprint(\"=\" * 80)\nprint(\"SECTION 10: Model Coverage Testing\")\nprint(\"=\" * 80)\n\n\nfrom pydantic import BaseModel, ConfigDict\nfrom typing import Union\n\n\nclass PaymentMethod(BaseModel):\n   model_config = ConfigDict(use_enum_values=True)\n   type: str\n   card_number: Optional[str] = None\n   bank_name: Optional[str] = None\n   verified: bool = False\n\n\nclass PaymentMethodFactory(ModelFactory[PaymentMethod]):\n   __model__ = PaymentMethod\n\n\npayment_methods = [\n   PaymentMethodFactory.build(type=\"card\", card_number=\"4111111111111111\"),\n   PaymentMethodFactory.build(type=\"bank\", bank_name=\"Chase Bank\"),\n   PaymentMethodFactory.build(verified=True),\n]\n\n\nprint(\"Payment Method Coverage:\")\nfor i, pm in enumerate(payment_methods, 1):\n   print(f\"  {i}. Type: {pm.type}\")\n   if pm.card_number:\n       print(f\"     Card: {pm.card_number}\")\n   if pm.bank_name:\n       print(f\"     Bank: {pm.bank_name}\")\n   print(f\"     Verified: {pm.verified}\")\nprint(\"n\")\n\n\nprint(\"=\" * 80)\nprint(\"TUTORIAL SUMMARY\")\nprint(\"=\" * 80)\nprint(\"\"\"\nThis tutorial covered:\n\n\n1. \u2713 Basic Dataclass Factories - Simple mock data generation\n2. \u2713 Custom Field Generators - Controlling individual field values\n3. \u2713 Field Constraints - Using PostGenerated for calculated fields\n4. \u2713 Pydantic Integration - Working with validated models\n5. \u2713 Complex Nested Structures - Building related objects\n6. \u2713 Attrs Support - Alternative to dataclasses\n7. \u2713 Build Overrides - Customizing specific instances\n8. \u2713 Use and Ignore - Explicit field control\n9. \u2713 Coverage Testing - Ensuring comprehensive test data\n\n\nKey Takeaways:\n- Polyfactory automatically generates mock data from type hints\n- Customize generation with classmethods and decorators\n- Supports multiple libraries: dataclasses, Pydantic, attrs, msgspec\n- Use PostGenerated for calculated\/dependent fields\n- Override specific values while keeping others random\n- Perfect for testing, development, and prototyping\n\n\nFor more information:\n- Documentation: https:\/\/polyfactory.litestar.dev\/\n- GitHub: https:\/\/github.com\/litestar-org\/polyfactory\n\"\"\")\nprint(\"=\" * 80)<\/code><\/pre>\n<\/div>\n<\/div>\n
We cover advanced usage patterns such as explicit overrides, constant field values, and coverage testing scenarios. We show how we can intentionally construct edge cases and variant instances for robust testing. This final step ties everything together by demonstrating how Polyfactory supports comprehensive and production-grade test data strategies.<\/p>\n
In conclusion, we demonstrated how Polyfactory enables us to create comprehensive, flexible test data with minimal boilerplate while still retaining fine-grained control over every field. We showed how to handle simple entities, complex nested structures, and Pydantic model validation, as well as explicit field overrides, within a single, consistent factory-based approach. Overall, we found that Polyfactory enables us to move faster and test more confidently, as it reliably generates realistic datasets that closely mirror production-like scenarios without sacrificing clarity or maintainability.<\/p>\n
\n
Check out the\u00a0FULL CODES here<\/a><\/strong>.\u00a0Also,\u00a0feel free to follow us on\u00a0Twitter<\/mark><\/a><\/strong>\u00a0and don\u2019t forget to join our\u00a0100k+ ML SubReddit<\/a><\/strong>\u00a0and Subscribe to\u00a0our Newsletter<\/a><\/strong>. Wait! are you on telegram?\u00a0now you can join us on telegram as well.<\/a><\/strong><\/p>\n
The post How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models<\/a> appeared first on MarkTechPost<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"
In this tutorial, we walk through an advanced, end-to-end exploration of Polyfactory, focusing on how we can generate rich, realistic mock data directly from Python type hints. We start by setting up the environment and progressively build factories for data classes, Pydantic models, and attrs-based classes, while demonstrating customization, overrides, calculated fields, and the generation of nested objects. As we move through each snippet, we show how we can control randomness, enforce constraints, and model real-world structures, making this tutorial directly applicable to testing, prototyping, and data-driven development workflows. Check out the\u00a0FULL CODES here. Copy CodeCopiedUse a different Browser import subprocess import sys def install_package(package): subprocess.check_call([sys.executable, “-m”, “pip”, “install”, “-q”, package]) packages = [ “polyfactory”, “pydantic”, “email-validator”, “faker”, “msgspec”, “attrs” ] for package in packages: try: install_package(package) print(f”\u2713 Installed {package}”) except Exception as e: print(f”\u2717 Failed to install {package}: {e}”) print(“n”) print(“=” * 80) print(“SECTION 2: Basic Dataclass Factories”) print(“=” * 80) from dataclasses import dataclass from typing import List, Optional from datetime import datetime, date from uuid import UUID from polyfactory.factories import DataclassFactory @dataclass class Address: street: str city: str country: str zip_code: str @dataclass class Person: id: UUID name: str email: str age: int birth_date: date is_active: bool address: Address phone_numbers: List[str] bio: Optional[str] = None class PersonFactory(DataclassFactory[Person]): pass person = PersonFactory.build() print(f”Generated Person:”) print(f” ID: {person.id}”) print(f” Name: {person.name}”) print(f” Email: {person.email}”) print(f” Age: {person.age}”) print(f” Address: {person.address.city}, {person.address.country}”) print(f” Phone Numbers: {person.phone_numbers[:2]}”) print() people = PersonFactory.batch(5) print(f”Generated {len(people)} people:”) for i, p in enumerate(people, 1): print(f” {i}. {p.name} – {p.email}”) print(“n”) We set up the environment and ensure all required dependencies are installed. We also introduce the core idea of using Polyfactory to generate mock data from type hints. By initializing the basic dataclass factories, we establish the foundation for all subsequent examples. Copy CodeCopiedUse a different Browser print(“=” * 80) print(“SECTION 3: Customizing Factory Behavior”) print(“=” * 80) from faker import Faker from polyfactory.fields import Use, Ignore @dataclass class Employee: employee_id: str full_name: str department: str salary: float hire_date: date is_manager: bool email: str internal_notes: Optional[str] = None class EmployeeFactory(DataclassFactory[Employee]): __faker__ = Faker(locale=”en_US”) __random_seed__ = 42 @classmethod def employee_id(cls) -> str: return f”EMP-{cls.__random__.randint(10000, 99999)}” @classmethod def full_name(cls) -> str: return cls.__faker__.name() @classmethod def department(cls) -> str: departments = [“Engineering”, “Marketing”, “Sales”, “HR”, “Finance”] return cls.__random__.choice(departments) @classmethod def salary(cls) -> float: return round(cls.__random__.uniform(50000, 150000), 2) @classmethod def email(cls) -> str: return cls.__faker__.company_email() employees = EmployeeFactory.batch(3) print(“Generated Employees:”) for emp in employees: print(f” {emp.employee_id}: {emp.full_name}”) print(f” Department: {emp.department}”) print(f” Salary: ${emp.salary:,.2f}”) print(f” Email: {emp.email}”) print() print() print(“=” * 80) print(“SECTION 4: Field Constraints and Calculated Fields”) print(“=” * 80) @dataclass class Product: product_id: str name: str description: str price: float discount_percentage: float stock_quantity: int final_price: Optional[float] = None sku: Optional[str] = None class ProductFactory(DataclassFactory[Product]): @classmethod def product_id(cls) -> str: return f”PROD-{cls.__random__.randint(1000, 9999)}” @classmethod def name(cls) -> str: adjectives = [“Premium”, “Deluxe”, “Classic”, “Modern”, “Eco”] nouns = [“Widget”, “Gadget”, “Device”, “Tool”, “Appliance”] return f”{cls.__random__.choice(adjectives)} {cls.__random__.choice(nouns)}” @classmethod def price(cls) -> float: return round(cls.__random__.uniform(10.0, 1000.0), 2) @classmethod def discount_percentage(cls) -> float: return round(cls.__random__.uniform(0, 30), 2) @classmethod def stock_quantity(cls) -> int: return cls.__random__.randint(0, 500) @classmethod def build(cls, **kwargs): instance = super().build(**kwargs) if instance.final_price is None: instance.final_price = round( instance.price * (1 – instance.discount_percentage \/ 100), 2 ) if instance.sku is None: name_part = instance.name.replace(” “, “-“).upper()[:10] instance.sku = f”{instance.product_id}-{name_part}” return instance products = ProductFactory.batch(3) print(“Generated Products:”) for prod in products: print(f” {prod.sku}”) print(f” Name: {prod.name}”) print(f” Price: ${prod.price:.2f}”) print(f” Discount: {prod.discount_percentage}%”) print(f” Final Price: ${prod.final_price:.2f}”) print(f” Stock: {prod.stock_quantity} units”) print() print() We focus on generating simple but realistic mock data using dataclasses and default Polyfactory behavior. We show how to quickly create single instances and batches without writing any custom logic. It helps us validate how Polyfactory automatically interprets type hints to populate nested structures. Copy CodeCopiedUse a different Browser print(“=” * 80) print(“SECTION 6: Complex Nested Structures”) print(“=” * 80) from enum import Enum class OrderStatus(str, Enum): PENDING = “pending” PROCESSING = “processing” SHIPPED = “shipped” DELIVERED = “delivered” CANCELLED = “cancelled” @dataclass class OrderItem: product_name: str quantity: int unit_price: float total_price: Optional[float] = None @dataclass class ShippingInfo: carrier: str tracking_number: str estimated_delivery: date @dataclass class Order: order_id: str customer_name: str customer_email: str status: OrderStatus items: List[OrderItem] order_date: datetime shipping_info: Optional[ShippingInfo] = None total_amount: Optional[float] = None notes: Optional[str] = None class OrderItemFactory(DataclassFactory[OrderItem]): @classmethod def product_name(cls) -> str: products = [“Laptop”, “Mouse”, “Keyboard”, “Monitor”, “Headphones”, “Webcam”, “USB Cable”, “Phone Case”, “Charger”, “Tablet”] return cls.__random__.choice(products) @classmethod def quantity(cls) -> int: return cls.__random__.randint(1, 5) @classmethod def unit_price(cls) -> float: return round(cls.__random__.uniform(5.0, 500.0), 2) @classmethod def build(cls, **kwargs): instance = super().build(**kwargs) if instance.total_price is None: instance.total_price = round(instance.quantity * instance.unit_price, 2) return instance class ShippingInfoFactory(DataclassFactory[ShippingInfo]): @classmethod def carrier(cls) -> str: carriers = [“FedEx”, “UPS”, “DHL”, “USPS”] return cls.__random__.choice(carriers) @classmethod def tracking_number(cls) -> str: return ”.join(cls.__random__.choices(‘0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ’, k=12)) class OrderFactory(DataclassFactory[Order]): @classmethod def order_id(cls) -> str: return f”ORD-{datetime.now().year}-{cls.__random__.randint(100000, 999999)}” @classmethod def items(cls) -> List[OrderItem]: return OrderItemFactory.batch(cls.__random__.randint(1, 5)) @classmethod def build(cls, **kwargs): instance = super().build(**kwargs) if instance.total_amount is None: instance.total_amount = round(sum(item.total_price for item in instance.items), 2) if instance.shipping_info is None and instance.status in [OrderStatus.SHIPPED, OrderStatus.DELIVERED]: instance.shipping_info = ShippingInfoFactory.build() return instance orders = OrderFactory.batch(2) print(“Generated Orders:”) for order in orders: print(f”n Order {order.order_id}”) print(f” Customer: {order.customer_name} ({order.customer_email})”) print(f” Status: {order.status.value}”) print(f” Items ({len(order.items)}):”) for item in order.items: print(f” – {item.quantity}x {item.product_name} @ ${item.unit_price:.2f} = ${item.total_price:.2f}”) print(f” Total: ${order.total_amount:.2f}”) if order.shipping_info: print(f” Shipping: {order.shipping_info.carrier} – {order.shipping_info.tracking_number}”) print(“n”) We build more complex domain logic by introducing calculated and dependent fields within factories. We show how we can derive values such as final prices, totals, and shipping details after object creation. This allows us to model realistic business rules directly inside our test data generators. Copy CodeCopiedUse a different Browser print(“=” * 80) print(“SECTION 7: Attrs Integration”) print(“=” * 80) import attrs from polyfactory.factories.attrs_factory import AttrsFactory @attrs.define class BlogPost: title: str author: str content: str views: int = 0 likes: int = 0 published: bool = False published_at: Optional[datetime] = None tags: List[str] = attrs.field(factory=list) class BlogPostFactory(AttrsFactory[BlogPost]): @classmethod def title(cls) -> str: templates = [ “10 Tips for {}”,<\/p>","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"pmpro_default_level":"","site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"_pvb_checkbox_block_on_post":false,"footnotes":""},"categories":[52,5,7,1],"tags":[],"class_list":["post-69719","post","type-post","status-publish","format-standard","hentry","category-ai-club","category-committee","category-news","category-uncategorized","pmpro-has-access"],"acf":[],"yoast_head":"\nHow to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models - YouZum<\/title>\n<meta name=\"description\" content=\"\u0e01\u0e34\u0e08\u0e01\u0e23\u0e23\u0e21\u0e40\u0e01\u0e35\u0e48\u0e22\u0e27\u0e01\u0e31\u0e1a\u0e42\u0e14\u0e23\u0e19\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/youzum.net\/it\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models - YouZum\" \/>\n<meta property=\"og:description\" content=\"\u0e01\u0e34\u0e08\u0e01\u0e23\u0e23\u0e21\u0e40\u0e01\u0e35\u0e48\u0e22\u0e27\u0e01\u0e31\u0e1a\u0e42\u0e14\u0e23\u0e19\" \/>\n<meta property=\"og:url\" content=\"https:\/\/youzum.net\/it\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/\" \/>\n<meta property=\"og:site_name\" content=\"YouZum\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DroneAssociationTH\/\" \/>\n<meta property=\"article:published_time\" content=\"2026-02-08T11:35:58+00:00\" \/>\n<meta name=\"author\" content=\"admin NU\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Scritto da\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin NU\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tempo di lettura stimato\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minuti\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/\"},\"author\":{\"name\":\"admin NU\",\"@id\":\"https:\/\/yousum.gpucore.co\/#\/schema\/person\/97fa48242daf3908e4d9a5f26f4a059c\"},\"headline\":\"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models\",\"datePublished\":\"2026-02-08T11:35:58+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/\"},\"wordCount\":513,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/yousum.gpucore.co\/#organization\"},\"articleSection\":[\"AI\",\"Committee\",\"News\",\"Uncategorized\"],\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/\",\"url\":\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/\",\"name\":\"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models - YouZum\",\"isPartOf\":{\"@id\":\"https:\/\/yousum.gpucore.co\/#website\"},\"datePublished\":\"2026-02-08T11:35:58+00:00\",\"description\":\"\u0e01\u0e34\u0e08\u0e01\u0e23\u0e23\u0e21\u0e40\u0e01\u0e35\u0e48\u0e22\u0e27\u0e01\u0e31\u0e1a\u0e42\u0e14\u0e23\u0e19\",\"breadcrumb\":{\"@id\":\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#breadcrumb\"},\"inLanguage\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/youzum.net\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/yousum.gpucore.co\/#website\",\"url\":\"https:\/\/yousum.gpucore.co\/\",\"name\":\"YouSum\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/yousum.gpucore.co\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/yousum.gpucore.co\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"it-IT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/yousum.gpucore.co\/#organization\",\"name\":\"Drone Association Thailand\",\"url\":\"https:\/\/yousum.gpucore.co\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/yousum.gpucore.co\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/youzum.net\/wp-content\/uploads\/2024\/11\/tranparent-logo.png\",\"contentUrl\":\"https:\/\/youzum.net\/wp-content\/uploads\/2024\/11\/tranparent-logo.png\",\"width\":300,\"height\":300,\"caption\":\"Drone Association Thailand\"},\"image\":{\"@id\":\"https:\/\/yousum.gpucore.co\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/DroneAssociationTH\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/yousum.gpucore.co\/#\/schema\/person\/97fa48242daf3908e4d9a5f26f4a059c\",\"name\":\"admin NU\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@id\":\"https:\/\/yousum.gpucore.co\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/youzum.net\/wp-content\/uploads\/avatars\/2\/1746849356-bpfull.png\",\"contentUrl\":\"https:\/\/youzum.net\/wp-content\/uploads\/avatars\/2\/1746849356-bpfull.png\",\"caption\":\"admin NU\"},\"url\":\"https:\/\/youzum.net\/it\/members\/adminnu\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models - YouZum","description":"\u0e01\u0e34\u0e08\u0e01\u0e23\u0e23\u0e21\u0e40\u0e01\u0e35\u0e48\u0e22\u0e27\u0e01\u0e31\u0e1a\u0e42\u0e14\u0e23\u0e19","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/youzum.net\/it\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/","og_locale":"it_IT","og_type":"article","og_title":"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models - YouZum","og_description":"\u0e01\u0e34\u0e08\u0e01\u0e23\u0e23\u0e21\u0e40\u0e01\u0e35\u0e48\u0e22\u0e27\u0e01\u0e31\u0e1a\u0e42\u0e14\u0e23\u0e19","og_url":"https:\/\/youzum.net\/it\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/","og_site_name":"YouZum","article_publisher":"https:\/\/www.facebook.com\/DroneAssociationTH\/","article_published_time":"2026-02-08T11:35:58+00:00","author":"admin NU","twitter_card":"summary_large_image","twitter_misc":{"Scritto da":"admin NU","Tempo di lettura stimato":"10 minuti"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#article","isPartOf":{"@id":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/"},"author":{"name":"admin NU","@id":"https:\/\/yousum.gpucore.co\/#\/schema\/person\/97fa48242daf3908e4d9a5f26f4a059c"},"headline":"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models","datePublished":"2026-02-08T11:35:58+00:00","mainEntityOfPage":{"@id":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/"},"wordCount":513,"commentCount":0,"publisher":{"@id":"https:\/\/yousum.gpucore.co\/#organization"},"articleSection":["AI","Committee","News","Uncategorized"],"inLanguage":"it-IT","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/","url":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/","name":"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models - YouZum","isPartOf":{"@id":"https:\/\/yousum.gpucore.co\/#website"},"datePublished":"2026-02-08T11:35:58+00:00","description":"\u0e01\u0e34\u0e08\u0e01\u0e23\u0e23\u0e21\u0e40\u0e01\u0e35\u0e48\u0e22\u0e27\u0e01\u0e31\u0e1a\u0e42\u0e14\u0e23\u0e19","breadcrumb":{"@id":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/youzum.net\/how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/youzum.net\/"},{"@type":"ListItem","position":2,"name":"How to Design Production-Grade Mock Data Pipelines Using Polyfactory with Dataclasses, Pydantic, Attrs, and Nested Models"}]},{"@type":"WebSite","@id":"https:\/\/yousum.gpucore.co\/#website","url":"https:\/\/yousum.gpucore.co\/","name":"YouSum","description":"","publisher":{"@id":"https:\/\/yousum.gpucore.co\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/yousum.gpucore.co\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"it-IT"},{"@type":"Organization","@id":"https:\/\/yousum.gpucore.co\/#organization","name":"Drone Association Thailand","url":"https:\/\/yousum.gpucore.co\/","logo":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/yousum.gpucore.co\/#\/schema\/logo\/image\/","url":"https:\/\/youzum.net\/wp-content\/uploads\/2024\/11\/tranparent-logo.png","contentUrl":"https:\/\/youzum.net\/wp-content\/uploads\/2024\/11\/tranparent-logo.png","width":300,"height":300,"caption":"Drone Association Thailand"},"image":{"@id":"https:\/\/yousum.gpucore.co\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DroneAssociationTH\/"]},{"@type":"Person","@id":"https:\/\/yousum.gpucore.co\/#\/schema\/person\/97fa48242daf3908e4d9a5f26f4a059c","name":"admin NU","image":{"@type":"ImageObject","inLanguage":"it-IT","@id":"https:\/\/yousum.gpucore.co\/#\/schema\/person\/image\/","url":"https:\/\/youzum.net\/wp-content\/uploads\/avatars\/2\/1746849356-bpfull.png","contentUrl":"https:\/\/youzum.net\/wp-content\/uploads\/avatars\/2\/1746849356-bpfull.png","caption":"admin NU"},"url":"https:\/\/youzum.net\/it\/members\/adminnu\/"}]}},"rttpg_featured_image_url":null,"rttpg_author":{"display_name":"admin NU","author_link":"https:\/\/youzum.net\/it\/members\/adminnu\/"},"rttpg_comment":0,"rttpg_category":"<a href=\"https:\/\/youzum.net\/it\/category\/ai-club\/\" rel=\"category tag\">AI<\/a> <a href=\"https:\/\/youzum.net\/it\/category\/committee\/\" rel=\"category tag\">Committee<\/a> <a href=\"https:\/\/youzum.net\/it\/category\/news\/\" rel=\"category tag\">News<\/a> <a href=\"https:\/\/youzum.net\/it\/category\/uncategorized\/\" rel=\"category tag\">Uncategorized<\/a>","rttpg_excerpt":"In this tutorial, we walk through an advanced, end-to-end exploration of Polyfactory, focusing on how we can generate rich, realistic mock data directly from Python type hints. We start by setting up the environment and progressively build factories for data classes, Pydantic models, and attrs-based classes, while demonstrating customization, overrides, calculated fields, and the generation…","_links":{"self":[{"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/posts\/69719","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/comments?post=69719"}],"version-history":[{"count":0,"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/posts\/69719\/revisions"}],"wp:attachment":[{"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/media?parent=69719"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/categories?post=69719"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/youzum.net\/it\/wp-json\/wp\/v2\/tags?post=69719"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}