Metadata-Version: 1.1
Name: django-fakery
Version: 1.4.0
Summary: A model instances generator for Django
Home-page: https://github.com/fcurella/django-fakery/
Author: Flavio Curella
Author-email: flavio.curella@gmail.com
License: MIT
Description: Django-fakery
        =============
        
        .. image:: https://travis-ci.org/fcurella/django-fakery.svg?branch=master
            :target: https://travis-ci.org/fcurella/django-fakery
        
        
        .. image:: https://coveralls.io/repos/fcurella/django-fakery/badge.svg?branch=master&service=github
          :target: https://coveralls.io/github/fcurella/django-fakery?branch=master
        
        An easy-to-use implementation of `Creation Methods`_ (aka Object Factory) for Django, backed by ``Faker``.
        
        .. _Creation Methods: http://xunitpatterns.com/Creation%20Method.html
        
        ``django_fakery`` will try to guess the field's value based on the field's name and type.
        
        Installation
        ------------
        
        Install with::
        
            $ pip install django-fakery
        
        QuickStart
        ----------
        
        .. code-block:: python
        
            from django_fakery import factory
        
            factory.make(
                'app.Model',
                fields={
                    'field': 'value',
                }
            )
        
        The value of a field can be any python object, a callable, or a lambda:
        
        .. code-block:: python
        
            from django_fakery import factory
            from django.utils import timezone
        
            factory.make(
                'app.Model',
                fields={
                    'created': timezone.now
                }
            )
        
        When using a lambda, it will receive two arguments: ``n`` is the iteration number, and ``f`` is an instance of ``faker``:
        
        .. code-block:: python
        
            user = factory.make(
                'auth.User',
                fields={
                    'username': lambda n, f: 'user_{}'.format(n),
                }
            )
        
        
        You can create multiple objects by using the ``quantity`` parameter:
        
        .. code-block:: python
        
            from django_fakery import factory
        
            factory.make('app.Model', quantity=4)
        
        For convenience, when the value of a field is a string, it will be interpolated with the iteration number:
        
        .. code-block:: python
        
            user = factory.make(
                'auth.User',
                fields={
                    'username': 'user_{}',
                },
                quantity=4
            )
        
        Foreign keys
        ------------
        
        Non-nullable ``ForeignKey`` s create related objects automatically.
        
        If you want to explicitly create a related object, you can pass it to the ``fields`` like any other value:
        
        .. code-block:: python
        
            pizza = factory.make(
                'food.Pizza',
                fields={
                    'chef': factory.make('auth.User', fields={'username': 'Gusteau'}),
                }
            )
        
        ManyToManies
        ------------
        
        Because ``ManyToManyField``s are implicitly nullable (ie: they're always allowed to have their ``.count()`` equal to ``0``), related objects on those fields are not automatically created for you.
        
        If you want to explicitly create a related objects, you can pass a list to the ``fields`` like any other value:
        
        .. code-block:: python
        
            pizza = factory.make(
                'food.Pizza',
                fields={
                    'toppings': [factory.make('food.Tooping', fields={'name': 'Anchovies'})],
                }
            )
        
        You can also pass a factory, to create multiple objects:
        
        .. code-block:: python
        
            pizza = factory.make(
                'food.Pizza',
                fields={
                    'toppings': factory.make('food.Tooping', quantity=5),
                }
            )
        
        Lazies
        ------
        
        You can refer to the created instance's own attributes or method by using `Lazy` objects.
        
        For example, if you'd like to create user with email as username, and have them always match, you could do:
        
        .. code-block:: python
        
            from django_fakery import factory, Lazy
        
            factory.make(
                'auth.User',
                fields={
                    'username': Lazy('email'),
                }
            )
        
        
        If you want to assign a value returned by a method on the instance, you can pass the method's arguments to the ``Lazy`` object:
        
        .. code-block:: python
        
            from django_fakery import factory, Lazy
        
            factory.make(
                'myapp.Model',
                fields={
                    'myfield': Lazy('model_method', 'argument', keyword='keyword value'),
                }
            )
        
        
        Pre-save and Post-save hooks
        ----------------------------
        
        You can define functions to be called right before the instance is saved or right after:
        
        .. code-block:: python
        
            from django_fakery import factory
        
            factory.make(
                'auth.User',
                fields={
                    'username': 'username',
                },
                pre_save=[
                    lambda i: i.set_password('password')
                ]
            )
        
        
        Since settings a user's password is such a common case, we special-cased that scenario, so you can just pass it as a field:
        
        .. code-block:: python
        
            from django_fakery import factory
        
            factory.make(
                'auth.User',
                fields={
                    'username': 'username',
                    'password': 'password',
                }
            )
        
        Non persistent instances
        ------------------------
        
        You can build instances that are not saved to the database by using the `.build()` method, just like you'd use `.make()`:
        
        .. code-block:: python
        
            from django_fakery import factory
        
            factory.build(
                'app.Model',
                fields={
                    'field': 'value',
                }
            )
        
        Note that since the instance is not saved to the database, `.build()` does not support ManyToManies or post-save hooks.
        
        Blueprints
        ----------
        
        Use a blueprint:
        
        .. code-block:: python
        
            from django_fakery import factory
        
            user = factory.blueprint('auth.User')
        
            user.make(quantity=10)
        
        Blueprints can refer other blueprints:
        
        .. code-block:: python
        
            pizza = factory.blueprint(
                'food.Pizza',
                fields={
                    'chef': user,
                }
            )
        
        Seeding the faker
        -----------------
        
        .. code-block:: python
        
            from django_fakery import factory
        
            factory.make('auth.User', fields={
                'username': 'regularuser_{}'
            }, seed=1234, quantity=4)
        
        
        Credits
        -------
        
        The API is heavily inspired by `model_mommy`_.
        
        .. _model_mommy: https://github.com/vandersonmota/model_mommy
        
        License
        -------
        
        This software is released under the MIT License.
        
Platform: any
Classifier: Development Status :: 4 - Beta
Classifier: Framework :: Django
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
