{"id":379,"date":"2026-02-08T18:12:32","date_gmt":"2026-02-08T10:12:32","guid":{"rendered":"https:\/\/connectword.dpdns.org\/?p=379"},"modified":"2026-02-08T18:12:32","modified_gmt":"2026-02-08T10:12:32","slug":"how-to-design-production-grade-mock-data-pipelines-using-polyfactory-with-dataclasses-pydantic-attrs-and-nested-models","status":"publish","type":"post","link":"https:\/\/connectword.dpdns.org\/?p=379","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 thro…<\/p>\n","protected":false},"author":1,"featured_media":29,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-379","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/379","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=379"}],"version-history":[{"count":0,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/posts\/379\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=\/wp\/v2\/media\/29"}],"wp:attachment":[{"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=379"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=379"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/connectword.dpdns.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=379"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}