tdcv2 0.1.2__tar.gz

tdcv2-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nick Liapin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tdcv2-0.1.2/PKG-INFO

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: tdcv2
+Version: 0.1.2
+Summary: Deterministic test-data generator: coherent records, exact proportions, and any text format you describe. Same seed, same bytes — in Python, TypeScript, Java, C# and Rust alike.
+Author: Nick Liapin
+License: MIT
+Project-URL: Homepage, https://nickliapin.github.io/tdcv2/
+Project-URL: Documentation, https://nickliapin.github.io/tdcv2/docs/bindings/python
+Project-URL: Repository, https://github.com/NickLiapin/tdcv2
+Project-URL: Changelog, https://github.com/NickLiapin/tdcv2/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/NickLiapin/tdcv2/issues
+Keywords: test-data,test-data-generator,mock-data,fake-data,fake-data-generator,synthetic-data,synthetic-data-generator,dummy-data,sample-data,data-generator,data-generation,deterministic,seeded,reproducible,coherent-data,fixtures,testing,csv,json,sql,parquet,cli,dsl,locale,i18n
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Testing :: Mocking
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: antlr4-python3-runtime==4.13.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# TDC — The Data Constructor
+
+Test data that is coherent **inside each record**. In one row, the name matches the
+gender, the city sits in the right country, the diagnosis fits the patient. Run it
+again with the same seed and you get the same rows, byte for byte.
+
+An ordinary fake-data library draws every field on its own, so a row is a bag of
+individually plausible values that contradict each other. TDC draws a field from what
+the previous field chose.
+
+```bash
+pip install tdcv2
+```
+
+## A first config
+
+A config says what the records are; a block says how they should look on the page.
+
+```xml title="people.tdc"
+<tdc>
+    <env count="10" seed="demo" local="en">
+        <sequence name="Gender">
+            <gen type="text" value="Male,Female" percent="60,40"/>
+        </sequence>
+
+        <sequence name="MaleName" parent="Gender.Male">
+            <gen type="template" value="person.male.firstName"/>
+        </sequence>
+        <sequence name="FemaleName" parent="Gender.Female">
+            <gen type="template" value="person.female.firstName"/>
+        </sequence>
+
+        <sequence name="Age"><gen type="number" value="18..65"/></sequence>
+    </env>
+
+    <block>
+        <line><data>${{_count}}. ${{Gender}} — ${{MaleName}}${{FemaleName}}, age ${{Age}}</data></line>
+    </block>
+</tdc>
+```
+
+```bash
+tdcv2 people.tdc
+```
+
+```
+1. Male — Robert, age 59
+2. Female — Mary, age 18
+3. Male — James, age 53
+...
+```
+
+Exactly six men and four women — `percent="60,40"` is apportioned across whole rows by
+the Hamilton method, not approximated by independent coin flips. Every name matches its
+gender, because a female row cannot reach the male list at all. Change the `<block>` and
+the same records come out as CSV, JSON, SQL, YAML or a format you spell out yourself.
+
+## From Python
+
+```python
+from tdcv2 import TDC
+
+data = TDC("people.tdc")
+print(data)                        # the whole run as text
+
+for row in data:
+    print(row["Gender"], row["Age"])
+
+data.write_file("people.parquet")  # the extension picks the format
+```
+
+The constructor also takes `config_string=` instead of a path, and `count=`, `seed=`,
+`locale=`, `now=` and `engine=` override whatever `<env>` declared. `now=` is the one
+worth remembering in a test: a config with a date generator reads the clock, so pinning
+it is what keeps such a test stable for longer than a day.
+
+### Large runs
+
+```python
+data.write_file("people.csv", workers="auto")   # one process per core, bar one
+```
+
+A row is a function of its own index — that is what the streaming engine is built
+around — so a run splits across processes with nothing to coordinate. The output is byte
+for byte what one process writes; on one machine a gigabyte went from 11m37s to 87s
+across eleven processes.
+
+You do not need `if __name__ == "__main__":` around the call. Workers are launched as a
+named module rather than through `multiprocessing`, so nothing of yours is re-imported
+and re-executed.
+
+Splitting is skipped, silently and safely, wherever it would not be sound: the in-memory
+and exact engines, a config passed as a string rather than a file, Parquet output, and
+runs short enough that starting processes costs more than the rows do.
+
+## The command line
+
+`pip install tdcv2` puts `tdcv2` on the PATH — the same commands as the TypeScript, Java,
+C# and Rust CLIs, flag for flag. A Python user should not have to install Node to run a
+`.tdc` file.
+
+```bash
+tdcv2 people.tdc -o people.csv --count 100000 --jobs 8
+```
+
+|                                              |                                                                                      |
+| -------------------------------------------- | ------------------------------------------------------------------------------------ |
+| `tdcv2 <file.tdc>`                           | Generate. `-o`, `--seed`, `--count`, `--locale`, `--data-path`, `--engine`, `--jobs` |
+| `tdcv2 init`                                 | Write a `tdcv2.config.json` — asks at a terminal, takes `--yes` in a script          |
+| `tdcv2 pack list \| add <id> \| remove <id>` | Data packs, from the shared registry                                                 |
+| `tdcv2 check <file.tdc>`                     | Validate and say nothing when it is fine — for a pre-commit hook                     |
+| `tdcv2 format [-w] <file.tdc>`               | Pretty-print a config; `-w` rewrites it in place                                     |
+
+`--jobs` is the process split described above, and changes nothing but the wall clock.
+
+## Data packs
+
+A pack is the _data_ — the name lists, cities, streets and locale rules that
+`type="template"` draws from. The wheel carries a starter set: `common`, `en` and the USA
+country pack, which is what the example above uses. Ten languages and more than ninety
+country packs — with the right check-digit rule for each national ID format — are
+downloaded on demand:
+
+```bash
+tdcv2 init                 # write a tdcv2.config.json, once per project
+tdcv2 pack list            # what the registry has
+tdcv2 pack add ru france   # download and wire up
+```
+
+Or from code:
+
+```python
+from tdcv2.packs import DataPacks
+
+DataPacks.install(None, "ru", "france")   # downloads, verifies, registers in tdcv2.config.json
+```
+
+One registry, one `tdcv2.config.json`, one store, shared by all five implementations: a
+pack installed from here is a pack the others find. `--registry` accepts an `http`,
+`https` or `file` address, so an offline mirror or a folder on a share works the same way
+as the public one.
+
+## One config, five implementations
+
+TDC exists in TypeScript, Python, Java, C# and Rust. The same config and seed produce the
+same bytes in all five — that is the contract, and a shared fixture suite under
+`fixtures/cross-language/` checks it on every change: the shared cases through the router
+and on all three engines, the diagnostic cases by code and position, the PRNG and
+apportionment vectors, and the Parquet files byte for byte.
+
+It is why this package reimplements what a dependency would otherwise have provided. The
+only runtime dependency is `antlr4-python3-runtime`, and only because the grammar is
+shared with the other implementations and the parse tree has to be the same tree. The
+PRNG, the Snappy encoder, the Parquet writer and the date arithmetic are written here, so
+no library's choice of rounding or compression can change the bytes.
+
+| Module         | What it owns                                                                      |
+| -------------- | --------------------------------------------------------------------------------- |
+| `prng`         | The seekable generator, and the format-preserving permutation                     |
+| `distribution` | Hamilton apportionment and the `percent=` mask                                    |
+| `generators`   | number, regex, advanced_regex, symbol, counter, file, http, repeat, imperfections |
+| `date`         | A UTC calendar written out, eleven locale tables, the Moment-style formatter      |
+| `stats`        | Named distributions, the special functions behind gamma and beta, time series     |
+| `pattern`      | A drawn curve as a signal or a distribution; SVG and PNG readers                  |
+| `format`       | The positional mask, the interpolation filters, `${{Name\|filter}}`               |
+| `compute`      | The check-digit language, and the `if=` expression language                       |
+| `packs`        | Pack loading, the project cascade, the shared registry client                     |
+| `engine`       | The three engines and the router that picks between them                          |
+| `validator`    | Every `TDC###` code, each at the position an editor would underline               |
+| `output`       | Declared column types and the Parquet writer                                      |
+
+## Working on the repository
+
+The parser is generated from the shared grammar and the generator runs on Node. A
+released package ships it already generated; a checkout does not.
+
+```bash
+node scripts/generate-parsers.mjs --only python
+cd python
+python3 -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/pytest                  # 970 tests
+.venv/bin/ruff check src tests
+```
+
+`node scripts/five-ways.mjs --only python` does the same and regenerates the parser
+first, which is what CI runs.
+
+## Links
+
+- [Documentation](https://nickliapin.github.io/tdcv2/) — the DSL reference, guides and generators
+- [The Python binding](https://nickliapin.github.io/tdcv2/docs/bindings/python)
+- [Source](https://github.com/NickLiapin/tdcv2)
+
+## License
+
+MIT

tdcv2-0.1.2/README.md

@@ -0,0 +1,196 @@
+# TDC — The Data Constructor
+
+Test data that is coherent **inside each record**. In one row, the name matches the
+gender, the city sits in the right country, the diagnosis fits the patient. Run it
+again with the same seed and you get the same rows, byte for byte.
+
+An ordinary fake-data library draws every field on its own, so a row is a bag of
+individually plausible values that contradict each other. TDC draws a field from what
+the previous field chose.
+
+```bash
+pip install tdcv2
+```
+
+## A first config
+
+A config says what the records are; a block says how they should look on the page.
+
+```xml title="people.tdc"
+<tdc>
+    <env count="10" seed="demo" local="en">
+        <sequence name="Gender">
+            <gen type="text" value="Male,Female" percent="60,40"/>
+        </sequence>
+
+        <sequence name="MaleName" parent="Gender.Male">
+            <gen type="template" value="person.male.firstName"/>
+        </sequence>
+        <sequence name="FemaleName" parent="Gender.Female">
+            <gen type="template" value="person.female.firstName"/>
+        </sequence>
+
+        <sequence name="Age"><gen type="number" value="18..65"/></sequence>
+    </env>
+
+    <block>
+        <line><data>${{_count}}. ${{Gender}} — ${{MaleName}}${{FemaleName}}, age ${{Age}}</data></line>
+    </block>
+</tdc>
+```
+
+```bash
+tdcv2 people.tdc
+```
+
+```
+1. Male — Robert, age 59
+2. Female — Mary, age 18
+3. Male — James, age 53
+...
+```
+
+Exactly six men and four women — `percent="60,40"` is apportioned across whole rows by
+the Hamilton method, not approximated by independent coin flips. Every name matches its
+gender, because a female row cannot reach the male list at all. Change the `<block>` and
+the same records come out as CSV, JSON, SQL, YAML or a format you spell out yourself.
+
+## From Python
+
+```python
+from tdcv2 import TDC
+
+data = TDC("people.tdc")
+print(data)                        # the whole run as text
+
+for row in data:
+    print(row["Gender"], row["Age"])
+
+data.write_file("people.parquet")  # the extension picks the format
+```
+
+The constructor also takes `config_string=` instead of a path, and `count=`, `seed=`,
+`locale=`, `now=` and `engine=` override whatever `<env>` declared. `now=` is the one
+worth remembering in a test: a config with a date generator reads the clock, so pinning
+it is what keeps such a test stable for longer than a day.
+
+### Large runs
+
+```python
+data.write_file("people.csv", workers="auto")   # one process per core, bar one
+```
+
+A row is a function of its own index — that is what the streaming engine is built
+around — so a run splits across processes with nothing to coordinate. The output is byte
+for byte what one process writes; on one machine a gigabyte went from 11m37s to 87s
+across eleven processes.
+
+You do not need `if __name__ == "__main__":` around the call. Workers are launched as a
+named module rather than through `multiprocessing`, so nothing of yours is re-imported
+and re-executed.
+
+Splitting is skipped, silently and safely, wherever it would not be sound: the in-memory
+and exact engines, a config passed as a string rather than a file, Parquet output, and
+runs short enough that starting processes costs more than the rows do.
+
+## The command line
+
+`pip install tdcv2` puts `tdcv2` on the PATH — the same commands as the TypeScript, Java,
+C# and Rust CLIs, flag for flag. A Python user should not have to install Node to run a
+`.tdc` file.
+
+```bash
+tdcv2 people.tdc -o people.csv --count 100000 --jobs 8
+```
+
+|                                              |                                                                                      |
+| -------------------------------------------- | ------------------------------------------------------------------------------------ |
+| `tdcv2 <file.tdc>`                           | Generate. `-o`, `--seed`, `--count`, `--locale`, `--data-path`, `--engine`, `--jobs` |
+| `tdcv2 init`                                 | Write a `tdcv2.config.json` — asks at a terminal, takes `--yes` in a script          |
+| `tdcv2 pack list \| add <id> \| remove <id>` | Data packs, from the shared registry                                                 |
+| `tdcv2 check <file.tdc>`                     | Validate and say nothing when it is fine — for a pre-commit hook                     |
+| `tdcv2 format [-w] <file.tdc>`               | Pretty-print a config; `-w` rewrites it in place                                     |
+
+`--jobs` is the process split described above, and changes nothing but the wall clock.
+
+## Data packs
+
+A pack is the _data_ — the name lists, cities, streets and locale rules that
+`type="template"` draws from. The wheel carries a starter set: `common`, `en` and the USA
+country pack, which is what the example above uses. Ten languages and more than ninety
+country packs — with the right check-digit rule for each national ID format — are
+downloaded on demand:
+
+```bash
+tdcv2 init                 # write a tdcv2.config.json, once per project
+tdcv2 pack list            # what the registry has
+tdcv2 pack add ru france   # download and wire up
+```
+
+Or from code:
+
+```python
+from tdcv2.packs import DataPacks
+
+DataPacks.install(None, "ru", "france")   # downloads, verifies, registers in tdcv2.config.json
+```
+
+One registry, one `tdcv2.config.json`, one store, shared by all five implementations: a
+pack installed from here is a pack the others find. `--registry` accepts an `http`,
+`https` or `file` address, so an offline mirror or a folder on a share works the same way
+as the public one.
+
+## One config, five implementations
+
+TDC exists in TypeScript, Python, Java, C# and Rust. The same config and seed produce the
+same bytes in all five — that is the contract, and a shared fixture suite under
+`fixtures/cross-language/` checks it on every change: the shared cases through the router
+and on all three engines, the diagnostic cases by code and position, the PRNG and
+apportionment vectors, and the Parquet files byte for byte.
+
+It is why this package reimplements what a dependency would otherwise have provided. The
+only runtime dependency is `antlr4-python3-runtime`, and only because the grammar is
+shared with the other implementations and the parse tree has to be the same tree. The
+PRNG, the Snappy encoder, the Parquet writer and the date arithmetic are written here, so
+no library's choice of rounding or compression can change the bytes.
+
+| Module         | What it owns                                                                      |
+| -------------- | --------------------------------------------------------------------------------- |
+| `prng`         | The seekable generator, and the format-preserving permutation                     |
+| `distribution` | Hamilton apportionment and the `percent=` mask                                    |
+| `generators`   | number, regex, advanced_regex, symbol, counter, file, http, repeat, imperfections |
+| `date`         | A UTC calendar written out, eleven locale tables, the Moment-style formatter      |
+| `stats`        | Named distributions, the special functions behind gamma and beta, time series     |
+| `pattern`      | A drawn curve as a signal or a distribution; SVG and PNG readers                  |
+| `format`       | The positional mask, the interpolation filters, `${{Name\|filter}}`               |
+| `compute`      | The check-digit language, and the `if=` expression language                       |
+| `packs`        | Pack loading, the project cascade, the shared registry client                     |
+| `engine`       | The three engines and the router that picks between them                          |
+| `validator`    | Every `TDC###` code, each at the position an editor would underline               |
+| `output`       | Declared column types and the Parquet writer                                      |
+
+## Working on the repository
+
+The parser is generated from the shared grammar and the generator runs on Node. A
+released package ships it already generated; a checkout does not.
+
+```bash
+node scripts/generate-parsers.mjs --only python
+cd python
+python3 -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/pytest                  # 970 tests
+.venv/bin/ruff check src tests
+```
+
+`node scripts/five-ways.mjs --only python` does the same and regenerates the parser
+first, which is what CI runs.
+
+## Links
+
+- [Documentation](https://nickliapin.github.io/tdcv2/) — the DSL reference, guides and generators
+- [The Python binding](https://nickliapin.github.io/tdcv2/docs/bindings/python)
+- [Source](https://github.com/NickLiapin/tdcv2)
+
+## License
+
+MIT

tdcv2-0.1.2/pyproject.toml

@@ -0,0 +1,112 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tdcv2"
+# One number across all five implementations, deliberately. They are held to one
+# contract by the fixtures under `fixtures/cross-language/`, so a reader comparing
+# tdcv2 0.1.2 on PyPI with tdcv2 0.1.2 on npm should be able to assume the same
+# engine and the same bytes — which is the whole claim of the project.
+version = "0.1.2"
+description = "Deterministic test-data generator: coherent records, exact proportions, and any text format you describe. Same seed, same bytes — in Python, TypeScript, Java, C# and Rust alike."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Nick Liapin" }]
+
+# The terms people actually type when they are looking for this. PyPI's own search
+# leans on the description far more than on these, but the classifiers below and
+# these together are what the package indexes have to go on.
+keywords = [
+    "test-data",
+    "test-data-generator",
+    "mock-data",
+    "fake-data",
+    "fake-data-generator",
+    "synthetic-data",
+    "synthetic-data-generator",
+    "dummy-data",
+    "sample-data",
+    "data-generator",
+    "data-generation",
+    "deterministic",
+    "seeded",
+    "reproducible",
+    "coherent-data",
+    "fixtures",
+    "testing",
+    "csv",
+    "json",
+    "sql",
+    "parquet",
+    "cli",
+    "dsl",
+    "locale",
+    "i18n",
+]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Testing :: Mocking",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+
+# One runtime dependency, and it is the parser generator's own runtime — the grammar is shared
+# with the other implementations, so the parse tree has to be the same tree. Everything else is
+# written here rather than depended on, which is what keeps the three implementations producing
+# identical bytes: a library that changes its rounding or its compression changes our output.
+dependencies = ["antlr4-python3-runtime==4.13.2"]
+
+# Keep this table last among the [project] keys: in TOML every key below a table
+# header belongs to that table, so a plain key written after it silently becomes
+# `project.urls.<key>` — which is how `dependencies` once ended up in here.
+[project.urls]
+Homepage = "https://nickliapin.github.io/tdcv2/"
+Documentation = "https://nickliapin.github.io/tdcv2/docs/bindings/python"
+Repository = "https://github.com/NickLiapin/tdcv2"
+Changelog = "https://github.com/NickLiapin/tdcv2/blob/main/CHANGELOG.md"
+Issues = "https://github.com/NickLiapin/tdcv2/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "ruff>=0.6"]
+
+# `pip install tdcv2` puts `tdcv2` on the PATH. A Python user should never need another language's
+# toolchain to run a .tdc file, which is exactly what having only the TypeScript CLI would mean.
+[project.scripts]
+tdcv2 = "tdcv2.cli.main:cli"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+# The starter packs, put here by scripts/bundle_packs.py. Everything else is downloaded from the
+# shared registry on demand — see src/tdcv2/packs/registry.py.
+"tdcv2" = ["packs_data/**/*.txt", "packs_data/index.txt"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+# The generated parser is not ours to style, and regenerating it would undo any edit anyway.
+extend-exclude = ["src/tdcv2/parser/generated"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "SIM", "RUF"]
+# The "ambiguous unicode character" rules warn that а might be a typo for a. In a library whose
+# job is multilingual data they fire on every alphabet we ship on purpose — Cyrillic, fullwidth
+# digits, Greek — and there is no true positive among them.
+ignore = ["RUF001", "RUF002", "RUF003"]

tdcv2-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tdcv2-0.1.2/setup.py

@@ -0,0 +1,33 @@
+"""The one thing pyproject.toml alone cannot express: generate the starter packs before building.
+
+The packs are DATA, and they live in this repository once, under ``data/packs``. Committing a
+second copy inside the package would guarantee the two drift, so the copy is made at build time
+instead — the same thing the Gradle build does for the jar.
+"""
+
+from __future__ import annotations
+
+import runpy
+import sys
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_py import build_py
+
+HERE = Path(__file__).resolve().parent
+
+
+class BuildWithPacks(build_py):
+    def run(self) -> None:
+        script = HERE / "scripts" / "bundle_packs.py"
+        if script.is_file() and (HERE.parent / "data" / "packs").is_dir():
+            sys.argv = [str(script)]
+            try:
+                runpy.run_path(str(script), run_name="__main__")
+            except SystemExit as exit_code:
+                if exit_code.code:
+                    raise
+        super().run()
+
+
+setup(cmdclass={"build_py": BuildWithPacks})

tdcv2-0.1.2/src/tdcv2/__init__.py

@@ -0,0 +1,6 @@
+"""TDC — The Data Constructor. Deterministic test data from a declarative config."""
+
+from .errors import Diagnostic, Severity, TdcError
+from .tdc import TDC, Row, SeedInfo
+
+__all__ = ["TDC", "Diagnostic", "Row", "SeedInfo", "Severity", "TdcError"]

tdcv2-0.1.2/src/tdcv2/cli/__init__.py

@@ -0,0 +1,5 @@
+"""The ``tdcv2`` command line.
+
+Nothing is imported here on purpose: ``python -m tdcv2.cli.main`` would otherwise warn about the
+module being loaded twice, and the ordinary library import has no reason to pull the CLI in.
+"""

tdcv2-0.1.2/src/tdcv2/cli/__main__.py

@@ -0,0 +1,5 @@
+"""``python -m tdcv2.cli`` — the same entry point as the installed ``tdcv2`` command."""
+
+from .main import cli
+
+cli()