In diesem Tutorial führen wir eine umfassende, umfassende Erkundung von durch Polyfabrikwobei der Schwerpunkt darauf liegt, wie wir direkt aus Python-Typhinweisen umfangreiche, realistische Scheindaten generieren können. Wir beginnen mit der Einrichtung der Umgebung und bauen nach und nach Fabriken für Datenklassen, Pydantic-Modelle und attrs-basierte Klassen auf, während wir Anpassungen, Überschreibungen, berechnete Felder und die Generierung verschachtelter Objekte demonstrieren. Während wir uns durch jedes Snippet bewegen, zeigen wir, wie wir Zufälligkeiten kontrollieren, Einschränkungen erzwingen und reale Strukturen modellieren können, sodass dieses Tutorial direkt auf Check-, Prototyping- und datengesteuerte Entwicklungsworkflows anwendbar ist. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
import subprocess
import sys
def install_package(package deal):
subprocess.check_call((sys.executable, "-m", "pip", "set up", "-q", package deal))
packages = (
"polyfactory",
"pydantic",
"email-validator",
"faker",
"msgspec",
"attrs"
)
for package deal in packages:
strive:
install_package(package deal)
print(f"✓ Put in {package deal}")
besides Exception as e:
print(f"✗ Failed to put in {package deal}: {e}")
print("n")
print("=" * 80)
print("SECTION 2: Fundamental Dataclass Factories")
print("=" * 80)
from dataclasses import dataclass
from typing import Listing, Optionally available
from datetime import datetime, date
from uuid import UUID
from polyfactory.factories import DataclassFactory
@dataclass
class Tackle:
avenue: str
metropolis: str
nation: str
zip_code: str
@dataclass
class Particular person:
id: UUID
identify: str
electronic mail: str
age: int
birth_date: date
is_active: bool
tackle: Tackle
phone_numbers: Listing(str)
bio: Optionally available(str) = None
class PersonFactory(DataclassFactory(Particular person)):
move
individual = PersonFactory.construct()
print(f"Generated Particular person:")
print(f" ID: {individual.id}")
print(f" Title: {individual.identify}")
print(f" Electronic mail: {individual.electronic mail}")
print(f" Age: {individual.age}")
print(f" Tackle: {individual.tackle.metropolis}, {individual.tackle.nation}")
print(f" Cellphone Numbers: {individual.phone_numbers(:2)}")
print()
individuals = PersonFactory.batch(5)
print(f"Generated {len(individuals)} individuals:")
for i, p in enumerate(individuals, 1):
print(f" {i}. {p.identify} - {p.electronic mail}")
print("n")Wir richten die Umgebung ein und stellen sicher, dass alle erforderlichen Abhängigkeiten installiert sind. Wir stellen auch die Kernidee der Verwendung von Polyfactory zum Generieren von Scheindaten aus Typhinweisen vor. Durch die Initialisierung der grundlegenden Datenklassenfabriken legen wir die Grundlage für alle nachfolgenden Beispiele.
print("=" * 80)
print("SECTION 3: Customizing Manufacturing unit Habits")
print("=" * 80)
from faker import Faker
from polyfactory.fields import Use, Ignore
@dataclass
class Worker:
employee_id: str
full_name: str
division: str
wage: float
hire_date: date
is_manager: bool
electronic mail: str
internal_notes: Optionally available(str) = None
class EmployeeFactory(DataclassFactory(Worker)):
__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__.identify()
@classmethod
def division(cls) -> str:
departments = ("Engineering", "Advertising", "Gross sales", "HR", "Finance")
return cls.__random__.alternative(departments)
@classmethod
def wage(cls) -> float:
return spherical(cls.__random__.uniform(50000, 150000), 2)
@classmethod
def electronic mail(cls) -> str:
return cls.__faker__.company_email()
workers = EmployeeFactory.batch(3)
print("Generated Staff:")
for emp in workers:
print(f" {emp.employee_id}: {emp.full_name}")
print(f" Division: {emp.division}")
print(f" Wage: ${emp.wage:,.2f}")
print(f" Electronic mail: {emp.electronic mail}")
print()
print()
print("=" * 80)
print("SECTION 4: Subject Constraints and Calculated Fields")
print("=" * 80)
@dataclass
class Product:
product_id: str
identify: str
description: str
worth: float
discount_percentage: float
stock_quantity: int
final_price: Optionally available(float) = None
sku: Optionally available(str) = None
class ProductFactory(DataclassFactory(Product)):
@classmethod
def product_id(cls) -> str:
return f"PROD-{cls.__random__.randint(1000, 9999)}"
@classmethod
def identify(cls) -> str:
adjectives = ("Premium", "Deluxe", "Traditional", "Fashionable", "Eco")
nouns = ("Widget", "Gadget", "Gadget", "Software", "Equipment")
return f"{cls.__random__.alternative(adjectives)} {cls.__random__.alternative(nouns)}"
@classmethod
def worth(cls) -> float:
return spherical(cls.__random__.uniform(10.0, 1000.0), 2)
@classmethod
def discount_percentage(cls) -> float:
return spherical(cls.__random__.uniform(0, 30), 2)
@classmethod
def stock_quantity(cls) -> int:
return cls.__random__.randint(0, 500)
@classmethod
def construct(cls, **kwargs):
occasion = tremendous().construct(**kwargs)
if occasion.final_price is None:
occasion.final_price = spherical(
occasion.worth * (1 - occasion.discount_percentage / 100), 2
)
if occasion.sku is None:
name_part = occasion.identify.substitute(" ", "-").higher()(:10)
occasion.sku = f"{occasion.product_id}-{name_part}"
return occasion
merchandise = ProductFactory.batch(3)
print("Generated Merchandise:")
for prod in merchandise:
print(f" {prod.sku}")
print(f" Title: {prod.identify}")
print(f" Worth: ${prod.worth:.2f}")
print(f" Low cost: {prod.discount_percentage}%")
print(f" Last Worth: ${prod.final_price:.2f}")
print(f" Inventory: {prod.stock_quantity} models")
print()
print()Wir konzentrieren uns auf die Generierung einfacher, aber realistischer Scheindaten mithilfe von Datenklassen und dem Standardverhalten von Polyfactory. Wir zeigen, wie Sie schnell einzelne Instanzen und Batches erstellen, ohne eine benutzerdefinierte Logik zu schreiben. Es hilft uns zu validieren, wie Polyfactory Typhinweise automatisch interpretiert, um verschachtelte Strukturen zu füllen.
print("=" * 80)
print("SECTION 6: Complicated Nested Buildings")
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
amount: int
unit_price: float
total_price: Optionally available(float) = None
@dataclass
class ShippingInfo:
service: str
tracking_number: str
estimated_delivery: date
@dataclass
class Order:
order_id: str
customer_name: str
customer_email: str
standing: OrderStatus
gadgets: Listing(OrderItem)
order_date: datetime
shipping_info: Optionally available(ShippingInfo) = None
total_amount: Optionally available(float) = None
notes: Optionally available(str) = None
class OrderItemFactory(DataclassFactory(OrderItem)):
@classmethod
def product_name(cls) -> str:
merchandise = ("Laptop computer", "Mouse", "Keyboard", "Monitor", "Headphones",
"Webcam", "USB Cable", "Cellphone Case", "Charger", "Pill")
return cls.__random__.alternative(merchandise)
@classmethod
def amount(cls) -> int:
return cls.__random__.randint(1, 5)
@classmethod
def unit_price(cls) -> float:
return spherical(cls.__random__.uniform(5.0, 500.0), 2)
@classmethod
def construct(cls, **kwargs):
occasion = tremendous().construct(**kwargs)
if occasion.total_price is None:
occasion.total_price = spherical(occasion.amount * occasion.unit_price, 2)
return occasion
class ShippingInfoFactory(DataclassFactory(ShippingInfo)):
@classmethod
def service(cls) -> str:
carriers = ("FedEx", "UPS", "DHL", "USPS")
return cls.__random__.alternative(carriers)
@classmethod
def tracking_number(cls) -> str:
return ''.be part of(cls.__random__.decisions('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', ok=12))
class OrderFactory(DataclassFactory(Order)):
@classmethod
def order_id(cls) -> str:
return f"ORD-{datetime.now().12 months}-{cls.__random__.randint(100000, 999999)}"
@classmethod
def gadgets(cls) -> Listing(OrderItem):
return OrderItemFactory.batch(cls.__random__.randint(1, 5))
@classmethod
def construct(cls, **kwargs):
occasion = tremendous().construct(**kwargs)
if occasion.total_amount is None:
occasion.total_amount = spherical(sum(merchandise.total_price for merchandise in occasion.gadgets), 2)
if occasion.shipping_info is None and occasion.standing in (OrderStatus.SHIPPED, OrderStatus.DELIVERED):
occasion.shipping_info = ShippingInfoFactory.construct()
return occasion
orders = OrderFactory.batch(2)
print("Generated Orders:")
for order in orders:
print(f"n Order {order.order_id}")
print(f" Buyer: {order.customer_name} ({order.customer_email})")
print(f" Standing: {order.standing.worth}")
print(f" Objects ({len(order.gadgets)}):")
for merchandise so as.gadgets:
print(f" - {merchandise.amount}x {merchandise.product_name} @ ${merchandise.unit_price:.2f} = ${merchandise.total_price:.2f}")
print(f" Complete: ${order.total_amount:.2f}")
if order.shipping_info:
print(f" Transport: {order.shipping_info.service} - {order.shipping_info.tracking_number}")
print("n")Wir bauen eine komplexere Domänenlogik auf, indem wir berechnete und abhängige Felder in Fabriken einführen. Wir zeigen, wie wir nach der Objekterstellung Werte wie Endpreise, Gesamtsummen und Versanddetails ableiten können. Dadurch können wir realistische Geschäftsregeln direkt in unseren Testdatengeneratoren modellieren.
print("=" * 80)
print("SECTION 7: Attrs Integration")
print("=" * 80)
import attrs
from polyfactory.factories.attrs_factory import AttrsFactory
@attrs.outline
class BlogPost:
title: str
creator: str
content material: str
views: int = 0
likes: int = 0
printed: bool = False
published_at: Optionally available(datetime) = None
tags: Listing(str) = attrs.subject(manufacturing unit=listing)
class BlogPostFactory(AttrsFactory(BlogPost)):
@classmethod
def title(cls) -> str:
templates = (
"10 Ideas for {}",
"Understanding {}",
"The Full Information to {}",
"Why {} Issues",
"Getting Began with {}"
)
subjects = ("Python", "Knowledge Science", "Machine Studying", "Internet Improvement", "DevOps")
template = cls.__random__.alternative(templates)
subject = cls.__random__.alternative(subjects)
return template.format(subject)
@classmethod
def content material(cls) -> str:
return " ".be part of(Faker().sentences(nb=cls.__random__.randint(3, 8)))
@classmethod
def views(cls) -> int:
return cls.__random__.randint(0, 10000)
@classmethod
def likes(cls) -> int:
return cls.__random__.randint(0, 1000)
@classmethod
def tags(cls) -> Listing(str):
all_tags = ("python", "tutorial", "newbie", "superior", "information",
"suggestions", "best-practices", "2024")
return cls.__random__.pattern(all_tags, ok=cls.__random__.randint(2, 5))
posts = BlogPostFactory.batch(3)
print("Generated Weblog Posts:")
for publish in posts:
print(f"n '{publish.title}'")
print(f" Writer: {publish.creator}")
print(f" Views: {publish.views:,} | Likes: {publish.likes:,}")
print(f" Printed: {publish.printed}")
print(f" Tags: {', '.be part of(publish.tags)}")
print(f" Preview: {publish.content material(:100)}...")
print("n")
print("=" * 80)
print("SECTION 8: Constructing with Particular Overrides")
print("=" * 80)
custom_person = PersonFactory.construct(
identify="Alice Johnson",
age=30,
electronic mail="(electronic mail protected)"
)
print(f"Customized Particular person:")
print(f" Title: {custom_person.identify}")
print(f" Age: {custom_person.age}")
print(f" Electronic mail: {custom_person.electronic mail}")
print(f" ID (auto-generated): {custom_person.id}")
print()
vip_customers = PersonFactory.batch(
3,
bio="VIP Buyer"
)
print("VIP Prospects:")
for buyer in vip_customers:
print(f" {buyer.identify}: {buyer.bio}")
print("n")Wir erweitern die Polyfactory-Nutzung auf validierte Pydantic-Modelle und attrs-basierte Klassen. Wir zeigen, wie wir Feldeinschränkungen, Validatoren und Standardverhalten respektieren und gleichzeitig gültige Daten im großen Maßstab generieren können. Es stellt sicher, dass unsere Scheindaten mit echten Anwendungsschemata kompatibel bleiben.
print("=" * 80)
print("SECTION 9: Subject-Stage Management with Use and Ignore")
print("=" * 80)
from polyfactory.fields import Use, Ignore
@dataclass
class Configuration:
app_name: str
model: str
debug: bool
created_at: datetime
api_key: str
secret_key: str
class ConfigFactory(DataclassFactory(Configuration)):
app_name = Use(lambda: "MyAwesomeApp")
model = Use(lambda: "1.0.0")
debug = Use(lambda: False)
@classmethod
def api_key(cls) -> str:
return f"api_key_{''.be part of(cls.__random__.decisions('0123456789abcdef', ok=32))}"
@classmethod
def secret_key(cls) -> str:
return f"secret_{''.be part of(cls.__random__.decisions('0123456789abcdef', ok=64))}"
configs = ConfigFactory.batch(2)
print("Generated Configurations:")
for config in configs:
print(f" App: {config.app_name} v{config.model}")
print(f" Debug: {config.debug}")
print(f" API Key: {config.api_key(:20)}...")
print(f" Created: {config.created_at}")
print()
print()
print("=" * 80)
print("SECTION 10: Mannequin Protection Testing")
print("=" * 80)
from pydantic import BaseModel, ConfigDict
from typing import Union
class PaymentMethod(BaseModel):
model_config = ConfigDict(use_enum_values=True)
kind: str
card_number: Optionally available(str) = None
bank_name: Optionally available(str) = None
verified: bool = False
class PaymentMethodFactory(ModelFactory(PaymentMethod)):
__model__ = PaymentMethod
payment_methods = (
PaymentMethodFactory.construct(kind="card", card_number="4111111111111111"),
PaymentMethodFactory.construct(kind="financial institution", bank_name="Chase Financial institution"),
PaymentMethodFactory.construct(verified=True),
)
print("Fee Technique Protection:")
for i, pm in enumerate(payment_methods, 1):
print(f" {i}. Sort: {pm.kind}")
if pm.card_number:
print(f" Card: {pm.card_number}")
if pm.bank_name:
print(f" Financial institution: {pm.bank_name}")
print(f" Verified: {pm.verified}")
print("n")
print("=" * 80)
print("TUTORIAL SUMMARY")
print("=" * 80)
print("""
This tutorial lined:
1. ✓ Fundamental Dataclass Factories - Easy mock information technology
2. ✓ Customized Subject Mills - Controlling particular person subject values
3. ✓ Subject Constraints - Utilizing PostGenerated for calculated fields
4. ✓ Pydantic Integration - Working with validated fashions
5. ✓ Complicated Nested Buildings - Constructing associated objects
6. ✓ Attrs Help - Different to dataclasses
7. ✓ Construct Overrides - Customizing particular situations
8. ✓ Use and Ignore - Specific subject management
9. ✓ Protection Testing - Making certain complete check information
Key Takeaways:
- Polyfactory mechanically generates mock information from kind hints
- Customise technology with classmethods and interior decorators
- Helps a number of libraries: dataclasses, Pydantic, attrs, msgspec
- Use PostGenerated for calculated/dependent fields
- Override particular values whereas preserving others random
- Excellent for testing, improvement, and prototyping
For extra info:
- Documentation: https://polyfactory.litestar.dev/
- GitHub: https://github.com/litestar-org/polyfactory
""")
print("=" * 80)Wir decken erweiterte Nutzungsmuster wie explizite Überschreibungen, konstante Feldwerte und Abdeckungstestszenarien ab. Wir zeigen, wie wir gezielt Randfälle und Varianteninstanzen für robuste Checks konstruieren können. Dieser letzte Schritt verbindet alles miteinander, indem er zeigt, wie Polyfactory umfassende und produktionstaugliche Testdatenstrategien unterstützt.
Abschließend haben wir gezeigt, wie Polyfactory es uns ermöglicht, umfassende, versatile Testdaten mit minimalem Boilerplate zu erstellen und dabei dennoch die detaillierte Kontrolle über jedes Feld zu behalten. Wir haben gezeigt, wie man mit einfachen Entitäten, komplexen verschachtelten Strukturen und Pydantic-Modellvalidierung sowie expliziten Feldüberschreibungen innerhalb eines einzigen, konsistenten, fabrikbasierten Ansatzes umgeht. Insgesamt haben wir festgestellt, dass wir mit Polyfactory schneller vorankommen und sicherer testen können, da es zuverlässig realistische Datensätze generiert, die produktionsähnliche Szenarien genau widerspiegeln, ohne dass die Klarheit oder Wartbarkeit darunter leidet.
Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.
