Django test data, FK-consistent, straight from your models.py.

From Django schema to populated database

Paste your models.py in the web app, push your whole project with the VS Code or PyCharm plugin, or use the CLI. The parser resolves Django's inheritance chain transitively: abstract bases merge their fields into every child, mixin-only models are detected, and the implicit auto id primary key is added so foreign keys have something to point at.

class Beehive(TimestampMixin, SoftDeleteMixin):
    name = models.CharField(max_length=120)
    owner = models.ForeignKey(User, on_delete=models.CASCADE)

# → INSERT INTO "user" ... 200 rows
# → INSERT INTO "beehive" ... owner_id resolves (declared FK),
#   2-19 hives per owner, long-tail distributed

What you get

Generate Django test data from models.py or a live database

Point SeedBase at your schema once, then generate from the Python SDK or the CLI. The SDK reads the project you imported (parsed from models.py or introspected from a live Postgres or MySQL database), produces FK-consistent rows, and hands you back SQL, CSV or JSON, or pushes straight into a connection.

# pip install seedbase
from seedbase import SeedbaseClient

client = SeedbaseClient(token="dr_sk_...")

# project_id was created when you imported models.py (or a live DB URL)
gen = client.generate(project_id, seed=42, wait=True)

# SQL with INSERTs in topological FK order, loads into a constrained schema as-is
sql = client.download(gen["id"], fmt="sql")
open("seed.sql", "w").write(sql)

Prefer the terminal? The CLI pulls schema and data straight into your local database, no SQL file to shuffle around.

# schema + data into the database from .seedbase.json
seedbase login
seedbase init
seedbase pull all --drop

Exact flags and the full command reference live in the docs.

pytest fixture with a reproducible seed

The Python package ships a pytest plugin. A fixed seed means the same rows on every run, so a failing test reproduces locally with the identical dataset and snapshot assertions stay stable. This is dependency injection of test data, not per-model factories you write and maintain by hand.

# conftest.py, or rely on the bundled fixture
import pytest
from seedbase import SeedbaseClient

@pytest.fixture(scope="session")
def seeded_data():
    client = SeedbaseClient(token="dr_sk_...")
    gen = client.generate(project_id, seed=42, wait=True)
    return client.download(gen["id"], fmt="json")

def test_owner_has_hives(seeded_data):
    # same seed, same rows, every CI run
    assert seeded_data["beehive"]
    assert all(h["owner_id"] for h in seeded_data["beehive"])

A pinned reference_date makes timestamps reproducible too, so "last 30 days" queries return the same window across runs instead of drifting as the calendar moves. factory_boy and Faker remain a good fit for building single objects inside a test, SeedBase fills a whole referentially intact database around them.

Foreign-key consistency across many tables

A real Django project is not three tables. Abstract bases, mixins, swappable user models and chains of ForeignKey and OneToOneField stack up fast. SeedBase walks the whole dependency graph, generates parents before children, and emits inserts in topological order so nothing references a row that does not exist yet. Self-references build trees rather than dangling pointers.

# orders depend on customers, customers on regions ...
# SeedBase orders the writes so every *_id resolves
INSERT INTO "region"   ...   # 20 rows
INSERT INTO "customer" ...   # 200 rows, region_id resolves
INSERT INTO "order"    ...   # 1,800 rows, customer_id resolves, 0-30 per customer
INSERT INTO "orderitem" ...  # order_id + product_id both resolve

This was tested against a real 20-app Django project with 226 models, abstract bases and self-referencing foreign keys included, so the parser is not a toy that handles only flat schemas. The same FK-safe ordering applies whether you export raw SQL for PostgreSQL and MySQL or generate for a Prisma schema. Masking production data instead of synthesizing it? See GDPR-compliant anonymization.