Mixer

7.2.2 · active · verified Thu Apr 16

Mixer is a Python library designed as a fixtures replacement, simplifying the creation of test data. It supports various ORMs like Django ORM, SQLAlchemy ORM, MongoEngine ODM, and plain Python objects. The current version is 7.2.2. It has a moderate release cadence, with updates and bug fixes released periodically.

Common errors

```
AttributeError: module 'mixer' has no attribute 'blend'
```
cause You likely tried `import mixer` and then `mixer.blend(...)` without initializing a `Mixer` instance or using a specific backend.

fix For plain Python objects: `from mixer.mix import Mixer; my_mixer = Mixer(); my_mixer.blend(...)`. For ORMs: `from mixer.backend.django import mixer; mixer.blend(...)`.
```
ImportError: cannot import name 'mixer' from 'mixer.main' (D:\...\mixer\main.py)
```
cause You are using an old import path from Mixer v6 or earlier that is no longer valid in v7+.

fix Update your import statement to use the specific backend, e.g., `from mixer.backend.django import mixer` or `from mixer.backend.sqlalchemy import mixer`.
```
TypeError: 'str' object is not callable (or similar for other types like 'int' object is not callable)
```
cause You passed the *result* of a faker function (e.g., `lorem.email()`) instead of the faker callable itself (`lorem.email`) to `mixer.blend` or `mixer.cycle`.

fix Remove the parentheses when passing faker functions: `mixer.blend(User, email=lorem.email)`.
```
django.db.utils.IntegrityError: NOT NULL constraint failed: myapp_mymodel.related_id
```
cause Mixer attempted to create a related object for a non-nullable ForeignKey, but either the creation failed, or no valid related object could be associated.

fix Ensure the related model is configured such that Mixer can create valid instances, or explicitly provide an existing related object: `mixer.blend(MyModel, related_field=existing_related_instance)`.

Warnings

breaking The `mixer.main.mixer` module and `mixer.mix.Mixer` (as a top-level callable) were removed or significantly changed. Direct imports like `from mixer.main import mixer` will fail.
Fix: Migrate your imports to use backend-specific instances (e.g., `from mixer.backend.django import mixer`) or explicitly instantiate `Mixer` for plain objects (`from mixer.mix import Mixer; mixer_instance = Mixer()`).
gotcha Using the wrong `mixer` instance for your ORM backend (e.g., using `mixer.mix.Mixer` instance for a Django model) will not correctly integrate with the ORM's save methods or relationships, potentially leading to validation errors or incorrect data.
Fix: Always import the correct mixer backend for your ORM: `from mixer.backend.django import mixer` for Django, `from mixer.backend.sqlalchemy import mixer` for SQLAlchemy, etc.
gotcha When providing callables (like `mixer.fakers` functions) to `mixer.blend` or `mixer.cycle`, pass the callable itself, not the result of calling it. Mixer will invoke the callable for each new object.
Fix: Instead of `mixer.blend(User, email=lorem.email())`, use `mixer.blend(User, email=lorem.email)`. If you need to pass arguments to the faker, use a lambda: `email=lambda: lorem.email(domain='example.com')`.
gotcha Mixer attempts to create related objects for foreign keys automatically. If a related object is not explicitly provided, and the foreign key is non-nullable, this can lead to `IntegrityError` if the automatically created related object is invalid or fails to save.
Fix: For non-nullable foreign keys, either ensure the related model can be created by Mixer successfully, or explicitly pass an existing instance of the related object: `mixer.blend(MyModel, foreign_key_field=existing_related_instance)`.

Install

pip install mixer Install core library
pip install mixer[django] Install with Django support
pip install mixer[sqlalchemy] Install with SQLAlchemy support
pip install mixer[mongoengine] Install with MongoEngine support

Imports

Mixer
wrong:
```
import mixer
```
correct:
```
from mixer.mix import Mixer
```
For creating plain Python objects or using custom backends. The top-level 'mixer' module does not expose a callable Mixer directly.
mixer (Django backend)
wrong:
```
from mixer.main import mixer
```
correct:
```
from mixer.backend.django import mixer
```
The 'mixer.main' module was removed in v7. Use specific backend imports.
mixer (SQLAlchemy backend)
wrong:
```
from mixer import mixer
```
correct:
```
from mixer.backend.sqlalchemy import mixer
```
Direct import from 'mixer' is ambiguous; use specific backend imports for ORM integration.

Quickstart

This quickstart demonstrates how to initialize the `Mixer` for plain Python objects and use `mixer.blend` to create single instances, and `mixer.cycle` to create multiple unique instances, with or without overriding specific fields.

from mixer.mix import Mixer

class User:
    def __init__(self, name: str, email: str, age: int):
        self.name = name
        self.email = email
        self.age = age

    def __repr__(self):
        return f"User(name='{self.name}', email='{self.email}', age={self.age})"

mixer = Mixer() # Initialize a mixer instance for plain Python objects

# Create a single user with random data
user_instance = mixer.blend(User)
print(f"Random User: {user_instance}")

# Create a user with specific fields
specific_user = mixer.blend(User, name='Alice', age=30)
print(f"Specific User: {specific_user}")

# Create multiple unique users
users_list = mixer.cycle(3, User)
print("\nMultiple Users:")
for user in users_list:
    print(user)

view raw JSON →