Factory Boy

https://factoryboy.readthedocs.io/en/stable/
Admin
Factory Boy is a Python fixtures replacement tool that provides easy-to-use factories for generating...
Tokens:142,546
Snippets:1,034
Trust Score:8.3
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example output of RandomUserFactory

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows an example output of creating a RandomUserFactory instance.

```python
>>> RandomUserFactory()
<User: Lucy Murray>
```

--------------------------------

### Install factory_boy from source

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Clone the factory_boy repository from GitHub and install it using setup.py. This method is for development or when you need the latest source.

```bash
$ git clone git://github.com/FactoryBoy/factory_boy/
$ python setup.py install

```

--------------------------------

### Output of simple SQLAlchemyModelFactory example

Source: https://factoryboy.readthedocs.io/en/stable/orms.html

Shows the output of creating a user with the simple SQLAlchemyModelFactory example. The session query confirms the user was added to the database.

```python
>>> session.query(User).all()
[]
>>> UserFactory()
<User: User 0>
>>> session.query(User).all()
[<User: User 0>]

```

--------------------------------

### Install factory_boy with pip

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Install factory_boy from PyPI using pip. This is the standard installation method.

```bash
$ pip install factory_boy

```

--------------------------------

### Install development dependencies

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Installs the package in editable mode with the 'dev' extra, which includes dependencies for development and testing.

```bash
$ pip install --editable '.[dev]'

```

--------------------------------

### Parent reference example output

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Output of the parent reference example: the owner's language is taken from the country's language.

```pycon
>>> company = CompanyFactory()
>>> company.country.language
'fr'
>>> company.owner.language
'fr'
```

--------------------------------

### make_factory

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Documentation for the make_factory function, including its signature, parameters, and usage examples.

```APIDOC
## make_factory

### Description
Takes a class, declarations as keyword arguments, and generates a new Factory for that class accordingly. An alternate base class to Factory can be specified in the FACTORY_CLASS argument.

### Function Signature
`make_factory(klass, **kwargs)`

### Parameters
- **klass** (class) - Required - The class for which to generate a factory.
- **kwargs** (dict) - Optional - Declarations as keyword arguments. The `FACTORY_CLASS` kwarg can be used to specify an alternate base class (added in 2.0.0).

### Usage Example
```python
UserFactory = make_factory(User,
    login='john',
    email=factory.LazyAttribute(lambda u: '%s@example.com' % u.login),
)
```

### Alternate Base Class Example
```python
UserFactory = make_factory(models.User,
    login='john',
    email=factory.LazyAttribute(lambda u: '%s@example.com' % u.login),
    FACTORY_CLASS=factory.django.DjangoModelFactory,
)
```
```

--------------------------------

### Simple SQLAlchemyModelFactory example with SQLite

Source: https://factoryboy.readthedocs.io/en/stable/orms.html

A complete, simple example of using SQLAlchemyModelFactory with a SQLAlchemy session. It sets up an in-memory SQLite database, defines a User model, and creates a factory that uses the session and sequence attributes for id and name.

```python
from sqlalchemy import Column, Integer, Unicode, create_engine
from sqlalchemy.orm import declarative_base, scoped_session, sessionmaker

engine = create_engine('sqlite://')
session = scoped_session(sessionmaker(bind=engine))
Base = declarative_base()


class User(Base):
    """ A SQLAlchemy simple model class who represents a user """
    __tablename__ = 'UserTable'

    id = Column(Integer(), primary_key=True)
    name = Column(Unicode(20))

Base.metadata.create_all(engine)

import factory

class UserFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = User
        sqlalchemy_session = session   # the SQLAlchemy session object

    id = factory.Sequence(lambda n: n)
    name = factory.Sequence(lambda n: 'User %d' % n)

```

--------------------------------

### SubFactory calling example

Source: https://factoryboy.readthedocs.io/en/stable/reference.html

Shows the output of calling CompanyFactory, demonstrating that the SubFactory's first_name override is applied.

```python
>>> c = CompanyFactory()
>>> c
<Company: FactoryBoyz>

# Notice that the first_name was overridden
>>> c.owner
<User: Jack De>
>>> c.owner.email
jack.de@example.org

```

--------------------------------

### factory.debug output example

Source: https://factoryboy.readthedocs.io/en/stable/reference.html

Example debug output from factory.debug() showing the sequence of operations during a factory call, including SubFactory instantiation and value computation.

```python
BaseFactory: Preparing tests.test_using.TestModel2Factory(extra={})
  LazyStub: Computing values for tests.test_using.TestModel2Factory(two=<OrderedDeclarationWrapper for <factory.declarations.SubFactory object at 0x1e15610>>)
    SubFactory: Instantiating tests.test_using.TestModelFactory(__containers=(<LazyStub for tests.test_using.TestModel2Factory>,), one=4), create=True
    BaseFactory: Preparing tests.test_using.TestModelFactory(extra={'__containers': (<LazyStub for tests.test_using.TestModel2Factory>,), 'one': 4})
      LazyStub: Computing values for tests.test_using.TestModelFactory(one=4)
      LazyStub: Computed values, got tests.test_using.TestModelFactory(one=4)
    BaseFactory: Generating tests.test_using.TestModelFactory(one=4)
  LazyStub: Computed values, got tests.test_using.TestModel2Factory(two=<tests.test_using.TestModel object at 0x1e15410>)
BaseFactory: Generating tests.test_using.TestModel2Factory(two=<tests.test_using.TestModel object at 0x1e15410>)
```

--------------------------------

### Sample debug log output

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Example output from factory.debug() showing the sequence of LazyStub and SubFactory operations. Useful for understanding the internal call chain.

```text
BaseFactory: Preparing tests.test_using.TestModel2Factory(extra={})
  LazyStub: Computing values for tests.test_using.TestModel2Factory(two=<OrderedDeclarationWrapper for <factory.declarations.SubFactory object at 0x1e15610>>)
    SubFactory: Instantiating tests.test_using.TestModelFactory(__containers=(<LazyStub for tests.test_using.TestModel2Factory>,), one=4), create=True
    BaseFactory: Preparing tests.test_using.TestModelFactory(extra={'__containers': (<LazyStub for tests.test_using.TestModel2Factory>,), 'one': 4})
      LazyStub: Computing values for tests.test_using.TestModelFactory(one=4)
      LazyStub: Computed values, got tests.test_using.TestModelFactory(one=4)
    BaseFactory: Generating tests.test_using.TestModelFactory(one=4)
  LazyStub: Computed values, got tests.test_using.TestModel2Factory(two=<tests.test_using.TestModel object at 0x1e15410>)
BaseFactory: Generating tests.test_using.TestModel2Factory(two=<tests.test_using.TestModel object at 0x1e15410>)

```

--------------------------------

### SubFactory strategy propagation example

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows how the associated object's strategy is used: create() saves both, build() saves neither.

```python
# Builds and saves a User and a Post
>>> post = PostFactory()
>>> post.id is None  # Post has been 'saved'
False
>>> post.author.id is None  # post.author has been saved
False

# Builds but does not save a User, and then builds but does not save a Post
>>> post = PostFactory.build()
>>> post.id is None
True
>>> post.author.id is None
True
```

--------------------------------

### UserFactory build and create usage

Source: https://factoryboy.readthedocs.io/en/stable/reference.html

Example usage of the decorated UserFactory. build() does not create the directory, while create() creates it based on the login or the extracted mbox value.

```python
>>> UserFactory.build()                  # Nothing was created
>>> UserFactory.create()                 # Creates dir /tmp/mbox/john
>>> UserFactory.create(login='jack')     # Creates dir /tmp/mbox/jack
>>> UserFactory.create(mbox='/tmp/alt')  # Creates dir /tmp/alt

```

--------------------------------

### Output of RandomUserFactory instantiation

Source: https://factoryboy.readthedocs.io/en/stable/index.html

Example output of instantiating a factory with Faker attributes, showing a random user name.

```python
>>> RandomUserFactory()
<User: Lucy Murray>

```

--------------------------------

### Generate unique values with Sequence

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows how to use factory.Sequence to generate unique values in a specific format, with example outputs.

```python
class UserFactory(factory.Factory):
    class Meta:
        model = models.User

    email = factory.Sequence(lambda n: 'person{}@example.com'.format(n))

>>> UserFactory().email
'person0@example.com'
>>> UserFactory().email
'person1@example.com'
```

--------------------------------

### Iterator reset example

Source: https://factoryboy.readthedocs.io/en/stable/reference.html

Shows how to reset the iterator to start from the first value again using the reset() method.

```python
>>> UserFactory().lang
'en'
>>> UserFactory().lang
'fr'
>>> UserFactory.lang.reset()
>>> UserFactory().lang
'en'

```

--------------------------------

### Build documentation

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Runs the build steps for documentation, first generating egg_info and then building docs.

```bash
python setup.py egg_info
make doc

```

--------------------------------

### Use create and build strategies

Source: https://factoryboy.readthedocs.io/en/stable/introduction.html

Shows the output of calling MyFactory.create(), MyFactory.build(), and MyFactory() (equivalent to create).

```python
>>> MyFactory.create()
<MyFactory: X (saved)>

>>> MyFactory.build()
<MyFactory: X (unsaved)>

>>> MyFactory()  # equivalent to MyFactory.create()
<MyClass: X (saved)>
```

--------------------------------

### FuzzyDateTime default end_dt example

Source: https://factoryboy.readthedocs.io/en/stable/_sources/fuzzy.rst.txt

Displays the default end_dt value when only start_dt is provided. The output shows the start and end bounds as datetime objects, with end_dt defaulting to the current UTC time (example captured at 2013-04-21 19:13:32.458487).

```pycon
>>> fdt = FuzzyDateTime(datetime.datetime(2008, 1, 1, tzinfo=UTC))
>>> fdt.start_dt, fdt.end_dt
datetime.datetime(2008, 1, 1, tzinfo=UTC), datetime.datetime(2013, 4, 21, 19, 13, 32, 458487, tzinfo=UTC)
```

--------------------------------

### FuzzyNaiveDateTime default end_dt example

Source: https://factoryboy.readthedocs.io/en/stable/_sources/fuzzy.rst.txt

Shows default end_dt value when omitted for FuzzyNaiveDateTime; the output shows the start and end datetimes, with end_dt defaulting to datetime.datetime.now().

```pycon
>>> fdt = FuzzyNaiveDateTime(datetime.datetime(2008, 1, 1))
>>> fdt.start_dt, fdt.end_dt
datetime.datetime(2008, 1, 1), datetime.datetime(2013, 4, 21, 19, 13, 32, 458487)
```

--------------------------------

### FuzzyDate end_date defaults to current date

Source: https://factoryboy.readthedocs.io/en/stable/_sources/fuzzy.rst.txt

Shows that the end_date of FuzzyDate defaults to the current date when omitted. The example creates a FuzzyDate with start_date 2008-01-01 and shows the resulting start and end dates.

```pycon
>>> fd = FuzzyDate(datetime.date(2008, 1, 1))
>>> fd.start_date, fd.end_date
datetime.date(2008, 1, 1), datetime.date(2013, 4, 16)
```

--------------------------------

### Create strategy implementation

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Illustrates the create strategy: instantiate the model, save it, and return it.

```pycon
>>> obj = self._associated_class(*args, **kwargs)
>>> obj.save()
>>> return obj
```

--------------------------------

### Use build, create, and stub instantiation strategies

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows the three instantiation strategies: build returns an unsaved instance, create returns a saved instance (requires ORM base class), and stub returns a stub object with just attributes.

```python
# Returns a User instance that's not saved
user = UserFactory.build()

# Returns a saved User instance.
# UserFactory must subclass an ORM base class, such as DjangoModelFactory.
user = UserFactory.create()

# Returns a stub object (just a bunch of attributes)
obj = UserFactory.stub()
```

--------------------------------

### SelfAttribute example output

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Output of the SelfAttribute example: birthmonth is set to the month of the birthdate field.

```pycon
>>> u = UserFactory()
>>> u.birthdate
date(2000, 3, 15)
>>> u.birthmonth
3
```

--------------------------------

### Using the simple factory

Source: https://factoryboy.readthedocs.io/en/stable/_sources/orms.rst.txt

Shows the usage of the simple factory: initially no users exist, creating a user adds one to the session, and querying returns the created user.

```pycon
>>> session.query(User).all()
[]
>>> UserFactory()
<User: User 0>
>>> session.query(User).all()
[<User: User 0>]
```

--------------------------------

### Create fixtures with factories

Source: https://factoryboy.readthedocs.io/en/stable/_sources/examples.rst.txt

Shows how to use factories to create fixture objects, including creating a batch of 50 profiles and then creating specific known profiles with overridden attributes.

```python
from . import factories

def make_objects():
    factories.ProfileFactory.create_batch(size=50)

    # Let's create a few, known objects.
    factories.ProfileFactory(
        gender=objects.Profile.GENDER_MALE,
        firstname='Luke',
        lastname='Skywalker',
        planet='Tatooine',
    )

    factories.ProfileFactory(
        gender=objects.Profile.GENDER_FEMALE,
        firstname='Leia',
        lastname='Organa',
        planet='Alderaan',
    )
```

--------------------------------

### Use factory as shortcut for default strategy

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows that calling the factory class directly is equivalent to using the default strategy, which is create() by default.

```python
# Same as UserFactory.create()
user = UserFactory()
```

--------------------------------

### Using inline_args in a Factory

Source: https://factoryboy.readthedocs.io/en/stable/reference.html

Demonstrates the inline_args Meta option, which lists non-keyword arguments for the model's __init__. The second block shows the resulting call and output.

```python
class UserFactory(factory.Factory):
    class Meta:
        model = User
        inline_args = ('login', 'email')

    login = 'john'
    email = factory.LazyAttribute(lambda o: '%s@example.com' % o.login)
    firstname = "John"

```

```python
>>> UserFactory()
<User: john>
>>> User('john', 'john@example.com', firstname="John")  # actual call

```

--------------------------------

### Define a basic factory with factory.Factory

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows how to declare a factory by setting the model in class Meta and defining attributes. Two factories for the same model are shown: UserFactory and AdminFactory.

```python
import factory
from . import models

class UserFactory(factory.Factory):
    class Meta:
        model = models.User

    first_name = 'John'
    last_name = 'Doe'
    admin = False

# Another, different, factory for the same object
class AdminFactory(factory.Factory):
    class Meta:
        model = models.User

    first_name = 'Admin'
    last_name = 'User'
    admin = True
```

--------------------------------

### create and create_batch

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Helper functions to create instances from a factory.

```APIDOC
## create(klass, FACTORY_CLASS=None, **kwargs)

### Description
Creates a factory for the given class and returns an instance created with the CREATE_STRATEGY.

### Parameters
- **klass** (type) - Required - Class of the instance to create
- **FACTORY_CLASS** (type) - Optional - Alternate base class (instead of Factory)
- **kwargs** (dict) - Optional - Declarations to use for the generated factory

### Returns
An instance created from the factory.
```

```APIDOC
## create_batch(klass, size, FACTORY_CLASS=None, **kwargs)

### Description
Creates a factory for the given class and returns a list of instances created with the CREATE_STRATEGY.

### Parameters
- **klass** (type) - Required - Class of the instance to create
- **size** (int) - Required - Number of instances to create
- **FACTORY_CLASS** (type) - Optional - Alternate base class (instead of Factory)
- **kwargs** (dict) - Optional - Declarations to use for the generated factory

### Returns
A list of created instances.
```

--------------------------------

### build and build_batch

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Helper functions to build instances from a factory.

```APIDOC
## build(klass, FACTORY_CLASS=None, **kwargs)

### Description
Creates a factory for the given class using the provided declarations and returns an instance built with the BUILD_STRATEGY.

### Parameters
- **klass** (type) - Required - Class of the instance to build
- **FACTORY_CLASS** (type) - Optional - Alternate base class (instead of Factory)
- **kwargs** (dict) - Optional - Declarations to use for the generated factory

### Returns
An instance built from the factory.
```

```APIDOC
## build_batch(klass, size, FACTORY_CLASS=None, **kwargs)

### Description
Creates a factory for the given class and returns a list of instances built with the BUILD_STRATEGY.

### Parameters
- **klass** (type) - Required - Class of the instance to build
- **size** (int) - Required - Number of instances to build
- **FACTORY_CLASS** (type) - Optional - Alternate base class (instead of Factory)
- **kwargs** (dict) - Optional - Declarations to use for the generated factory

### Returns
A list of built instances.
```

--------------------------------

### factory.Trait

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Documentation for the factory.Trait class, including usage examples and notes on overriding.

```APIDOC
## [Trait] factory.Trait

### Description
Defines a set of attribute values that can be applied to a factory instance. Traits can be overridden by call-time values and can be chained together.

### Usage

```python
class OrderFactory(factory.Factory):
    class Meta:
        model = Order

    state = 'pending'
    shipped_on = None
    shipped_by = None
    received_on = None
    received_by = None

    class Params:
        shipped = factory.Trait(
            state='shipped',
            shipped_on=datetime.date.today,
            shipped_by=factory.SubFactory(EmployeeFactory),
        )
        received = factory.Trait(
            shipped=True,
            state='received',
            shipped_on=datetime.date.today - datetime.timedelta(days=4),
            received_on=datetime.date.today,
            received_by=factory.SubFactory(CustomerFactory),
        )
```

### Notes
- Traits can be overridden by call-time values.
- Traits can be chained.
- When overriding a Trait in a Factory subclass, the whole declaration MUST be replaced.
```

--------------------------------

### SQLAlchemyModelFactory

Source: https://factoryboy.readthedocs.io/en/stable/orms.html

Documentation for the SQLAlchemyModelFactory class, including its Meta options and usage examples.

```APIDOC
## SQLAlchemyModelFactory

### Description
Dedicated class for SQLAlchemy models. This class provides the following features: `create()` uses `sqlalchemy.orm.Session.add()`.

### Class
`factory.alchemy.SQLAlchemyModelFactory`

### Meta Options

#### sqlalchemy_session
- **Type**: SQLAlchemy session
- **Required**: No
- **Description**: SQLAlchemy session to use to communicate with the database when creating an object through this `SQLAlchemyModelFactory`.

#### sqlalchemy_session_factory
- **Type**: Callable returning a `Session` instance
- **Required**: No
- **Description**: Callable returning a `Session` instance to use to communicate with the database. You can either provide the session through this attribute, or through `sqlalchemy_session`, but not both at the same time.

#### sqlalchemy_session_persistence
- **Type**: String or None
- **Required**: No
- **Description**: Control the action taken by `sqlalchemy_session` at the end of a create call. Valid values are: `None` (do nothing), `'flush'` (perform a session `flush()`), `'commit'` (perform a session `commit()`). The default value is `None`.

#### sqlalchemy_get_or_create
- **Type**: List of field names
- **Required**: No
- **Description**: Fields whose name are passed in this list will be used to perform a `Model.query.one_or_none()` or the usual `Session.add()`.

### Example
```python
from . import common

class UserFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = User
        sqlalchemy_session_factory = lambda: common.Session()

    username = 'john'
```

### Example with get_or_create
```python
class UserFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = User
        sqlalchemy_session = session
        sqlalchemy_get_or_create = ('username',)

    username = 'john'
```

### Example with session
```python
from sqlalchemy import Column, Integer, Unicode, create_engine
from sqlalchemy.orm import declarative_base, scoped_session, sessionmaker

engine = create_engine('sqlite://')
session = scoped_session(sessionmaker(bind=engine))
Base = declarative_base()

class User(Base):
    """ A SQLAlchemy simple model class who represents a user """
    __tablename__ = 'UserTable'

    id = Column(Integer(), primary_key=True)
    name = Column(Unicode(20))

Base.metadata.create_all(engine)

import factory

class UserFactory(factory.alchemy.SQLAlchemyModelFactory):
    class Meta:
        model = User
        sqlalchemy_session = session   # the SQLAlchemy session object

    id = factory.Sequence(lambda n: n)
    name = factory.Sequence(lambda n: 'User %d' % n)
```
```

--------------------------------

### Test with factory_boy vs without factory_boy

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows a side-by-side comparison of writing a test with factory_boy versus manually constructing objects. The factory_boy example uses OrderFactory with field overrides and nested attributes, while the manual example creates Address, Customer, and other objects explicitly. This illustrates the convenience of factory_boy for test-specific customization.

```python
class FooTests(unittest.TestCase):

    def test_with_factory_boy(self):
        # We need a 200€, paid order, shipping to australia, for a VIP customer
        order = OrderFactory(
            amount=200,
            status='PAID',
            customer__is_vip=True,
            address__country='AU',
        )
        # Run the tests here

    def test_without_factory_boy(self):
        address = Address(
            street="42 fubar street",
            zipcode="42Z42",
            city="Sydney",
            country="AU",
        )
        customer = Customer(
            first_name="John",
            last_name="Doe",
            phone="+1234",
            email="john.doe@example.org",
            active=True,
            is_vip=True,
            address=address,
        )
        # etc.

```

--------------------------------

### PostGenerationMethodCall

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Documentation for the PostGenerationMethodCall declaration class, including its constructor parameters and usage example.

```APIDOC
## PostGenerationMethodCall

### Description
Declares a method to be called on the generated object just after instantiation. This declaration class provides a friendly means of generating attributes of a factory instance during initialization.

### Constructor
`PostGenerationMethodCall(method_name, *arg, **kwargs)`

### Parameters
- **method_name** (string) - Required - The name of the method to call on the model object.
- **arg** (any) - Optional - The default, optional, positional argument to pass to the method.
- **kwargs** (dict) - Optional - The default set of keyword arguments to pass to the method.

### Usage Example
```python
class User(models.Model):
    name = models.CharField(max_length=191)

    def register(self, system, auth_token="ABC"):
        self.registration_id = system.register(auth_token)

class UserFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = User

    name = 'user'
    register = factory.PostGenerationMethodCall("register", DefaultRegistry())
```

### Notes
- Allows at most one positional argument; all other parameters should be passed as keyword arguments.
- Keywords extracted from the factory arguments are merged into the defaults present in the declaration.
```

--------------------------------

### Output of LazyAttribute email

Source: https://factoryboy.readthedocs.io/en/stable/index.html

Output of the LazyAttribute example, showing the computed email address.

```python
>>> UserFactory().email
"joe.blow@example.com"

```

--------------------------------

### Factory with inline_args

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Demonstrates the inline_args Meta option for factories that require non-keyword arguments to __init__. The example shows a UserFactory with inline_args ('login', 'email') and the resulting call to User('john', 'john@example.com', firstname="John").

```python
class UserFactory(factory.Factory):
    class Meta:
        model = User
        inline_args = ('login', 'email')

    login = 'john'
    email = factory.LazyAttribute(lambda o: '%s@example.com' % o.login)
    firstname = "John"
```

```pycon
>>> UserFactory()
<User: john>
>>> User('john', 'john@example.com', firstname="John")  # actual call
```

--------------------------------

### Example output of LazyAttribute

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows the output of accessing the email attribute of a UserFactory instance.

```python
>>> UserFactory().email
"joe.blow@example.com"
```

--------------------------------

### Calling a Factory class

Source: https://factoryboy.readthedocs.io/en/stable/reference.html

Shows the typical way to call a Factory class, which invokes the default strategy (create) with the given keyword arguments.

```python
>>> UserFactory()               # Calls UserFactory.create()
>>> UserFactory(login='john')   # Calls UserFactory.create(login='john')

```

--------------------------------

### Creating a Faker declaration

Source: https://factoryboy.readthedocs.io/en/stable/_modules/factory/faker.html

Interactive example of creating a Faker declaration for a 'name' provider.

```python
>>> foo = factory.Faker('name')
```

--------------------------------

### Reset iterator to first value

Source: https://factoryboy.readthedocs.io/en/stable/_sources/reference.rst.txt

Shows resetting the iterator to start from the first value again.

```pycon
>>> UserFactory().lang
'en'
>>> UserFactory().lang
'fr'
>>> UserFactory.lang.reset()
>>> UserFactory().lang
'en'
```

--------------------------------

### Create a batch of objects with build_batch

Source: https://factoryboy.readthedocs.io/en/stable/index.html?__cf_chl_rt_tk=1HwICJ7vgijNigv8SwZFwhI3EfuCntWQkJZb5sIxVOE-1790943257-1.0.1.1-3tczTpCDdbE65YUT5kLvyg.SsbDWQlh000O1foFPgGg

Shows how to create multiple objects in a single call using build_batch, and verifies the count and values.

```python
>>> users = UserFactory.build_batch(10, first_name="Joe")
>>> len(users)
10
>>> [user.first_name for user in users]
["Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe", "Joe"]
```

--------------------------------

### Django model with GenericForeignKey

Source: https://factoryboy.readthedocs.io/en/stable/recipes.html

Example Django model using GenericForeignKey, as shown in the Django docs.

```python
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models


class TaggedItem(models.Model):
    """Example GenericForeignKey model from django docs"""
    tag = models.SlugField()
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey('content_type', 'object_id')

    def __str__(self):
        return self.tag

```

--------------------------------

### FuzzyNaiveDateTime

Source: https://factoryboy.readthedocs.io/en/stable/_sources/fuzzy.rst.txt

Documentation for the FuzzyNaiveDateTime fuzzer class, including constructor parameters, attributes, and usage examples.

```APIDOC
## FuzzyNaiveDateTime

### Description
Generates random naive datetime within a given inclusive range. The end_dt bound may be omitted, defaulting to datetime.datetime.now(). The force_XXX keyword arguments force the related value of generated datetimes.

### Constructor
FuzzyNaiveDateTime(start_dt[, end_dt], force_year=None, force_month=None, force_day=None, force_hour=None, force_minute=None, force_second=None, force_microsecond=None)

### Parameters
- **start_dt** (datetime.datetime) - Required - The inclusive lower bound of generated datetimes.
- **end_dt** (datetime.datetime) - Optional - The inclusive upper bound of generated datetimes. Defaults to datetime.datetime.now().
- **force_year** (int or None) - Optional - If set, forces the year of generated datetime.
- **force_month** (int or None) - Optional - If set, forces the month of generated datetime.
- **force_day** (int or None) - Optional - If set, forces the day of generated datetime.
- **force_hour** (int or None) - Optional - If set, forces the hour of generated datetime.
- **force_minute** (int or None) - Optional - If set, forces the minute of generated datetime.
- **force_second** (int or None) - Optional - If set, forces the second of generated datetime.
- **force_microsecond** (int or None) - Optional - If set, forces the microsecond of generated datetime.

### Attributes
- **start_dt** (datetime.datetime) - The inclusive lower bound of generated datetimes.
- **end_dt** (datetime.datetime) - The inclusive upper bound of generated datetimes.
- **force_year** (int or None) - If set, forces the year of generated datetime.
- **force_month** (int or None) - If set, forces the month of generated datetime.
- **force_day** (int or None) - If set, forces the day of generated datetime.
- **force_hour** (int or None) - If set, forces the hour of generated datetime.
- **force_minute** (int or None) - If set, forces the minute of generated datetime.
- **force_second** (int or None) - If set, forces the second of generated datetime.
- **force_microsecond** (int or None) - If set, forces the microsecond of generated datetime.

### Example
```pycon
>>> fdt = FuzzyNaiveDateTime(datetime.datetime(2008, 1, 1))
>>> fdt.start_dt, fdt.end_dt
datetime.datetime(2008, 1, 1), datetime.datetime(2013, 4, 21, 19, 13, 32, 458487)
```

```pycon
>>> fdt = FuzzyNaiveDateTime(datetime.datetime(2008, 1, 1), datetime.datetime(2009, 1, 1),
...     force_day=3, force_second=42)
>>> fdt.evaluate(2, None, False)  # Actual code used by ``SomeFactory.build()``
datetime.datetime(2008, 5, 3, 12, 13, 42, 124848)
```
```
Tokens:
Raw