Django Dynamic Fixture

Common errors

• AttributeError: module 'ddf' has no attribute 'Fixture'

  cause Attempting to use the old `Fixture` class name after upgrading to ddf v4.0.0 or later.
  fix Change `Fixture` to `F`. Update import statements (`from ddf import Fixture` to `from ddf import F`) and usage (`Fixture(...)` to `F(...)`).

• TypeError: 'int' object is not callable

  cause This often occurs when passing an integer (or other literal) directly to a field that expects a callable or `ddf.F` when using certain DDF features, e.g., in a list comprehension or generator, or when using `ddf.F` incorrectly.
  fix Ensure you are using `ddf.F(lambda: some_value)` for dynamic values or `ddf.F(some_callable)` when you intend to pass a callable function for a field value that should be evaluated later, especially in list/generator contexts.

• NameError: name 'G' is not defined

  cause Forgetting to import the `G` function from the `ddf` module.
  fix Add `from ddf import G` at the top of your file.

• django.db.utils.IntegrityError: NOT NULL constraint failed: myapp_model.field_id

  cause Occurs when a non-nullable field or a unique field without a default value is not provided by `ddf.G` (or `ddf.G` generates a non-unique value for a unique field).
  fix Explicitly provide values for all non-nullable fields. For unique fields, ensure DDF can generate unique values (e.g., by using `Faker().unique.email()` or providing `F(lambda: unique_value_generator())`).

Warnings

• breaking The `Fixture` class was renamed to `F` in version 4.0.0. Code using `from ddf import Fixture` or `ddf.Fixture(...)` will break.
  Fix: Update imports from `from ddf import Fixture` to `from ddf import F` and replace all `Fixture(...)` calls with `F(...)`.
• breaking Version 4.0.0 dropped support for older Python and Django versions. Specifically, it requires Python >= 3.8 and Django >= 3.2.
  Fix: Ensure your project runs on Python 3.8+ and Django 3.2+ before upgrading to django-dynamic-fixture v4.x. If not possible, stick to django-dynamic-fixture v3.x.
• gotcha When using `ddf.G` for related fields (ForeignKey, ManyToManyField, OneToOneField), passing `F(...)` directly for the related object (e.g., `author=F(...)`) will not create the related object automatically. Instead, define nested attributes using double underscores (e.g., `author__name='...'`) or pass an existing object.
  Fix: To create a related object and link it, use the `related_field__attribute=value` syntax (e.g., `G(Book, author__name='New Author')`). To link to an existing object, pass the object directly (e.g., `G(Book, author=my_author_instance)`).

Install

• pip install django-dynamic-fixture Install latest version

Imports

• G

  from ddf import G

  The primary function to create and persist model instances.
• F

  from ddf import F

  Used to define dynamic or conditional values for fields, e.g., using callables or Faker.
• N

  from ddf import N

  Creates a non-persisted (unsaved) model instance.
• Fixture
  wrong:

  from ddf import Fixture

  correct:

  from ddf import F

  The `Fixture` class was renamed to `F` in v4.0.0. Using `Fixture` will raise an AttributeError in newer versions.

Quickstart

This quickstart demonstrates how to use `ddf.G` to create and persist model instances, `ddf.F` for dynamic field values (including using `Faker`), and `ddf.N` for non-persisted instances. It includes a minimal, self-contained Django setup to make the code runnable without a pre-existing Django project.

import os
from django.conf import settings
from django.apps import apps
from django.db import models
from ddf import G, F, N
from faker import Faker

# Minimal Django setup for the quickstart to be runnable without a full project
if not apps.ready:
    settings.configure(
        DEBUG=True,
        INSTALLED_APPS=[
            'django.contrib.auth',
            'django.contrib.contenttypes',
        ],
        DATABASES={
            'default': {
                'ENGINE': 'django.db.backends.sqlite3',
                'NAME': ':memory:',
            }
        },
        SECRET_KEY='not-a-secret',
        USE_TZ=True,
        # Define a dummy app_label for models in this ad-hoc setup
        MIGRATION_MODULES={'myapp': None} # Prevent migrations check
    )
    import django
    django.setup()

# Define dummy models for the quickstart within a custom app_label
class Author(models.Model):
    name = models.CharField(max_length=255)
    email = models.EmailField(unique=True)
    bio = models.TextField(blank=True)

    class Meta:
        app_label = 'myapp' # Required for models in minimal setup

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    pages = models.IntegerField(default=100)

    class Meta:
        app_label = 'myapp' # Required

    def __str__():
        return self.title


# --- Actual django-dynamic-fixture usage ---
fake = Faker()

print("--- Creating instances ---")

# 1. Create a single Author instance
author1 = G(Author, name=fake.name(), email=fake.email(), bio=fake.paragraph())
print(f"  Created Author: {author1.name} ({author1.email})")

# 2. Create a Book instance referencing an existing author
book1 = G(Book, author=author1, title=fake.sentence(nb_words=4))
print(f"  Created Book: '{book1.title}' by {book1.author.name}")

# 3. Create multiple Books with dynamic values using F()
# This will also create a new Author because 'author__name' is specified
books_dynamic = G(Book, n=2, author__name=F(fake.name), author__email=F(fake.email),
                 title=F(lambda: fake.sentence(nb_words=3)),
                 pages=F(lambda: fake.random_int(min=50, max=500)))
for book_obj in books_dynamic:
    print(f"  Created Dynamic Book: '{book_obj.title}' by {book_obj.author.name} ({book_obj.pages} pages)")

# 4. Create a non-persisted instance (not saved to database)
draft_book = N(Book, title="Draft Idea", author=author1, pages=20)
print(f"  Created Draft Book (not persisted): '{draft_book.title}' by {draft_book.author.name}")

# You can verify it's not saved (requires django.db.models import and Django setup)
# from django.db import connection
# with connection.cursor() as cursor:
#     cursor.execute("SELECT COUNT(*) FROM myapp_book")
#     print(f"Total books in DB: {cursor.fetchone()[0]}")