openstatspec 0.3.0__tar.gz → 0.4.0__tar.gz

{openstatspec-0.3.0 → openstatspec-0.4.0}/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to this reference implementation are documented here.
 
+## 0.4.0 — 2026-07-31
+
+### Added
+
+- Added a public canonical transformation-plan in-place API accepting either
+  typed plan objects or strictly validated mappings.
+- Added apply-plan and install-in-place-schema CLI workflows alongside the
+  compatible apply-spss command.
+- Added explicit audit provenance distinguishing canonical plan documents from
+  SPSS syntax sources.
+- Added a transformation manual covering the canonical core, frontend boundary,
+  execution invariants, CLI/API workflows, and extension rules.
+
+### Changed
+
+- Moved the SPSS parser, binder, compiler, and convenience execution adapter to
+  the dedicated openstatspec.frontends.spss package.
+- Kept openstatspec.transform language-neutral with canonical plan, schema, and
+  live-schema validation modules while preserving previous SPSS import paths.
+- Reserved empty Stata and SAS frontend directories without exposing parsers,
+  capabilities, CLI choices, or support claims.
+- Strengthened pre-mutation target-type checks and target-scoped physical table
+  identity guards. The executor continues to modify the same dataset and table
+  without creating OpenStatSpec rollback, copy, snapshot, or history layers.
+
+### Specification basis
+
+- Conformance and release validation continue to use OpenStatSpec specification
+  release v0.2.0 at exact commit
+  79339ec3d8f8aa81789b7e85f6b8afa6f1374e50.
+
 ## 0.3.0 — 2026-07-31
 
 ### Added

{openstatspec-0.3.0 → openstatspec-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openstatspec
-Version: 0.3.0
+Version: 0.4.0
 Summary: Reference adapter for the OpenStatSpec relational contract
 Author: OpenStatSpec
 License: Apache-2.0
@@ -45,6 +45,10 @@ import.
   capabilities, and loss reports.
 - `openstatspec.sql`: database connection and wide-table/catalog operations.
 - `openstatspec.spss`: SAV/ZSAV adapter boundary.
+- `openstatspec.transform`: canonical plans, frontend-neutral schema concepts,
+  and plan validation.
+- `openstatspec.frontends.spss`: the SPSS-like syntax frontend and convenience
+  execution adapter.
 
 ## Intended workflow
 
@@ -82,43 +86,17 @@ implemented capability boundary.
 
 ## SPSS-like transformation frontend
 
-The transformation frontend accepts `RECODE`, `VARIABLE LABELS`, and
-`VALUE LABELS`, lowers them to a canonical OpenStatSpec Transformation Plan,
-and mutates the same logical dataset and physical wide table. SQLite,
-PostgreSQL, MySQL, MariaDB, and Dolt connections are allowed. It creates no
-derived dataset, copied table, snapshot, or OpenStatSpec rollback/version layer.
-
-Install the compact operation-audit relation separately, then apply syntax:
-
-```python
-from openstatspec import (
-    apply_spss_in_place,
-    install_in_place_transformation_schema,
-)
-
-database_url = "postgresql+psycopg://user:password@host/database"
-install_in_place_transformation_schema(database_url=database_url)
-result = apply_spss_in_place(
-    database_url=database_url,
-    dataset_id="...",
-    actor="agent@example.org",
-    source_text="""
-      RECODE age (18 THRU 34 = 1) (35 THRU 64 = 2) INTO age_group.
-      VARIABLE LABELS age_group 'Age group'.
-      VALUE LABELS age_group 1 '18-34' 2 '35-64'.
-    """,
-)
-```
-
-Existing-target recodes and metadata mutations use direct DML. SQLite and
-PostgreSQL may also add a target column in the same native transaction. MySQL,
-MariaDB, and Dolt reject such schema-changing plans before mutation because
-their implicit-commit DDL could otherwise leave a partial apply. On Dolt, the
-caller additionally supplies expected branch and HEAD identities, and the
-working set must be clean. The transformer never calls `DOLT_COMMIT`.
-
-See [in-place transformations](docs/in-place-transformation.md) for the full
-execution boundary and CLI form.
+The SPSS-like frontend lowers supported `RECODE`, `VARIABLE LABELS`, and
+`VALUE LABELS` syntax into a language-neutral canonical plan. The in-place
+path applies it to the same logical dataset, physical wide table, and metadata
+catalog without a derived dataset, copied table, snapshot, or separate
+rollback/history layer. Dolt remains the sole versioning layer for Dolt-backed
+edits, and the transformer never calls `DOLT_COMMIT`.
+
+See the [dataset transformations manual](docs/transformations.md) for schema
+installation, Python and CLI surfaces, database invariants, audit provenance,
+package layout, and extension guidance. Stata and SAS are unimplemented
+placeholders.
 
 ## Current support status
 

{openstatspec-0.3.0 → openstatspec-0.4.0}/README.md

@@ -26,6 +26,10 @@ import.
   capabilities, and loss reports.
 - `openstatspec.sql`: database connection and wide-table/catalog operations.
 - `openstatspec.spss`: SAV/ZSAV adapter boundary.
+- `openstatspec.transform`: canonical plans, frontend-neutral schema concepts,
+  and plan validation.
+- `openstatspec.frontends.spss`: the SPSS-like syntax frontend and convenience
+  execution adapter.
 
 ## Intended workflow
 
@@ -63,43 +67,17 @@ implemented capability boundary.
 
 ## SPSS-like transformation frontend
 
-The transformation frontend accepts `RECODE`, `VARIABLE LABELS`, and
-`VALUE LABELS`, lowers them to a canonical OpenStatSpec Transformation Plan,
-and mutates the same logical dataset and physical wide table. SQLite,
-PostgreSQL, MySQL, MariaDB, and Dolt connections are allowed. It creates no
-derived dataset, copied table, snapshot, or OpenStatSpec rollback/version layer.
-
-Install the compact operation-audit relation separately, then apply syntax:
-
-```python
-from openstatspec import (
-    apply_spss_in_place,
-    install_in_place_transformation_schema,
-)
-
-database_url = "postgresql+psycopg://user:password@host/database"
-install_in_place_transformation_schema(database_url=database_url)
-result = apply_spss_in_place(
-    database_url=database_url,
-    dataset_id="...",
-    actor="agent@example.org",
-    source_text="""
-      RECODE age (18 THRU 34 = 1) (35 THRU 64 = 2) INTO age_group.
-      VARIABLE LABELS age_group 'Age group'.
-      VALUE LABELS age_group 1 '18-34' 2 '35-64'.
-    """,
-)
-```
-
-Existing-target recodes and metadata mutations use direct DML. SQLite and
-PostgreSQL may also add a target column in the same native transaction. MySQL,
-MariaDB, and Dolt reject such schema-changing plans before mutation because
-their implicit-commit DDL could otherwise leave a partial apply. On Dolt, the
-caller additionally supplies expected branch and HEAD identities, and the
-working set must be clean. The transformer never calls `DOLT_COMMIT`.
-
-See [in-place transformations](docs/in-place-transformation.md) for the full
-execution boundary and CLI form.
+The SPSS-like frontend lowers supported `RECODE`, `VARIABLE LABELS`, and
+`VALUE LABELS` syntax into a language-neutral canonical plan. The in-place
+path applies it to the same logical dataset, physical wide table, and metadata
+catalog without a derived dataset, copied table, snapshot, or separate
+rollback/history layer. Dolt remains the sole versioning layer for Dolt-backed
+edits, and the transformer never calls `DOLT_COMMIT`.
+
+See the [dataset transformations manual](docs/transformations.md) for schema
+installation, Python and CLI surfaces, database invariants, audit provenance,
+package layout, and extension guidance. Stata and SAS are unimplemented
+placeholders.
 
 ## Current support status
 

openstatspec-0.4.0/docs/in-place-transformation.md

@@ -0,0 +1,9 @@
+# In-place transformations
+
+This page has moved to the comprehensive
+[dataset transformations manual](transformations.md).
+
+The manual covers the canonical plan, SPSS-like frontend, executor, audit
+schema, Python and CLI surfaces, database and Dolt invariants, provenance,
+package layout, and future frontend boundary. Stata and SAS remain
+unimplemented placeholders.

{openstatspec-0.3.0 → openstatspec-0.4.0}/docs/release-readiness.md

@@ -1,4 +1,4 @@
-# 0.3.0 release readiness
+# 0.4.0 release readiness
 
 This page records the expected release contract, not a publication event.
 Creating a version tag remains a separate maintainer action.
@@ -56,6 +56,36 @@ otherwise the strict export policy reports and blocks the loss. A caller
 that supplies consent for an available loss code receives the
 machine-readable loss report with the export result.
 
+## Transformation release gates
+
+The canonical transformation core and SPSS syntax frontend are separate public
+surfaces. A release must run the specification-owned canonical-plan and SPSS
+frontend conformance fixtures, then exercise both the generic plan apply API
+and the SPSS compatibility apply path.
+
+The gate must prove that:
+
+- a TransformationPlan object and its strict JSON mapping produce the same
+  plan hash and in-place result;
+- top-level SPSS compiler imports and legacy openstatspec.transform re-exports
+  still load from an installed wheel;
+- install-in-place-schema, apply-plan, and apply-spss execute their documented
+  CLI workflows;
+- invalid or unsupported plans fail before the first data or metadata mutation;
+- successful applies retain the same dataset ID, physical schema/table
+  identity, dataset count, and persistent physical data-table count;
+- audit rows distinguish canonical plans from SPSS syntax, preserve correct
+  source/plan hashes and frontend contract, and contain no copied data;
+- no OpenStatSpec rollback, snapshot, staging, copy, derived-dataset, or
+  parallel history artifacts are created; and
+- Dolt checks expected branch, HEAD, and a clean working set without committing
+  or changing HEAD; other supported SQL connections remain allowed.
+
+The built wheel must contain the generic openstatspec.transform modules and the
+implemented openstatspec.frontends.spss package. Stata and SAS remain empty
+source-tree placeholders and must expose no compiler, apply API, CLI choice,
+capability claim, or implied support.
+
 ## Maintainer checks before tagging
 
 1. Publish the pinned `openstatspec-pyspssio==0.5.1.post2` engine distribution

openstatspec-0.4.0/docs/transformations.md

@@ -0,0 +1,204 @@
+# Dataset transformations
+
+OpenStatSpec separates transformation syntax, canonical meaning, and database
+mutation. This lets multiple language frontends produce the same plan without
+coupling the executor to any one language.
+
+The implemented frontend accepts a small SPSS-like subset: `RECODE`,
+`VARIABLE LABELS`, and `VALUE LABELS`. Stata and SAS are not implemented.
+
+## Architecture
+
+The path has three layers:
+
+1. A **frontend** parses source text and binds names and types against an
+   explicit input schema. It performs no database mutation or SQL generation.
+2. The **canonical plan** contains ordered, typed, language-neutral operations.
+   Its canonical JSON and hash are independent of SQL dialect and source
+   formatting.
+3. The **in-place executor** validates the complete plan against the live
+   dataset, then directly mutates that dataset's existing wide table and
+   metadata catalog. It does not parse frontend syntax.
+
+This is a trust boundary. JSON plans must pass
+`transformation_plan_from_dict()` and live-schema validation before mutation;
+they are never treated as arbitrary SQL.
+
+## Install the audit schema
+
+Install the compact audit relation once before the first apply:
+
+```python
+import openstatspec
+
+openstatspec.install_in_place_transformation_schema(
+    database_url="sqlite:///survey.sqlite",
+)
+```
+
+Installation is separate because schema DDL may commit independently on some
+engines. Apply fails before changing data or metadata when the audit relation is
+absent, and never creates or migrates schema-management objects itself.
+
+The CLI equivalent is:
+
+```text
+openstatspec install-in-place-schema --database-url sqlite:///survey.sqlite
+```
+
+## Generic canonical-plan apply
+
+`openstatspec.transform.TransformationPlan` is the generic model. Numeric
+constants retain exact binary64 bits, strings retain exact Unicode text, and
+operation order is significant. Use `transformation_plan_from_dict()` for
+untrusted mappings. `canonical_plan_json()` and `canonical_plan_hash()`
+produce stable audit identities.
+
+The public API is:
+
+```python
+result = openstatspec.apply_transformation_plan_in_place(
+    database_url="sqlite:///survey.sqlite",
+    dataset_id="responses",
+    plan=plan,
+    actor="agent@example.org",
+    expected_branch=None,
+    expected_head=None,
+)
+```
+
+`plan` accepts a `TransformationPlan` or a mapping handled by the strict
+loader. The executor recomputes the hash and validates the whole plan before
+mutation.
+
+The corresponding CLI is:
+
+```text
+openstatspec apply-plan --database-url sqlite:///survey.sqlite \
+  --dataset-id responses --actor agent@example.org --plan-file plan.json
+```
+
+## SPSS-like frontend
+
+The pure compiler works without a database:
+
+```python
+from openstatspec import VariableDefinition, VariableSchema, compile_spss_syntax
+
+schema = VariableSchema((VariableDefinition("age", "numeric"),))
+compilation = compile_spss_syntax(
+    "RECODE age (18 THRU 34 = 1) (35 THRU 64 = 2).",
+    schema,
+)
+print(compilation.plan.canonical_json())
+print(compilation.plan_hash)
+```
+
+It normalizes line endings, records the source hash, parses and sequentially
+binds the supported subset, and returns a canonical plan plus output schema.
+
+For database-connected use, the compatibility wrapper loads the live schema,
+compiles the source, and invokes the in-place path:
+
+```python
+result = openstatspec.apply_spss_in_place(
+    database_url="sqlite:///survey.sqlite",
+    dataset_id="responses",
+    actor="agent@example.org",
+    source_text="""
+      RECODE age (18 THRU 34 = 1) (35 THRU 64 = 2).
+      VARIABLE LABELS age 'Age group'.
+      VALUE LABELS age 1 '18-34' 2 '35-64'.
+    """,
+)
+```
+
+`openstatspec.compile_spss_syntax` and
+`openstatspec.apply_spss_in_place` remain compatibility APIs.
+
+The current CLI wrapper is:
+
+```text
+openstatspec apply-spss --database-url sqlite:///survey.sqlite \
+  --dataset-id responses --actor agent@example.org --syntax-file transform.sps
+```
+
+On Dolt, also pass `--expected-branch` and `--expected-head`.
+
+## Database and Dolt invariants
+
+Every successful apply preserves the logical `dataset_id` and physical
+schema/table identity. It creates no derived dataset, output table, full-table
+copy, staging table, snapshot, rollback artifact, or recovery/history layer.
+Existing-target recodes use direct `UPDATE`; label operations mutate existing
+catalog rows.
+
+SQLite and PostgreSQL may add a numeric target where native transactions make
+the complete operation atomic. MySQL, MariaDB, and Dolt reject target-creating
+plans before the first mutation because implicit-commit DDL could leave a
+partial apply. Their target column and metadata must already exist.
+
+Dolt is the sole history, diff, branch, and rollback layer for Dolt-backed
+datasets. Before mutation, the executor verifies the expected branch and
+`HEAD` and requires clean `dolt_status`. Success changes the same working set
+without changing `HEAD`. OpenStatSpec does not call `DOLT_COMMIT`, switch
+branches, merge, reset, tag, or create a hidden recovery commit. The caller
+reviews `dolt diff` and separately decides whether to commit or restore.
+
+## Audit and provenance
+
+Each success writes one compact `transformation_apply` row in the data and
+metadata transaction. It records dataset and relation identity, actor, plan
+hash, operation count, timestamps, database profile, and relevant Dolt
+branch/HEAD. SPSS source also has a normalized source hash.
+
+The row stores no case values and references no copied state. It is provenance,
+not an undo log or substitute for Dolt history. `source_kind` distinguishes a
+direct `canonical_plan` from `spss_syntax`. For a direct plan, the canonical
+JSON document is itself the source artifact, so its source hash equals the plan
+hash and `frontend_contract` is null. SPSS applies record the normalized
+syntax hash and SPSS frontend contract.
+
+## Package layout
+
+The intended boundary is:
+
+```text
+openstatspec
+├── transform
+│   ├── plan.py
+│   ├── schema.py
+│   ├── validation.py
+│   └── errors.py
+└── frontends
+    ├── spss
+    │   ├── syntax.py
+    │   ├── binding.py
+    │   ├── compiler.py
+    │   └── execution.py
+    ├── stata       # empty placeholder; not implemented
+    └── sas         # empty placeholder; not implemented
+```
+
+Current imports from `openstatspec` and `openstatspec.transform` remain
+compatibility contracts if implementation files move. Stata and SAS provide no
+parser, compiler, apply API, CLI choice, or support claim.
+
+## Extension guidance
+
+There is no plugin discovery or Python entry-point protocol. A future built-in
+frontend must parse with source spans, bind against `VariableSchema` without
+database access, emit only canonical operations, produce deterministic hashes,
+share the generic validator/executor, and add specification-owned conformance
+fixtures.
+
+An external plugin protocol should be added only for a real external frontend.
+It would need explicit identity, contract compatibility, deterministic
+compilation, capabilities, stable error semantics, and a trust policy.
+
+Transformation conformance covers canonical plan fixtures, strict invalid-plan
+cases, frontend source/plan hashes and diagnostics, wrapper-to-plan equivalence,
+preflight-before-mutation, dataset/table identity, metadata and audit rows, CLI
+compatibility, and service evidence before database execution support is
+claimed. Stata and SAS need their own fixtures and implementations before their
+placeholder status can change.

{openstatspec-0.3.0 → openstatspec-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openstatspec"
-version = "0.3.0"
+version = "0.4.0"
 description = "Reference adapter for the OpenStatSpec relational contract"
 readme = "README.md"
 requires-python = ">=3.11"

{openstatspec-0.3.0 → openstatspec-0.4.0}/src/openstatspec/__init__.py

@@ -1,7 +1,8 @@
 """Public API for the OpenStatSpec Python reference implementation."""
 
 from .api import (
-    apply_spss_in_place, capabilities, capability_matrix, derive_sql_dataset,
+    apply_spss_in_place, apply_transformation_plan_in_place,
+    capabilities, capability_matrix, derive_sql_dataset,
     execute_sql_transformation,
     export_sav, get_dataset, import_sav, inspect,
     install_in_place_transformation_schema, list_datasets,
@@ -11,17 +12,24 @@ from .api import (
 )
 from .core import CapabilityDeclaration, LossReport, UnsupportedOperationError
 from .sql.workflow import TransformationError
+from .frontends.spss import SpssFrontendCompilation, compile_spss_syntax
 from .transform import (
-    SpssFrontendCompilation, TransformationFrontendError,
-    VariableDefinition, VariableSchema, compile_spss_syntax,
+    RecodeMatch, RecodeOperation, RecodeResult, RecodeRule,
+    ReplaceValueLabelsOperation, SetVariableLabelOperation,
+    TransformationFrontendError, TransformationPlan, TypedValue, ValueLabel,
+    VariableDefinition, VariableSchema, transformation_plan_from_dict,
 )
 
 __all__ = [
     "CapabilityDeclaration", "LossReport", "SpssFrontendCompilation",
     "TransformationError", "TransformationFrontendError",
-    "VariableDefinition", "VariableSchema",
+    "RecodeMatch", "RecodeOperation", "RecodeResult", "RecodeRule",
+    "ReplaceValueLabelsOperation", "SetVariableLabelOperation",
+    "TransformationPlan", "TypedValue", "ValueLabel",
+    "VariableDefinition", "VariableSchema", "transformation_plan_from_dict",
     "UnsupportedOperationError", "capabilities", "capability_matrix",
-    "apply_spss_in_place", "compile_spss_syntax", "derive_sql_dataset",
+    "apply_spss_in_place", "apply_transformation_plan_in_place",
+    "compile_spss_syntax", "derive_sql_dataset",
     "execute_sql_transformation", "export_sav",
     "get_dataset", "import_sav", "inspect",
     "install_in_place_transformation_schema", "list_datasets",

{openstatspec-0.3.0 → openstatspec-0.4.0}/src/openstatspec/api.py

@@ -20,11 +20,13 @@ from .sql.workflow import (
     remove_derived_relation as _remove_derived_relation,
     retire_derived_dataset as _retire_derived_dataset,
 )
+from .frontends.spss.execution import apply_spss_in_place as _apply_spss_in_place
 from .sql.inplace_transform import (
-    apply_spss_in_place as _apply_spss_in_place,
+    apply_transformation_plan_in_place as _apply_transformation_plan_in_place,
     in_place_transformation_capabilities,
     install_in_place_transformation_schema as _install_in_place_schema,
 )
+from .transform import TransformationPlan
 from .sql.capabilities import (
     SPECIFICATION_COMMIT, SPECIFICATION_RELEASE, active_connection, catalog_binding,
 )
@@ -154,6 +156,23 @@ def apply_spss_in_place(
     ))
 
 
+def apply_transformation_plan_in_place(
+    *, database_url: Any, dataset_id: str,
+    plan: TransformationPlan | Mapping[str, Any],
+    actor: str, expected_branch: str | None = None,
+    expected_head: str | None = None,
+) -> Mapping[str, Any]:
+    """Apply a canonical plan to the same logical dataset and physical table."""
+    return result(_apply_transformation_plan_in_place(
+        database_url=str(database_url),
+        dataset_id=dataset_id,
+        plan=plan,
+        actor=actor,
+        expected_branch=expected_branch,
+        expected_head=expected_head,
+    ))
+
+
 def install_in_place_transformation_schema(*, database_url: Any) -> None:
     """Install the compact apply-audit relation before the first apply."""
     _install_in_place_schema(database_url=str(database_url))

{openstatspec-0.3.0 → openstatspec-0.4.0}/src/openstatspec/cli.py

@@ -5,10 +5,12 @@ from collections.abc import Sequence
 from pathlib import Path
 
 from .api import (
-    apply_spss_in_place, capability_matrix, derive_sql_dataset,
+    apply_spss_in_place, apply_transformation_plan_in_place,
+    capability_matrix, derive_sql_dataset,
     execute_sql_transformation,
     export_sav, get_dataset, import_sav, inspect, list_datasets,
-    register_sql_transformation, validate, validate_derived,
+    install_in_place_transformation_schema, register_sql_transformation,
+    validate, validate_derived,
 )
 
 
@@ -77,7 +79,7 @@ def main(argv: Sequence[str] | None = None) -> int:
 
     apply_spss = commands.add_parser(
         "apply-spss",
-        help="apply supported SPSS syntax in-place on a controlled Dolt branch",
+        help="compile supported SPSS syntax and apply it in-place",
     )
     apply_spss.add_argument("--database-url", required=True)
     apply_spss.add_argument("--dataset-id", required=True)
@@ -88,6 +90,23 @@ def main(argv: Sequence[str] | None = None) -> int:
     syntax_source.add_argument("--syntax")
     syntax_source.add_argument("--syntax-file")
 
+    apply_plan = commands.add_parser(
+        "apply-plan",
+        help="apply a canonical transformation plan in-place",
+    )
+    apply_plan.add_argument("--database-url", required=True)
+    apply_plan.add_argument("--dataset-id", required=True)
+    apply_plan.add_argument("--actor", required=True)
+    apply_plan.add_argument("--expected-branch")
+    apply_plan.add_argument("--expected-head")
+    apply_plan.add_argument("--plan-file", required=True)
+
+    install_in_place = commands.add_parser(
+        "install-in-place-schema",
+        help="install or upgrade the compact in-place apply audit schema",
+    )
+    install_in_place.add_argument("--database-url", required=True)
+
     derived_validator = commands.add_parser("validate-derived", help="validate a derived dataset")
     derived_validator.add_argument("--database-url", required=True)
     derived_validator.add_argument("--derived-dataset-id", required=True)
@@ -151,6 +170,19 @@ def main(argv: Sequence[str] | None = None) -> int:
             expected_branch=args.expected_branch,
             expected_head=args.expected_head,
         )
+    elif args.command == "apply-plan":
+        plan = json.loads(Path(args.plan_file).read_text(encoding="utf-8"))
+        output = apply_transformation_plan_in_place(
+            database_url=args.database_url,
+            dataset_id=args.dataset_id,
+            plan=plan,
+            actor=args.actor,
+            expected_branch=args.expected_branch,
+            expected_head=args.expected_head,
+        )
+    elif args.command == "install-in-place-schema":
+        install_in_place_transformation_schema(database_url=args.database_url)
+        output = {"status": "installed"}
     else:
         output = validate_derived(
             database_url=args.database_url, derived_dataset_id=args.derived_dataset_id,

openstatspec-0.4.0/src/openstatspec/frontends/__init__.py

@@ -0,0 +1 @@
+"""Syntax frontends that lower external languages to canonical plans."""

openstatspec-0.4.0/src/openstatspec/frontends/spss/__init__.py

@@ -0,0 +1,26 @@
+"""SPSS syntax frontend for canonical OpenStatSpec transformation plans."""
+
+from .binding import bind_spss_syntax
+from .compiler import SpssFrontendCompilation, compile_spss_syntax
+from .syntax import (
+    SpssSyntaxProgram,
+    normalize_spss_source,
+    parse_spss_syntax,
+    spss_source_hash,
+    tokenize_spss,
+)
+
+
+SPSS_FRONTEND_CONTRACT = "openstatspec-spss-syntax-frontend-v0.1"
+
+__all__ = [
+    "SPSS_FRONTEND_CONTRACT",
+    "SpssFrontendCompilation",
+    "SpssSyntaxProgram",
+    "bind_spss_syntax",
+    "compile_spss_syntax",
+    "normalize_spss_source",
+    "parse_spss_syntax",
+    "spss_source_hash",
+    "tokenize_spss",
+]