umf-codegen 0.10.8__py3-none-any.whl

umf_codegen/__init__.py

@@ -0,0 +1,198 @@
+# SPDX-License-Identifier: MIT OR Apache-2.0
+"""Generate the same typed Python client as UMF's portable TypeScript API."""
+from __future__ import annotations
+
+from typing import Literal, TypedDict, cast
+
+from ._native import GenerationError, execute
+
+__version__ = "0.10.8"
+
+
+class RecordSelection(TypedDict):
+    module: str
+    element: str
+
+
+class ActionSelection(TypedDict):
+    module: str
+    action: str
+
+
+class GeneratedFile(TypedDict):
+    path: str
+    text: str
+    sha256: str
+
+
+class PythonClientResult(TypedDict):
+    sourceDigest: str
+    description: dict[str, object]
+    files: list[GeneratedFile]
+
+
+class TableDeploymentConfiguration(TypedDict):
+    module: str
+    schema: str
+    ownerRole: str
+    personRole: str
+    batchRole: str
+    groupRoles: dict[str, str]
+
+
+class TableDeploymentDiagnostic(TypedDict):
+    code: str
+    path: str
+    message: str
+    severity: str
+
+
+class CompiledTableDeployment(TypedDict):
+    status: Literal["compiled"]
+    bundle: dict[str, object]
+    diagnostics: list[TableDeploymentDiagnostic]
+
+
+class BlockedTableDeployment(TypedDict):
+    status: Literal["blocked"]
+    diagnostics: list[TableDeploymentDiagnostic]
+
+
+class TableMigrationPredecessor(TypedDict):
+    id: str
+    digest: str
+
+
+class CompiledTableMigration(TypedDict):
+    status: Literal["compiled"]
+    plan: dict[str, object]
+    diagnostics: list[TableDeploymentDiagnostic]
+
+
+class BlockedTableMigration(TypedDict):
+    status: Literal["blocked"]
+    diagnostics: list[TableDeploymentDiagnostic]
+
+
+class ReviewedChangeCandidate(TypedDict):
+    id: str
+    kind: str
+    path: str
+    oldDigest: str
+    newDigest: str
+    oldValue: object
+    newValue: object
+
+
+class TableMigrationDiscoveryOptions(TypedDict):
+    version: Literal["umf.table-migration-discovery/0.2"]
+
+
+def compile_table_migration(*, migration_id: str, predecessor: TableMigrationPredecessor | None,
+                            previous_bundle: dict[str, object] | None, next_bundle: dict[str, object],
+                            options: dict[str, object] | None = None,
+                            timeout_seconds: float = 30) -> CompiledTableMigration | BlockedTableMigration:
+    """Compile an inert forward plan; native ledger and approval remain required."""
+    return cast(CompiledTableMigration | BlockedTableMigration,
+                execute({"id": migration_id, "predecessor": predecessor,
+                         "previous": previous_bundle, "next": next_bundle,
+                         **({"options": options} if options is not None else {})},
+                        timeout_seconds, operation="migration"))
+
+
+def verify_table_migration(plan: dict[str, object], *, timeout_seconds: float = 30) -> dict[str, object]:
+    """Recompile a complete plan; consistency cannot authenticate native history."""
+    return execute({"plan": plan}, timeout_seconds, operation="verify_migration")
+
+
+def discover_table_migration_changes(previous_bundle: dict[str, object], next_bundle: dict[str, object],
+                                     *, options: TableMigrationDiscoveryOptions | None = None,
+                                     timeout_seconds: float = 30) -> list[ReviewedChangeCandidate]:
+    """Discover exact source-bound review candidates from two verified deployment bundles.
+
+    Returned values explain each delta. Copy only id, kind, path, oldDigest and
+    newDigest into `reviewedChanges`; a supported type conversion must also be
+    selected explicitly as `pg-cast-v1`.
+    Omitting `options`, or passing `None`, retains the historical discovery
+    profile. G03 candidates require the explicit discovery 0.2 selector.
+    """
+    request = {"previous": previous_bundle, "next": next_bundle}
+    if options is not None:
+        request["options"] = options
+    result = execute(request, timeout_seconds,
+                     operation="discover_changes")
+    changes = result.get("changes")
+    if not isinstance(changes, list) or any(not isinstance(item, dict) for item in changes):
+        raise GenerationError("PAYLOAD_INVALID", "Embedded compiler returned invalid reviewed changes")
+    return cast(list[ReviewedChangeCandidate], changes)
+
+
+def compile_table_deployment(text: str, *, configuration: TableDeploymentConfiguration,
+                             format: Literal["json", "yaml"] = "json", timeout_seconds: float = 30
+                             ) -> CompiledTableDeployment | BlockedTableDeployment:
+    """Compile inert initial DDL using UMF's original portable implementation."""
+    return cast(CompiledTableDeployment | BlockedTableDeployment,
+                execute({"text": text, "format": format, "configuration": configuration},
+                        timeout_seconds, operation="deployment"))
+
+
+def verify_table_deployment(bundle: dict[str, object], *, timeout_seconds: float = 30) -> dict[str, object]:
+    """Recompile a bundle; hosts must additionally verify their trusted digest."""
+    return execute({"bundle": bundle}, timeout_seconds, operation="verify_deployment")
+
+
+def normalize_row_scope(input: dict[str, object], *, context: dict[str, object],
+                        timeout_seconds: float = 30) -> dict[str, object]:
+    """Normalize row_scope with exact host bindings and lifecycle/native admission."""
+    return execute({"input": input, "context": context}, timeout_seconds, operation="row_scope")
+
+
+def generate_python_client(text: str, *, package: str, format: Literal["json", "yaml"] = "json",
+                           records: list[RecordSelection] | None = None,
+                           actions: list[ActionSelection] | None = None,
+                           timeout_seconds: float = 30) -> PythonClientResult:
+    request: dict[str, object] = {"text": text, "package": package, "format": format}
+    if records is not None:
+        request["records"] = records
+    if actions is not None:
+        request["actions"] = actions
+    return cast(PythonClientResult, execute(request, timeout_seconds))
+
+
+def generate_pack_tools(request: dict[str, object], *, timeout_seconds: float = 30) -> dict[str, object]:
+    """Compile the complete ``umf.pack-tools/1`` request through pinned Rust.
+
+    The result's generated, partial, and blocked statuses are ordinary compiler
+    outcomes. This wrapper preserves the request and result profiles and adds
+    no source parsing or generation behavior in Python.
+    """
+    if type(request) is not dict:
+        raise TypeError("request must be a dict")
+    return execute(request, timeout_seconds, operation="pack_tools")
+
+
+__all__ = [
+    "ActionSelection",
+    "BlockedTableDeployment",
+    "BlockedTableMigration",
+    "CompiledTableDeployment",
+    "CompiledTableMigration",
+    "GeneratedFile",
+    "GenerationError",
+    "PythonClientResult",
+    "RecordSelection",
+    "ReviewedChangeCandidate",
+    "TableDeploymentConfiguration",
+    "TableDeploymentDiagnostic",
+    "TableMigrationDiscoveryOptions",
+    "TableMigrationPredecessor",
+    "__version__",
+    "compile_table_deployment",
+    "compile_table_migration",
+    "discover_table_migration_changes",
+    "generate_python_client",
+    "generate_pack_tools",
+    "normalize_row_scope",
+    "verify_table_deployment",
+    "verify_table_migration",
+]

umf_codegen/__main__.py

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: MIT OR Apache-2.0
+"""Installed generate/check CLI. No executable discovery or external JS process."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import generate_python_client
+from ._writer import check_package, write_package
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="umf-codegen", allow_abbrev=False)
+    parser.add_argument("command", choices=("generate", "check"))
+    parser.add_argument("--schema", required=True, type=Path)
+    parser.add_argument("--package", required=True)
+    parser.add_argument("--output", required=True, type=Path)
+    argv = sys.argv[1:] if argv is None else argv
+    for flag in ("--schema", "--package", "--output"):
+        if sum(item.split("=", 1)[0] == flag for item in argv) > 1:
+            parser.error("option may only appear once: " + flag)
+    args = parser.parse_args(argv)
+    try:
+        result = generate_python_client(args.schema.read_bytes().decode("utf-8"), package=args.package,
+                                        format="yaml" if args.schema.suffix.lower() in (".yaml", ".yml") else "json")
+        if args.command == "check":
+            differences = check_package(args.output, result)
+            for path in differences:
+                print(path, file=sys.stderr)
+            return int(bool(differences))
+        write_package(args.output, result)
+        print(json.dumps({"package": args.package, "sourceDigest": result["sourceDigest"], "files": len(result["files"])}))
+        return 0
+    except Exception as error:  # noqa: BLE001 -- sanitize errors at the CLI process boundary
+        response = {"code": getattr(error, "code", "GENERATION_FAILED"), "message": str(error)}
+        for name in ("path", "written", "recovery"):
+            value = getattr(error, name, None)
+            if value is not None:
+                response[name] = value
+        print(json.dumps(response), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

umf_codegen/_embedded.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: MIT OR Apache-2.0
+"""Compatibility import for callers of the former private bridge module."""