README.md

---
license: cc-by-4.0
pretty_name: Python Execution Prediction Training Pool
language:
- code
task_categories:
- text-generation
size_categories:
- 10K<n<100K
---

# Python execution prediction training pool

Short Python functions, a concrete call of each one, and the value that call really returns, from
five public sources read at the pinned revisions named below and laid out twice. Train on either
layer or on both.

## `pool.jsonl`

Every source rewritten into one shape, 38154 rows, one JSON object per line, with these fields.

| Field | What it holds |
|---|---|
| `id` | a row identifier unique within this file |
| `code` | the Python source that defines the function |
| `entry_point` | the name of the function the call names |
| `input` | the argument text, so the call is `entry_point(input)` |
| `output` | the `repr` of the value that call returns |
| `source` | the name of the source directory the row came from |
| `source_repo`, `source_revision` | the dataset and the revision it was read at |
| `source_file`, `source_id` | the file and the row's own name in that set: its id or task and position for PyX, the execution trace set and MBPP, the function's URL for CodeSearchNet, and repository, path and identifier for The Vault |
| `provenance_class` | how the row came to exist |
| `licence` | the licence the row is under: the source's term, or for The Vault the repository's own licence as the source publishes it |

Every output here was computed by running the function, not copied from its source. Each candidate
was run twice in a separate process under a two second deadline, and a row survives only when both
runs return the same value, the value's `repr` parses back to an equal value, and that text is at
most 200 characters. Rows whose function returns `None` were dropped. Rows are deduplicated across
sources on the function text together with its entry point and its input, keeping the first source
in the order of the sections below.

## `sources/`

The same data untouched, 604602 rows, one directory per source, holding the files at the paths, in
the formats and with the columns its own repository publishes. Nothing here was renamed, reshaped,
reordered or deduplicated, and no output here was computed by this builder. Use this layer if you
want a field the rewritten one drops, such as the written reasoning in the first source or the
documentation strings in the two code corpora, or if you would rather choose the calls yourself.

## The sources

### `sources/pyx`

Python functions written by a language model from short problem statements, each paired with a
concrete call of the function. Two of every three rows carry no call this builder can read and
contribute to the raw layer only.

From `semcoder/PyX` at revision `7f328668db983ff1d52deec102f65c4ca117e094`, files `pyx.jsonl`. 93158
rows here, and 30571 rows of `pool.jsonl` were built from them. Provenance class `model-generated`,
licence `mit`.

Worth knowing. The functions and the calls were produced by a model, so a function may be odd or
wrong in the way a model is wrong. That does not matter for this shape of data: the output recorded
here is what the function really returns, whatever the function meant to do, which is also true of
the graded material.

### `sources/execution_trace`

Self-contained Python programs written by people for this purpose, each with a call and the output
it produces, chosen to exercise control flow, collections, exceptions and standard library
behaviour.

From `databounty-io/python-execution-trace-output-prediction-cmskdimp` at revision
`88c74bd6525825f46bec4d68b2a9ed7f11fa0cf9`, files `data/items.jsonl`, `manifest.json`. 996 rows
here, and 935 rows of `pool.jsonl` were built from them. Provenance class `human`, licence `cc-
by-4.0`.

Worth knowing. One thousand rows, the smallest source here and the one closest in intent to what the
rows are for. Its own card names the twenty six people who wrote it.

### `sources/mbpp`

Short Python programming problems written by crowdworkers, each with a reference solution and three
assertions. Every assertion of the form call equals value is one row here, so one problem
contributes up to three.

From `google-research-datasets/mbpp` at revision `4bb6404fdc6cacfda99d4ac4205087b89d32030c`, files
`full/train-00000-of-00001.parquet`, `full/validation-00000-of-00001.parquet`,
`full/prompt-00000-of-00001.parquet`. 474 rows here, and 1391 rows of `pool.jsonl` were built from
them. Provenance class `human`, licence `cc-by-4.0`.

Worth knowing. The train, validation and prompt splits only. The test split is left out, since it is
the held-out half of its own release and is widely used as one.

### `sources/code_search_net`

Python functions with documentation, collected from open source repositories on GitHub. The calls
are not published with them and are drawn here.

From `code-search-net/code_search_net` at revision `bd0cf261e357a3eb5c8fba490d23ec1a1cd59555`, files
`python/train-00000-of-00001.parquet`, `python/validation-00000-of-00001.parquet`,
`python/test-00000-of-00001.parquet`. 457339 rows here, and 4685 rows of `pool.jsonl` were built
from them. Provenance class `collected`, licence `unknown`.

Worth knowing. The licence tag on the repository is literally other. Its collectors kept only
repositories whose licence permits redistributing parts of the project, but the corpus does not
record which licence each function came under, so every row here carries the licence unknown and
names its repository instead.

### `sources/the_vault`

Python functions with documentation, collected from permissively licensed repositories. The calls
are not published with them and are drawn here.

From `Fsoft-AIC/the-vault-function` at revision `505c679056e49a2a269b64777ee7c496d22e1440`, files
`data/validation/python-00000-of-00001.parquet`, `data/test/python-00000-of-00001.parquet`. 52635
rows here, and 572 rows of `pool.jsonl` were built from them. Provenance class `collected`, licence
`mit`.

Worth knowing. The validation and test splits only, which are two complete files. Its train
configurations run to fifteen gigabytes of Python and yield the same kind of row as the other corpus
here, so they would add size rather than variety.

## Provenance and licences

By provenance class the curated layer holds 5257 rows `collected`, 2326 rows `human`, 30571 rows
`model-generated`. `human` means a person wrote the function and the call, `collected` means the
function was taken from a public repository and the call was drawn here from a fixed catalogue of
values, and `model-generated` means a language model wrote both. Every output, in every class, was
computed by running the function.

The pool as a whole is offered under `cc-by-4.0`, which is the most restrictive term its sources
compose to. PyX is `mit`, the execution trace set and MBPP are `cc-by-4.0`, The Vault publishes the
licence of each function's repository with the row and every one of its rows here is under a
permissive term (`mit`, `apache-2.0`, the BSD family and a few others, none copyleft), and
CodeSearchNet carries the tag `other` with no per-row licence recorded, so its rows carry the
licence `unknown` and name their repository instead. Each row carries its own, so a subset under a
single licence can be selected.

## Filtering

Rows whose function duplicated or closely matched a function in a held-out set were removed before
publication, from both layers alike, by a check on the normalised function text (0 rows) followed by
a word-level 8-gram overlap check (576 rows). That held-out set is not distributed here. Nothing
else was filtered out of the raw layer.