varda 0.1.0__tar.gz

varda-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Luttikhof
+
+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.

varda-0.1.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: varda
+Version: 0.1.0
+Summary: Dimensional modeling for LinkML — a profile, its rules, and the generators that hang off it
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mluttikh/varda
+Project-URL: Documentation, https://mluttikh.github.io/varda/
+Project-URL: Source, https://github.com/mluttikh/varda
+Keywords: linkml,dimensional-modeling,star-schema,kimball,data-warehouse,data-mart,metadata
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: linkml-runtime>=1.9
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: pyyaml>=6; extra == "dev"
+Requires-Dist: types-PyYAML>=6; extra == "dev"
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Requires-Dist: actionlint-py>=1.7; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: mkdocs<2,>=1.6; extra == "docs"
+Dynamic: license-file
+
+# Varda
+
+[![CI](https://github.com/mluttikh/varda/actions/workflows/ci.yml/badge.svg)](https://github.com/mluttikh/varda/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/varda)](https://pypi.org/project/varda/)
+[![Python](https://img.shields.io/pypi/pyversions/varda)](https://pypi.org/project/varda/)
+[![Docs](https://img.shields.io/badge/docs-mluttikh.github.io%2Fvarda-2F6B57)](https://mluttikh.github.io/varda/)
+
+**Dimensional modeling for [LinkML](https://linkml.io).**
+
+Varda is a *profile* of LinkML: a small vocabulary that lets you say a class
+is a fact table, that a column is a semi-additive measure, that a dimension
+keeps history. It then checks those claims and generates from them.
+
+A model annotated with Varda is still an ordinary LinkML schema. Every other
+LinkML tool — `gen-pydantic`, `gen-owl`, `gen-json-schema` — will read it
+happily and ignore what it does not understand.
+
+```yaml
+FctSale:
+  annotations:
+    varda:role: fact
+    varda:fact_type: transaction
+    varda:grain: one row per product per line of a sales receipt
+  attributes:
+    customer_key:
+      range: integer
+      annotations:
+        varda:role: foreign_key
+        varda:references: DimCustomer
+    net_amount:
+      range: decimal
+      annotations:
+        varda:role: measure
+        varda:additivity: additive
+        varda:unit: EUR
+```
+
+```console
+$ varda check model.yaml
+8 tables checked against 22 rules (varda 0.1.0): 0 errors, 0 warnings
+
+$ varda generate model.yaml --out out/
+wrote out/docs/model.md
+wrote out/sql/mart.sql
+```
+
+## Install
+
+```console
+pip install varda
+```
+
+Python 3.11+. The only runtime dependency is `linkml-runtime`.
+
+## What it gives you
+
+**Eleven annotations.** Five on tables — `role`, `grain`, `fact_type`, `scd`,
+`physical_name`. Six on columns — `role`, `references`, `additivity`,
+`semi_additive_over`, `unit`, `physical_name`. That is the whole core
+vocabulary, and it is deliberately the whole core vocabulary.
+
+**Twenty-two rules** that catch the mistakes worth catching:
+
+| | |
+| --- | --- |
+| `V001`–`V003` | the annotations themselves — typos, bad enum values, unknown prefixes |
+| `V101`–`V113` | structure — a fact without a grain, a foreign key pointing at a fact, a dimension with no natural key |
+| `V201`–`V206` | measures — an unclassified measure, a semi-additive one that never says what it cannot cross |
+
+The `V2xx` family exists because additivity is where the expensive errors
+live. A structural mistake usually breaks a query. An additivity mistake
+returns a number that looks entirely reasonable and is wrong, to someone who
+will act on it.
+
+**Two generators**, `sql` and `docs`, producing runnable DDL and a Markdown
+reference. Both are deterministic: no timestamps, no environment, same model
+in and same bytes out, so the output can be committed and diffed.
+
+## Extending it
+
+Varda's core is small on purpose. Anything specific to how *your*
+organization works — cost centers, retention, data classification, ownership
+— goes in an extension under your own prefix.
+
+The smallest useful extension needs no Python at all. Write a LinkML schema
+declaring your vocabulary, then a `varda.toml`:
+
+```toml
+[[extension]]
+name = "acme"
+prefix = "acme"
+profile = "profiles/acme.yaml"
+```
+
+From then on `acme:cost_center` is a first-class annotation: checked for
+typos, its enum values enforced, and listed by `varda ext`. Misspell it and
+you get
+
+```
+ERROR V001  DimStore
+        unknown table annotation 'acme:cost_center'; declare it in
+        acme.yaml or fix the typo
+```
+
+Full documentation: **<https://mluttikh.github.io/varda/>**
+
+An extension with code behind it adds rules and generators through
+`varda.ext`, and ships as an installable package advertising the
+`varda.extensions` entry point. See [`SPEC.md`](SPEC.md) for the interface
+and `tests/fixtures/acme_ext/` for a complete worked example.
+
+**One party, one namespace; extensions add, they never redefine.** An
+extension may introduce annotations, enums and rules under its own prefix. It
+may not add a value to `TableRole` or change what `semi_additive` means —
+every generator dispatches exhaustively on those, and the registry refuses at
+load rather than warning.
+
+## Commands
+
+| | |
+| --- | --- |
+| `varda check MODEL` | validate; `--strict` fails on warnings too |
+| `varda generate MODEL --out DIR` | write artifacts; fails closed |
+| `varda rules` | list every rule, `-v` for reasoning |
+| `varda ext` | describe active extensions and their vocabulary |
+| `varda importmap` | print the LinkML import map |
+
+Exit codes are part of the contract: `0` success, `1` the model or run
+failed, `2` the invocation was wrong.
+
+## Status
+
+**0.1.0 — alpha.** The vocabulary and rule codes are stable enough to build
+on; rule codes will not be renumbered. Analytical functions, model diffing,
+lineage and the drift gate are deliberately not here yet — see `SPEC.md` for
+what is deferred and why.
+
+## Building the documentation
+
+```console
+pip install -e ".[docs]"
+mkdocs serve
+```
+
+Then open **<http://127.0.0.1:8000/varda/>** — note the `/varda/` path, which
+comes from `site_url` because this is a GitHub Pages project site rather than
+a user site. Plain `http://127.0.0.1:8000/` redirects there.
+
+The vocabulary, rules and command-line pages are generated from the package
+itself into a git-ignored `docs/reference/`, so they cannot drift from the
+code. `mkdocs serve` regenerates them on every rebuild and watches `src/` as
+well as `docs/` — edit a rule's docstring and the page updates.
+
+To build the static site the way CI does:
+
+```console
+python scripts/gen_reference.py
+mkdocs build --strict
+```
+
+`--strict` turns a broken internal link into a failed build. The generator is
+a standalone script rather than a plugin, so the site also builds under
+[Zensical](https://zensical.org) and [ProperDocs](https://properdocs.org) from
+the same `mkdocs.yml` — see `docs/design.md` for why that matters.
+
+## License
+
+MIT for the code. The profile vocabulary in `src/varda/profile/varda.yaml` is
+CC0, so it can be reused anywhere without attribution — a vocabulary that
+constrains its own reuse is not much of a vocabulary.

varda-0.1.0/README.md

@@ -0,0 +1,170 @@
+# Varda
+
+[![CI](https://github.com/mluttikh/varda/actions/workflows/ci.yml/badge.svg)](https://github.com/mluttikh/varda/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/varda)](https://pypi.org/project/varda/)
+[![Python](https://img.shields.io/pypi/pyversions/varda)](https://pypi.org/project/varda/)
+[![Docs](https://img.shields.io/badge/docs-mluttikh.github.io%2Fvarda-2F6B57)](https://mluttikh.github.io/varda/)
+
+**Dimensional modeling for [LinkML](https://linkml.io).**
+
+Varda is a *profile* of LinkML: a small vocabulary that lets you say a class
+is a fact table, that a column is a semi-additive measure, that a dimension
+keeps history. It then checks those claims and generates from them.
+
+A model annotated with Varda is still an ordinary LinkML schema. Every other
+LinkML tool — `gen-pydantic`, `gen-owl`, `gen-json-schema` — will read it
+happily and ignore what it does not understand.
+
+```yaml
+FctSale:
+  annotations:
+    varda:role: fact
+    varda:fact_type: transaction
+    varda:grain: one row per product per line of a sales receipt
+  attributes:
+    customer_key:
+      range: integer
+      annotations:
+        varda:role: foreign_key
+        varda:references: DimCustomer
+    net_amount:
+      range: decimal
+      annotations:
+        varda:role: measure
+        varda:additivity: additive
+        varda:unit: EUR
+```
+
+```console
+$ varda check model.yaml
+8 tables checked against 22 rules (varda 0.1.0): 0 errors, 0 warnings
+
+$ varda generate model.yaml --out out/
+wrote out/docs/model.md
+wrote out/sql/mart.sql
+```
+
+## Install
+
+```console
+pip install varda
+```
+
+Python 3.11+. The only runtime dependency is `linkml-runtime`.
+
+## What it gives you
+
+**Eleven annotations.** Five on tables — `role`, `grain`, `fact_type`, `scd`,
+`physical_name`. Six on columns — `role`, `references`, `additivity`,
+`semi_additive_over`, `unit`, `physical_name`. That is the whole core
+vocabulary, and it is deliberately the whole core vocabulary.
+
+**Twenty-two rules** that catch the mistakes worth catching:
+
+| | |
+| --- | --- |
+| `V001`–`V003` | the annotations themselves — typos, bad enum values, unknown prefixes |
+| `V101`–`V113` | structure — a fact without a grain, a foreign key pointing at a fact, a dimension with no natural key |
+| `V201`–`V206` | measures — an unclassified measure, a semi-additive one that never says what it cannot cross |
+
+The `V2xx` family exists because additivity is where the expensive errors
+live. A structural mistake usually breaks a query. An additivity mistake
+returns a number that looks entirely reasonable and is wrong, to someone who
+will act on it.
+
+**Two generators**, `sql` and `docs`, producing runnable DDL and a Markdown
+reference. Both are deterministic: no timestamps, no environment, same model
+in and same bytes out, so the output can be committed and diffed.
+
+## Extending it
+
+Varda's core is small on purpose. Anything specific to how *your*
+organization works — cost centers, retention, data classification, ownership
+— goes in an extension under your own prefix.
+
+The smallest useful extension needs no Python at all. Write a LinkML schema
+declaring your vocabulary, then a `varda.toml`:
+
+```toml
+[[extension]]
+name = "acme"
+prefix = "acme"
+profile = "profiles/acme.yaml"
+```
+
+From then on `acme:cost_center` is a first-class annotation: checked for
+typos, its enum values enforced, and listed by `varda ext`. Misspell it and
+you get
+
+```
+ERROR V001  DimStore
+        unknown table annotation 'acme:cost_center'; declare it in
+        acme.yaml or fix the typo
+```
+
+Full documentation: **<https://mluttikh.github.io/varda/>**
+
+An extension with code behind it adds rules and generators through
+`varda.ext`, and ships as an installable package advertising the
+`varda.extensions` entry point. See [`SPEC.md`](SPEC.md) for the interface
+and `tests/fixtures/acme_ext/` for a complete worked example.
+
+**One party, one namespace; extensions add, they never redefine.** An
+extension may introduce annotations, enums and rules under its own prefix. It
+may not add a value to `TableRole` or change what `semi_additive` means —
+every generator dispatches exhaustively on those, and the registry refuses at
+load rather than warning.
+
+## Commands
+
+| | |
+| --- | --- |
+| `varda check MODEL` | validate; `--strict` fails on warnings too |
+| `varda generate MODEL --out DIR` | write artifacts; fails closed |
+| `varda rules` | list every rule, `-v` for reasoning |
+| `varda ext` | describe active extensions and their vocabulary |
+| `varda importmap` | print the LinkML import map |
+
+Exit codes are part of the contract: `0` success, `1` the model or run
+failed, `2` the invocation was wrong.
+
+## Status
+
+**0.1.0 — alpha.** The vocabulary and rule codes are stable enough to build
+on; rule codes will not be renumbered. Analytical functions, model diffing,
+lineage and the drift gate are deliberately not here yet — see `SPEC.md` for
+what is deferred and why.
+
+## Building the documentation
+
+```console
+pip install -e ".[docs]"
+mkdocs serve
+```
+
+Then open **<http://127.0.0.1:8000/varda/>** — note the `/varda/` path, which
+comes from `site_url` because this is a GitHub Pages project site rather than
+a user site. Plain `http://127.0.0.1:8000/` redirects there.
+
+The vocabulary, rules and command-line pages are generated from the package
+itself into a git-ignored `docs/reference/`, so they cannot drift from the
+code. `mkdocs serve` regenerates them on every rebuild and watches `src/` as
+well as `docs/` — edit a rule's docstring and the page updates.
+
+To build the static site the way CI does:
+
+```console
+python scripts/gen_reference.py
+mkdocs build --strict
+```
+
+`--strict` turns a broken internal link into a failed build. The generator is
+a standalone script rather than a plugin, so the site also builds under
+[Zensical](https://zensical.org) and [ProperDocs](https://properdocs.org) from
+the same `mkdocs.yml` — see `docs/design.md` for why that matters.
+
+## License
+
+MIT for the code. The profile vocabulary in `src/varda/profile/varda.yaml` is
+CC0, so it can be reused anywhere without attribution — a vocabulary that
+constrains its own reuse is not much of a vocabulary.

varda-0.1.0/pyproject.toml

@@ -0,0 +1,212 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "varda"
+
+# The version lives in `src/varda/__init__.py` and is read from there, rather
+# than being declared here and repeated in the package. Two copies of a
+# version number drift the first time somebody bumps one of them, and the
+# failure is quiet: `varda check` prints `__version__` in its summary line, so
+# a package would misreport itself to every user while the distribution
+# metadata said something else. One source removes the class of mistake
+# instead of adding a test that notices it afterwards.
+dynamic = ["version"]
+description = "Dimensional modeling for LinkML — a profile, its rules, and the generators that hang off it"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+keywords = [
+    "linkml",
+    "dimensional-modeling",
+    "star-schema",
+    "kimball",
+    "data-warehouse",
+    "data-mart",
+    "metadata",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Database",
+    "Topic :: Software Development :: Code Generators",
+    "Typing :: Typed",
+]
+
+# Only linkml-runtime. The full `linkml` distribution pulls a large tree in
+# order to provide generators, and Varda's generators are hand-written against
+# the model layer rather than against LinkML's generator framework. A minimal
+# dependency set is most of what makes this installable inside somebody else's
+# pipeline without an argument.
+dependencies = ["linkml-runtime>=1.9"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "mypy>=1.11",
+    "ruff>=0.6",
+    "pyyaml>=6",
+    "types-PyYAML>=6",
+    "build>=1",
+    "twine>=5",
+    # Vendors the actionlint binary. The workflows are code that only
+    # ever runs on a push, so a mistake in them is otherwise found by
+    # pushing a broken one and reading the failure.
+    "actionlint-py>=1.7",
+]
+docs = [
+    "mkdocs-material>=9.5",
+    # Pinned below 2.0 deliberately. MkDocs last shipped 1.6.1 in August
+    # 2024, and its maintainer has announced a 2.0 that will not support
+    # existing themes, plugins or config files. An unpinned `mkdocs` could
+    # therefore break the docs build without a change on our side.
+    #
+    # `properdocs`, a maintained continuation of 1.x, has been verified as a
+    # drop-in: `properdocs build --strict` produces an identical site from
+    # this same mkdocs.yml. If 2.0 lands and the pin becomes untenable, that
+    # is the migration, and it is a one-line change here.
+    "mkdocs>=1.6,<2",
+]
+
+[project.urls]
+Homepage = "https://github.com/mluttikh/varda"
+Documentation = "https://mluttikh.github.io/varda/"
+Source = "https://github.com/mluttikh/varda"
+
+[project.scripts]
+varda = "varda.cli:main"
+
+[project.entry-points."varda.extensions"]
+# Extensions register here. Varda itself does not — it is built in, so that
+# the core is present even when nothing else is installed.
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.dynamic]
+version = { attr = "varda.__version__" }
+
+# Ships the type information. An extension author's own type checker then sees
+# the boundary Varda maintains: `model.py` is the wall built along the untyped
+# LinkML runtime, and everything it returns is a concrete type.
+[tool.setuptools.package-data]
+varda = ["py.typed", "profile/*.yaml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.11"
+files = ["src/varda", "tests", "scripts"]
+strict = true
+
+# LinkML ships no `py.typed`, so every object out of `SchemaView` is `Any`.
+# That is not a defect to suppress and forget: it is the boundary of the typed
+# world, and `varda/model.py` is the wall built along it.
+#
+# `warn_return_any` is the rule doing the work. It fires whenever an `Any`
+# escapes into a signature claiming something specific, which is exactly the
+# mistake this arrangement exists to catch. Do not switch it off to make a
+# stubborn line pass.
+[[tool.mypy.overrides]]
+module = ["linkml_runtime.*", "jsonasobj2"]
+ignore_missing_imports = true
+
+[tool.ruff]
+line-length = 80
+extend-exclude = ["out"]
+
+[tool.ruff.lint]
+select = [
+    "A",    # flake8-builtins
+    "ARG",  # unused-function-argument
+    "B",    # flake8-bugbear
+    "BLE",  # flake8-blind-except
+    "C4",   # comprehensions
+    "C90",  # mccabe
+    "D",    # pydocstyle
+    "E",    # pycodestyle
+    "EM",   # flake8-errmsg
+    "ERA",  # eradicate
+    "F",    # pyflakes
+    "FA",   # flake8-future-annotations
+    "FLY",  # flynt
+    "FURB", # refurb
+    "G",    # flake8-logging-format
+    "I",    # isort
+    "ICN",  # flake8-import-conventions
+    "INP",  # flake8-no-pep420
+    "ISC",  # flake8-implicit-str-concat
+    "LOG",  # flake8-logging
+    "N",    # pep8-naming
+    "PERF", # Perflint
+    "PGH",  # pygrep-hooks
+    "PIE",  # flake8-pie
+    "PLC",  # pylint-convention
+    "PLE",  # pylint-error
+    "PLR",  # pylint-refactor
+    "PLW",  # pylint-warning
+    "PT",   # flake8-pytest-style
+    "PTH",  # flake8-use-pathlib
+    "PYI",  # flake8-pyi
+    "Q",    # flake8-quotes
+    "RET",  # flake8-return
+    "RSE",  # flake8-raise
+    "RUF",  # ruff-specific
+    "S",    # flake8-bandit
+    "SIM",  # flake8-simplify
+    "SLF",  # flake8-self
+    "T10",  # flake8-debugger
+    "T20",  # flake8-print
+    "TCH",  # flake8-type-checking
+    "TID",  # flake8-tidy-imports
+    "UP",   # pyupgrade
+    "W",    # pycodestyle
+    "YTT",  # flake8-2020
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "pep257"
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+"tests/**" = [
+    "D103",    # undocumented-public-function
+    "PLR2004", # magic-value-comparison
+    "S101",    # assert
+    "SLF001",  # private-member-access
+    # INP001 wants an `__init__.py` here. Adding one would make `tests` a
+    # package, which changes how pytest imports these modules and breaks the
+    # `sys.path` insertion in `conftest.py` that makes the extension fixture
+    # importable the way an installed extension would be. The rule exists to
+    # catch source accidentally left as a namespace package; a pytest test
+    # directory is not that.
+    "INP001",
+]
+
+# Three deviations, each specific to this codebase rather than to taste.
+#
+# T201 in the CLI: a command-line tool's output *is* `print`. Routing it
+# through a logger to satisfy the rule would make the thing worse at its job.
+"src/varda/cli.py" = ["T201"]
+#
+# D102 in the model layer: `model.py` is mostly one-line property wrappers,
+# and the only docstring they could carry is the property name restated. The
+# class docstrings carry the meaning; the accessors do not need one each.
+"src/varda/model.py" = ["D102"]
+#
+# D103 in the rules: every rule registers a human-readable title in its
+# decorator, and `varda rules` prints it. A docstring is reserved for rules
+# whose *reasoning* is not obvious, and `varda rules -v` prints those.
+# Requiring one on all twenty-one would duplicate the title twenty-one times.
+"src/varda/rules.py" = ["D103"]
+#
+# scripts/ is build tooling, not an importable package — INP001 wants an
+# __init__.py that would serve no purpose. T201 because writing to stdout is
+# how a build script reports what it wrote.
+"scripts/**" = ["INP001", "T201"]

varda-0.1.0/setup.cfg

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

varda-0.1.0/src/varda/__init__.py

@@ -0,0 +1,29 @@
+"""Varda — dimensional modeling for LinkML.
+
+A profile of LinkML that adds the vocabulary of dimensional modeling — facts,
+dimensions, grain, additivity, slowly-changing dimensions — plus the rules
+that check a model against it and the generators that build from it.
+
+Third parties import :mod:`varda.ext` and nothing else. Everything reachable
+from there is public and versioned; everything else is internal and moves
+without notice.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .ext import Context, Extension, ExtensionError, Generator
+from .model import DimensionalModel
+from .rules import Finding, RuleSet
+
+__all__ = [
+    "Context",
+    "DimensionalModel",
+    "Extension",
+    "ExtensionError",
+    "Finding",
+    "Generator",
+    "RuleSet",
+    "__version__",
+]

varda-0.1.0/src/varda/__main__.py

@@ -0,0 +1,8 @@
+"""Allow ``python -m varda``."""
+
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())