API

This part of the documentation documents all the public classes and functions in Mixer.

Common interface

class mixer.main.Mixer(fake=True, factory=None, loglevel=30, silence=False, locale='en_US', **params)

This class is using for integration to an application.

Parameters:
  • fake – (True) Generate fake data instead of random data.
  • factory – (GenFactory) Fabric’s factory
class SomeScheme:
    score = int
    name = str

mixer = Mixer()
instance = mixer.blend(SomeScheme)
print instance.name  # Some like: 'Mike Douglass'

mixer = Mixer(fake=False)
instance = mixer.blend(SomeScheme)
print instance.name  # Some like: 'AKJfdjh3'
type_mixer_cls

alias of TypeMixer

blend(scheme, **values)

Generate instance of scheme.

Parameters:
  • scheme – Scheme class for generation or string with class path.
  • values – Keyword params with predefined values
Return value:

A generated instance

mixer = Mixer()

mixer.blend(SomeSheme, active=True)
print scheme.active  # True

mixer.blend('module.SomeSheme', active=True)
print scheme.active  # True
get_typemixer(scheme)

Return a cached typemixer instance.

Return TypeMixer:
 
static postprocess(target)

Run the code after generation.

Return target:
static sequence(*args)

Create a sequence for predefined values.

It makes a infinity loop with given function where does increment the counter on each iteration.

Parameters:args

If method get more one arguments, them make generator from arguments (loop on arguments). If that get one argument and this equal a function, method makes a generator from them. If argument is equal string it should be using as format string.

By default function is equal ‘lambda x: x’.

Returns:A generator

Mixer can uses a generators.

gen = (name for name in ['test0', 'test1', 'test2'])
for counter in range(3):
    mixer.blend(Scheme, name=gen)

Mixer.sequence is a helper for create generators more easy.

Generate values from sequence:

for _ in range(3):
    mixer.blend(Scheme, name=mixer.sequence('john', 'mike'))

Make a generator from function:

for counter in range(3):
    mixer.blend(Scheme, name=mixer.sequence(
        lambda c: 'test%s' % c
    ))

Short format is a python formating string

for counter in range(3):
    mixer.blend(Scheme, name=mixer.sequence('test{0}'))
cycle(count=5)

Generate a few objects. The syntastic sugar for cycles.

Parameters:count – List of objects or integer.
Returns:ProxyMixer
users = mixer.cycle(5).blend('somemodule.User')

profiles = mixer.cycle(5).blend(
    'somemodule.Profile', user=(user for user in users)

apples = mixer.cycle(10).blend(
    Apple, title=mixer.sequence('apple_{0}')
middleware(scheme)

Middleware decorator.

You could add the middleware layers to generation process:

from mixer.backend.django import mixer

# Register middleware to model
@mixer.middleware('auth.user')
def encrypt_password(user):
    user.set_password('test')
    return user

You can add several middlewares. Each middleware should get one argument (generated value) and return them.

register(scheme, **params)

Manualy register a function as value’s generator for class.field.

Parameters:
  • scheme – Scheme for generation (class or class path)
  • params – Kwargs with generator’s definitions (field_name=field_generator)
class Scheme:
    id = str
    title = str

def func():
    return 'ID'

mixer.register(
    Scheme,
    id=func,
    title='Always same',
)

test = mixer.blend(Scheme)
test.id == 'ID'
test.title == 'Always same'
ctx(*args, **kwds)

Redifine params for current mixer as context.

with mixer.ctx(commit=False):
    hole = mixer.blend(Hole)
    self.assertTrue(hole)
    self.assertFalse(Hole.objects.count())
reload(*objs)

Reload the objects from storage.

guard(*args, **kwargs)

Abstract method. In some backends used for prevent object creation.

Returns:A Proxy to mixer
class mixer.main.GenFactory

Make generators for types.

classmethod cls_to_simple(fcls)

Translate class to one of simple base types.

Return type:A simple type for generation
static name_to_simple(fname)

Translate name to one of simple base names.

Return str:
classmethod get_fabric(fcls, fname=None, fake=False)

Make a objects fabric based on class and name.

Return function:
 

Set values

class mixer.mix_types.Field(scheme, name, **params)

Set field values.

By default the mixer generates random or fake a field values by types of them. But you can set some values by manual.

# Generate a User model
mixer.blend(User)

# Generate with some values
mixer.blend(User, name='John Connor')

Note

Value may be a callable or instance of generator.

# Value may be callable
client = mixer.blend(Client, username=lambda:'callable_value')
assert client.username == 'callable_value'

# Value may be a generator
clients = mixer.cycle(4).blend(
    Client, username=(name for name in ('Piter', 'John')))

See also

mixer.main.Fake, mixer.main.Random, mixer.main.Select, mixer.main.Mixer.sequence()

Force a random values

class mixer.mix_types.Random(scheme=None, *choices, **params)

Force a random value.

If you initialized a Mixer by default mixer try to fill fields with fake data. You can user mixer.RANDOM for prevent this behaviour for a custom fields.

mixer = Mixer()
user = mixer.blend(User)
print user.name  # Some like: Bob Marley

user = mixer.blend(User, name=mixer.RANDOM)
print user.name  # Some like: Fdjw4das

You can setup a field type for generation of fake value:

user = mixer.blend(User, score=mixer.RANDOM(str))
print user.score  # Some like: Fdjw4das

Or you can get random value from choices:

user = mixer.blend(User, name=mixer.RANDOM('john', 'mike'))
 print user.name  # mike or john

Note

This is also useful on ORM model generation for randomize fields with default values (or null).

from mixer.backend.django import mixer

mixer.blend('auth.User', first_name=mixer.RANDOM)
print user.first_name  # Some like: Fdjw4das

Force a fake values

class mixer.mix_types.Fake(scheme=None, *choices, **params)

Force a fake value.

If you initialized a Mixer with fake=False you can force a fake value for field with this attribute (mixer.FAKE).

mixer = Mixer(fake=False)
user = mixer.blend(User)
print user.name  # Some like: Fdjw4das

user = mixer.blend(User, name=mixer.FAKE)
print user.name  # Some like: Bob Marley

You can setup a field type for generation of fake value:

user = mixer.blend(User, score=mixer.FAKE(str))
print user.score  # Some like: Bob Marley

Note

This is also usefull on ORM model generation for filling a fields with default values (or null).

from mixer.backend.django import mixer

user = mixer.blend('auth.User', first_name=mixer.FAKE)
print user.first_name  # Some like: John

Select a relation from database

class mixer.mix_types.Select(scheme=None, *choices, **params)

Select values from database.

When you generate some ORM models you can set value for related fields from database (select by random).

Example for Django (select user from exists):

from mixer.backend.django import mixer

mixer.generate(Role, user=mixer.SELECT)

You can setup a Django or SQLAlchemy filters with mixer.SELECT:

from mixer.backend.django import mixer

mixer.generate(Role, user=mixer.SELECT(
    username='test'
))

Virtual mixed object

class mixer.mix_types.Mix(value=None, parent=None)

Virtual link on the mixed object.

mixer = Mixer()

# here `mixer.MIX` points on a generated `User` instance
user = mixer.blend(User, username=mixer.MIX.first_name)

# here `mixer.MIX` points on a generated `Message.author` instance
message = mixer.blend(Message, author__name=mixer.MIX.login)

# Mixer mix can get a function
message = mixer.blend(Message, title=mixer.MIX.author(
    lambda author: 'Author: %s' % author.name
))