datadoom 0.1.0.dev0__tar.gz → 0.1.1__tar.gz

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/.github/workflows/release.yml

@@ -111,6 +111,12 @@ jobs:
           name: dist
           path: dist
       - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          # PyPI versions are immutable: a re-run (or a tag pointing at an already
+          # published version) would otherwise fail with "File already exists".
+          # Skip files already on PyPI so re-runs are idempotent; publishing NEW
+          # content still requires bumping src/datadoom/version.py.
+          skip-existing: true
 
   docker:
     name: build + push image (GHCR)

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/.tmp_pdir.txt

@@ -1 +1 @@
-C:\Users\santh\AppData\Local\Temp\claude\tmp5pkupaok
+C:\Users\santh\AppData\Local\Temp\claude\tmp5pkupaok

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/CHANGELOG.md

@@ -4,7 +4,7 @@ All notable changes to DataDoom are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project follows
 [Semantic Versioning](https://semver.org/).
 
-## [Unreleased]
+## 0.1.1
 
 ### Added
 

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datadoom
-Version: 0.1.0.dev0
+Version: 0.1.1
 Summary: Local-first, open-source engine for controllable, reproducible synthetic data.
 Project-URL: Homepage, https://github.com/SanthoshReddy352/datadoom
 Project-URL: Repository, https://github.com/SanthoshReddy352/datadoom
@@ -80,12 +80,53 @@ difficulty, and failure modes — and regenerate it identically, forever, from a
 📖 **Docs:** <https://santhoshreddy352.github.io/datadoom/> · authoritative design in
 [`docs_v2/`](docs_v2/) (start at [`docs_v2/00_README_Index.md`](docs_v2/00_README_Index.md)).
 
+## Why DataDoom
+
+Synthetic data usually forces a trade-off: it's either **realistic but a black box**
+(you can't say what relationships or flaws it contains) or **controllable but
+throwaway** (you can't regenerate the exact same dataset tomorrow). That makes it hard
+to teach with, benchmark against, file a bug against, or share.
+
+**The goal:** make a dataset something you *design* and *version-control like source
+code*. You declare its structure — distributions, causal relationships, difficulty,
+and data-quality failures — in one spec file, and DataDoom regenerates it
+**byte-for-byte identically** from `(spec_hash, seed)`, while honestly reporting how
+well the realized data matches what you asked for. No network, no telemetry, no
+account: everything runs locally.
+
+**Good for:** ML teaching & reproducible benchmarks · testing data pipelines on known
+edge cases · sharing a dataset's *recipe* instead of PII · hackathon / challenge
+datasets with a known ground truth.
+
+## What it does
+
+- **Deterministic by construction** — one seeded RNG underpins everything; the same
+  spec + seed yields a bitwise-identical dataset on the pinned path.
+- **Honest statistics** — distributions are sampled correctly and their fit is
+  *reported* (KS / chi-square goodness-of-fit, compliance score); parameters are never
+  refit to flatter the sample.
+- **Causal structure** — a DAG of structural equations (linear/logistic/polynomial/…)
+  with per-node noise and `do()` interventions, plus a true-graph + mutual-information
+  report.
+- **Failure injection** — eight mechanisms (MCAR/MAR/MNAR, label & feature noise,
+  drift, covariate shift, leakage) corrupt a *copy* while the clean baseline is kept,
+  with realized-effect diffs.
+- **Difficulty targeting** — calibrate a binary label to a chosen baseline-model AUROC
+  band, reported with the achieved metric, knobs, and bisection trace.
+- **Rich feature types** — numeric/categorical/boolean/datetime, realistic seeded text
+  (names, emails, addresses), additive time-series, and latent (hidden) features.
+- **Extensible** — distributions, structural functions, failure modes, exporters, and
+  probes all ship as plugins against the engine ABCs, with zero core changes.
+- **Built to consume** — export CSV / JSON / Parquet, load a run straight into
+  pandas / PyTorch / TensorFlow / HuggingFace, and start from built-in domain templates
+  (including ready-made hackathon challenges).
+- **Two surfaces, one engine** — a CLI for automation and a web Canvas for design both
+  call the exact same pipeline, so results never diverge.
+
 ## Status
 
-**Phases 0–5 complete; 1.0 hardening underway.** The deterministic engine, server +
-web Canvas, causal engine, failure injection, difficulty targeting, the plugin system,
-exporters, templates, time-series, framework adapters, and the AI spec-authoring
-manifest all ship. Remaining for 1.0 is hardening (docs, release automation, the repro
+**Phases 0–5 complete; 1.0 hardening underway.** Everything in *What it does* above
+ships today. Remaining for 1.0 is hardening (docs site, release automation, the repro
 matrix); see [`status.md`](status.md). Optional team mode is a deferred future addon.
 
 ## Install
@@ -110,18 +151,73 @@ datadoom verify examples/causal-fraud.datadoom.yaml --seed 42 --against out/
 
 # start from a built-in domain template
 datadoom template use fraud-detection --out my.datadoom.yaml
+```
+
+## Web UI (Canvas)
+
+The web Canvas — design schemas, wire causal graphs, configure difficulty/failures,
+generate with a live tracker, preview/compare/export — ships **prebuilt inside the
+package** (no Node toolchain needed). There are two ways to run it.
+
+### Option A — pip + `datadoom serve`
+
+```bash
+pip install "datadoom[server]"   # the [server] extra adds FastAPI/uvicorn
+datadoom serve                   # serves the API + Canvas on http://127.0.0.1:8000
+```
+
+Then open <http://127.0.0.1:8000> in your browser. `datadoom serve` is what starts
+the UI — installing the package alone does not run a server.
+
+> **Hitting `The web server needs extra deps … pip install 'datadoom[server]'`
+> even after installing it?** You almost certainly have an older `datadoom` already
+> installed, so pip reports "already satisfied" and never pulls the `[server]`
+> dependencies. Force a clean reinstall:
+> ```bash
+> pip install --upgrade --force-reinstall --no-cache-dir "datadoom[server]"
+> ```
+
+### Option B — Docker (UI starts automatically)
+
+The image's entrypoint **is** `datadoom serve`, so the Canvas comes up as soon as
+the container runs — you do **not** run any extra command.
 
-# launch the web Canvas (needs the [server] extra)
-datadoom serve
+**Build and run from a clone (works today):**
+
+```bash
+docker build -t datadoom:local .
+docker run --rm -p 8000:8000 -v datadoom-data:/data datadoom:local
+```
+
+**Or pull the published image** (available after a tagged release pushes it to
+GHCR — see [`docs_v2/22`](docs_v2/22_Release_and_Publishing_Runbook.md) §3):
+
+```bash
+docker run --rm -p 8000:8000 -v datadoom-data:/data ghcr.io/santhoshreddy352/datadoom:latest
 ```
 
+> Each `docker run` is a **single line** on purpose — it works in PowerShell, CMD,
+> and bash alike. A `\` line-continuation is bash-only and breaks in PowerShell.
+
+Open <http://localhost:8000>. The `-v datadoom-data:/data` volume persists your
+datasets/runs across restarts; the server binds `0.0.0.0:8000` inside the container.
+
 ## Development
 
+Clone the repo (or **fork** it first on GitHub and clone your fork if you intend to
+open a pull request), then set up a project-local virtual environment:
+
 ```bash
+# clone (use your fork's URL if you forked)
+git clone https://github.com/SanthoshReddy352/datadoom.git
+cd datadoom
+
+# project-local venv (Python 3.11 matches CI's lowest supported version)
 python -m venv .venv
 .venv\Scripts\activate          # Windows
 # source .venv/bin/activate     # macOS/Linux
-pip install -e ".[dev]"
+
+pip install -e ".[dev]"         # editable install + dev tools
 
 ruff check src tests            # lint
 lint-imports                    # architecture boundaries
@@ -129,6 +225,9 @@ mypy                            # type-check
 pytest                          # test suite
 ```
 
+Contributions are welcome — please commit with DCO sign-off (`git commit -s`) and run
+the gates above before opening a PR. See [`CONTRIBUTING.md`](CONTRIBUTING.md).
+
 ## The reproducibility guarantee (scoped)
 
 Given the same spec and seed, on the **pinned path** (single-threaded BLAS, pinned

datadoom-0.1.1/README.md

@@ -0,0 +1,179 @@
+# DataDoom
+
+**Local-first, open-source engine for controllable, reproducible synthetic data.**
+
+[![CI](https://github.com/SanthoshReddy352/datadoom/actions/workflows/ci.yml/badge.svg)](https://github.com/SanthoshReddy352/datadoom/actions/workflows/ci.yml)
+[![Reproducibility Matrix](https://github.com/SanthoshReddy352/datadoom/actions/workflows/repro-matrix.yml/badge.svg)](https://github.com/SanthoshReddy352/datadoom/actions/workflows/repro-matrix.yml)
+[![Docs](https://github.com/SanthoshReddy352/datadoom/actions/workflows/docs.yml/badge.svg)](https://santhoshreddy352.github.io/datadoom/)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue.svg)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+
+Design the dataset the way you reason about it — distributions, causal relationships,
+difficulty, and failure modes — and regenerate it identically, forever, from a single spec file.
+
+> **North star:** a synthetic dataset should be as version-controllable, shareable, and
+> reproducible as source code.
+
+📖 **Docs:** <https://santhoshreddy352.github.io/datadoom/> · authoritative design in
+[`docs_v2/`](docs_v2/) (start at [`docs_v2/00_README_Index.md`](docs_v2/00_README_Index.md)).
+
+## Why DataDoom
+
+Synthetic data usually forces a trade-off: it's either **realistic but a black box**
+(you can't say what relationships or flaws it contains) or **controllable but
+throwaway** (you can't regenerate the exact same dataset tomorrow). That makes it hard
+to teach with, benchmark against, file a bug against, or share.
+
+**The goal:** make a dataset something you *design* and *version-control like source
+code*. You declare its structure — distributions, causal relationships, difficulty,
+and data-quality failures — in one spec file, and DataDoom regenerates it
+**byte-for-byte identically** from `(spec_hash, seed)`, while honestly reporting how
+well the realized data matches what you asked for. No network, no telemetry, no
+account: everything runs locally.
+
+**Good for:** ML teaching & reproducible benchmarks · testing data pipelines on known
+edge cases · sharing a dataset's *recipe* instead of PII · hackathon / challenge
+datasets with a known ground truth.
+
+## What it does
+
+- **Deterministic by construction** — one seeded RNG underpins everything; the same
+  spec + seed yields a bitwise-identical dataset on the pinned path.
+- **Honest statistics** — distributions are sampled correctly and their fit is
+  *reported* (KS / chi-square goodness-of-fit, compliance score); parameters are never
+  refit to flatter the sample.
+- **Causal structure** — a DAG of structural equations (linear/logistic/polynomial/…)
+  with per-node noise and `do()` interventions, plus a true-graph + mutual-information
+  report.
+- **Failure injection** — eight mechanisms (MCAR/MAR/MNAR, label & feature noise,
+  drift, covariate shift, leakage) corrupt a *copy* while the clean baseline is kept,
+  with realized-effect diffs.
+- **Difficulty targeting** — calibrate a binary label to a chosen baseline-model AUROC
+  band, reported with the achieved metric, knobs, and bisection trace.
+- **Rich feature types** — numeric/categorical/boolean/datetime, realistic seeded text
+  (names, emails, addresses), additive time-series, and latent (hidden) features.
+- **Extensible** — distributions, structural functions, failure modes, exporters, and
+  probes all ship as plugins against the engine ABCs, with zero core changes.
+- **Built to consume** — export CSV / JSON / Parquet, load a run straight into
+  pandas / PyTorch / TensorFlow / HuggingFace, and start from built-in domain templates
+  (including ready-made hackathon challenges).
+- **Two surfaces, one engine** — a CLI for automation and a web Canvas for design both
+  call the exact same pipeline, so results never diverge.
+
+## Status
+
+**Phases 0–5 complete; 1.0 hardening underway.** Everything in *What it does* above
+ships today. Remaining for 1.0 is hardening (docs site, release automation, the repro
+matrix); see [`status.md`](status.md). Optional team mode is a deferred future addon.
+
+## Install
+
+```bash
+pip install datadoom              # engine + CLI
+pip install "datadoom[server]"    # + web Canvas (datadoom serve)
+pip install "datadoom[parquet]"   # + Parquet export
+```
+
+## Quickstart
+
+```bash
+# generate a dataset from a spec
+datadoom run examples/causal-fraud.datadoom.yaml --seed 42 --out out/
+
+# validate a spec
+datadoom validate examples/causal-fraud.datadoom.yaml
+
+# verify a run reproduces bitwise from spec + seed
+datadoom verify examples/causal-fraud.datadoom.yaml --seed 42 --against out/
+
+# start from a built-in domain template
+datadoom template use fraud-detection --out my.datadoom.yaml
+```
+
+## Web UI (Canvas)
+
+The web Canvas — design schemas, wire causal graphs, configure difficulty/failures,
+generate with a live tracker, preview/compare/export — ships **prebuilt inside the
+package** (no Node toolchain needed). There are two ways to run it.
+
+### Option A — pip + `datadoom serve`
+
+```bash
+pip install "datadoom[server]"   # the [server] extra adds FastAPI/uvicorn
+datadoom serve                   # serves the API + Canvas on http://127.0.0.1:8000
+```
+
+Then open <http://127.0.0.1:8000> in your browser. `datadoom serve` is what starts
+the UI — installing the package alone does not run a server.
+
+> **Hitting `The web server needs extra deps … pip install 'datadoom[server]'`
+> even after installing it?** You almost certainly have an older `datadoom` already
+> installed, so pip reports "already satisfied" and never pulls the `[server]`
+> dependencies. Force a clean reinstall:
+> ```bash
+> pip install --upgrade --force-reinstall --no-cache-dir "datadoom[server]"
+> ```
+
+### Option B — Docker (UI starts automatically)
+
+The image's entrypoint **is** `datadoom serve`, so the Canvas comes up as soon as
+the container runs — you do **not** run any extra command.
+
+**Build and run from a clone (works today):**
+
+```bash
+docker build -t datadoom:local .
+docker run --rm -p 8000:8000 -v datadoom-data:/data datadoom:local
+```
+
+**Or pull the published image** (available after a tagged release pushes it to
+GHCR — see [`docs_v2/22`](docs_v2/22_Release_and_Publishing_Runbook.md) §3):
+
+```bash
+docker run --rm -p 8000:8000 -v datadoom-data:/data ghcr.io/santhoshreddy352/datadoom:latest
+```
+
+> Each `docker run` is a **single line** on purpose — it works in PowerShell, CMD,
+> and bash alike. A `\` line-continuation is bash-only and breaks in PowerShell.
+
+Open <http://localhost:8000>. The `-v datadoom-data:/data` volume persists your
+datasets/runs across restarts; the server binds `0.0.0.0:8000` inside the container.
+
+## Development
+
+Clone the repo (or **fork** it first on GitHub and clone your fork if you intend to
+open a pull request), then set up a project-local virtual environment:
+
+```bash
+# clone (use your fork's URL if you forked)
+git clone https://github.com/SanthoshReddy352/datadoom.git
+cd datadoom
+
+# project-local venv (Python 3.11 matches CI's lowest supported version)
+python -m venv .venv
+.venv\Scripts\activate          # Windows
+# source .venv/bin/activate     # macOS/Linux
+
+pip install -e ".[dev]"         # editable install + dev tools
+
+ruff check src tests            # lint
+lint-imports                    # architecture boundaries
+mypy                            # type-check
+pytest                          # test suite
+```
+
+Contributions are welcome — please commit with DCO sign-off (`git commit -s`) and run
+the gates above before opening a PR. See [`CONTRIBUTING.md`](CONTRIBUTING.md).
+
+## The reproducibility guarantee (scoped)
+
+Given the same spec and seed, on the **pinned path** (single-threaded BLAS, pinned
+library versions, CPU, same OS/arch), DataDoom produces a **bitwise-identical** dataset.
+Across different OS/architectures we guarantee **statistical** — not bitwise —
+equivalence (FP reductions differ). The cross-OS × cross-Python reproducibility matrix
+enforces this in CI. See
+[`docs_v2/13_Testing_and_Reproducibility_Strategy.md`](docs_v2/13_Testing_and_Reproducibility_Strategy.md).
+
+## License
+
+[Apache-2.0](LICENSE).

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/docs_v2/00_README_Index.md

@@ -46,6 +46,7 @@ This `docs_v2/` set is the **authoritative design** for DataDoom. It supersedes
 | 20 | **YAML_Authoring_Guide** | Beginner-friendly, end-to-end guide to writing a spec by hand | `20_YAML_Authoring_Guide.md` |
 | 21 | **LLM_Spec_Authoring_Reference** | Terse authoring contract optimized for AI/agent spec generation | `21_LLM_Spec_Authoring_Reference.md` |
 | 22 | **Release_and_Publishing_Runbook** | Operator steps to publish docs/PyPI/Docker/releases (Pages, OIDC, provenance) | `22_Release_and_Publishing_Runbook.md` |
+| 23 | **Pushing_Changes_DCO_and_Versioning** | How to push to GitHub, sign off commits (DCO), bump versions, cut a release | `23_Pushing_Changes_DCO_and_Versioning.md` |
 
 ### Legacy docs intentionally **dropped** (SaaS/microservices-only, not part of DataDoom v2 core)
 `Advanced_System_Documents.md`, `Kafka_Event_Contract.md`, `Portobuff_Definitions.md`, `Mulit_Tenant_Isolation.md`, `SLA_SLO_RateLimiting.md`, `Infrastructure_Summary.md` — their still-relevant fragments are folded into 03, 06, 07, 14, 15. Kafka, gRPC/Protobuf, multi-tenant RLS, SLA tiers, and dedicated infra are **out of the core** (may return later as optional editions/plugins).

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/docs_v2/22_Release_and_Publishing_Runbook.md

@@ -85,6 +85,20 @@ is tag-triggered: publishing is **tokenless** via PyPI Trusted Publishing (OIDC)
    build **provenance** (see §4), creates the GitHub Release, and publishes to
    PyPI via OIDC. No token needed.
 
+> **PyPI versions are immutable.** Every release must use a **new** version in
+> `src/datadoom/version.py` — you cannot re-upload an existing one. The publish
+> step sets `skip-existing: true`, so a *re-run* of an already-published version
+> succeeds as a no-op (instead of the `400 File already exists` error) — but to
+> ship new content you must bump the version. `pip install datadoom` ignores
+> `.devN` pre-releases unless they are the only versions available, so cut a
+> non-dev version (e.g. `0.1.0`) for the first public release.
+
+> **User reports `datadoom serve` says it needs `[server]` even after installing
+> it?** That's a *stale local install*, not a packaging bug — pip sees the version
+> "already satisfied" and skips the extra's deps. Tell them:
+> `pip install --upgrade --force-reinstall --no-cache-dir "datadoom[server]"`.
+> (The published wheel does carry the `server` extra and the bundled web Canvas.)
+
 **Manual fallback (if not yet automated):**
 
 ```bash
@@ -144,9 +158,9 @@ There is intentionally **no private key checked into or required by the repo**.
 
 ---
 
-## 5. Reproducibility & CI badges 🟡 pending (Task 19 — deliverable C)
+## 5. Reproducibility & CI badges 🟢 ready
 
-The README badges (CI status, reproducibility matrix) point at the existing
+The README badges (CI, Reproducibility Matrix, Docs) point at the existing
 workflows and need no setup beyond the workflows running at least once on `main`.
 The repro matrix pins numpy in its CI cells so the golden-checksum gate actually
 asserts (rather than skips); see

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/frontend/src/components/GenerationsPanel.tsx

@@ -151,7 +151,7 @@ export function GenerationsPanel({
                   </Button>
                 </a>
               )}
-              <Menu trigger={({ toggle }) => <IconButton onClick={toggle}><MoreHorizontal size={16} /></IconButton>}>
+              <Menu trigger={({ toggle }) => <IconButton onClick={toggle} aria-label="More actions"><MoreHorizontal size={16} /></IconButton>}>
                 {(close) => (
                   <>
                     <MenuItem icon={<Pencil size={14} />} onClick={() => { close(); setRenaming(r); }}>

datadoom-0.1.1/frontend/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/App.tsx","./src/main.tsx","./src/components/CausalGraphEditor.tsx","./src/components/CausalGraphView.tsx","./src/components/CausalInspector.tsx","./src/components/ColumnGuideView.tsx","./src/components/ComparisonView.tsx","./src/components/ConfirmHost.tsx","./src/components/DifficultyConfigurator.tsx","./src/components/DifficultyView.tsx","./src/components/ErrorBoundary.tsx","./src/components/ExportModal.tsx","./src/components/FailureBadges.tsx","./src/components/FailureConfigurator.tsx","./src/components/FailureInspector.tsx","./src/components/GenerationsPanel.tsx","./src/components/Histogram.tsx","./src/components/Inspector.tsx","./src/components/Layout.tsx","./src/components/Modal.tsx","./src/components/OverviewView.tsx","./src/components/SpecDrawer.tsx","./src/components/StageStepper.tsx","./src/components/TableCanvas.tsx","./src/components/Toaster.tsx","./src/components/ui.tsx","./src/lib/api.ts","./src/lib/audit.ts","./src/lib/causal.ts","./src/lib/clsx.ts","./src/lib/difficulty.ts","./src/lib/failures.ts","./src/lib/runSocket.ts","./src/lib/sampling.ts","./src/lib/schemaForm.tsx","./src/lib/specDefaults.ts","./src/lib/summary.ts","./src/lib/types.ts","./src/lib/useHistory.ts","./src/lib/viewLayout.ts","./src/pages/Canvas.tsx","./src/pages/Dashboard.tsx","./src/pages/Placeholder.tsx","./src/pages/Plugins.tsx","./src/pages/Results.tsx","./src/pages/Templates.tsx","./src/pages/Tracker.tsx","./src/store/chrome.ts","./src/store/confirm.ts","./src/store/toast.ts","./src/store/ui.ts"],"version":"5.9.3"}

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/src/datadoom/cli/main.py

@@ -102,8 +102,16 @@ def serve(
     bind_port = port or cfg.port
     cfg.ensure_dirs()
 
+    # 0.0.0.0 / :: are bind-all addresses, not browsable URLs — show a link the
+    # user can actually click (e.g. inside Docker, where we bind 0.0.0.0).
+    browse_host = "localhost" if bind_host in ("0.0.0.0", "::", "[::]") else bind_host
     typer.secho(
-        f"DataDoom serving on http://{bind_host}:{bind_port}  (data: {cfg.home})",
+        f"DataDoom — open the web Canvas at http://{browse_host}:{bind_port}",
+        fg=typer.colors.GREEN,
+        bold=True,
+    )
+    typer.secho(
+        f"  (bound to {bind_host}:{bind_port} · data: {cfg.home} · Ctrl+C to stop)",
         fg=typer.colors.GREEN,
     )
     if reload:

{datadoom-0.1.0.dev0 → datadoom-0.1.1}/src/datadoom/version.py

@@ -1,3 +1,3 @@
 """Single source of truth for the package version (read by hatchling)."""
 
-__version__ = "0.1.0.dev0"
+__version__ = "0.1.1"