django-tasks-v1

Task dataset for a Django RL / eval environment, in the shape used by the Prime Intellect Environments Hub.

29 Django ORM tasks against a fixed three-model schema. Each task gives the model the schema and a fixture and asks for a query; the answer is a list of rows, compared to a reference. Grading is deterministic — no LLM judge, no external API, no network.

This is a deliberate change of domain from the numeric siblings (pandas, numpy/scipy, PyTorch, JAX): an agent that can do tensor algebra may still be unable to write a correct ORM query, and ORM mistakes — a missing distinct() after a join, an aggregate that fans out, a filter applied on the wrong side of a relation — are their own skill.

Category	Tasks	Covers
filtering	9	__gte/__lt/__in/__range/__contains, booleans, Q objects, exclude, multi-condition filters
aggregation	8	count, Count/Sum/Max/Avg annotations, HAVING-style filters on annotations, distinct counts
relations	6	forward and reverse FK traversal, filtering across two relations, distinct() after a join
expressions	6	F expressions, ordering by a related field, slicing (top-N), aggregate

The schema

class Publisher(models.Model):
    name = CharField(max_length=64); country = CharField(max_length=2)

class Author(models.Model):
    name = CharField(max_length=64); birth_year = IntegerField()

class Book(models.Model):
    title = CharField(max_length=128)
    author = ForeignKey(Author, related_name="books")
    publisher = ForeignKey(Publisher, related_name="books")
    year = IntegerField(); price = DecimalField(6, 2); pages = IntegerField()
    in_stock = BooleanField(default=True)

4 publishers, 5 authors, 12 books — all hard-coded, carried in every row's fixture field.

Fields

Field	Description
task_id	stable id, e.g. django-017
category	one of the four above
prompt	the natural-language instruction
schema	the model definitions, verbatim
fixture	the full seed data as JSON, so the task is self-contained
expected_output	{"rows": [[...], ...]} — the reference result

Why ORM work is gradeable at all

Three design decisions do the work:

• One in-memory SQLite database from a hard-coded fixture. No network, no migrations on disk, no clock or randomness anywhere in the data.
• Every reference returns a list of tuples of primitives, never a QuerySet — so the answer is compared by value, not by object identity or lazy evaluation.
• Every task orders explicitly. SQLite promises nothing about row order without an ORDER BY, and grading a model on an unspecified order would be grading it on luck.

Verification

Every task is independently checked: it runs, is deterministic across two freshly rebuilt databases, returns a non-empty list of JSON-safe primitives, is not the trivial "return every row" answer, and survives the serialisation round-trip exactly. All 29 pass on Django 6.0.8.

The verifier earned its keep here too: it caught a task asking for "every year with at least 2 books", which returned nothing — every book in the fixture has a distinct year. It was replaced with the same GROUP BY … HAVING shape over the publisher's country, which has real duplicates and exercises a join.

Builder and verifier: build_tasks.py.