serverless-data-mesh 0.2.0__py3-none-any.whl

serverless_data_mesh/verification/fallback.py

@@ -0,0 +1,200 @@
+"""Pure-Python multiset verifier when veridata-recon wheels are unavailable."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import uuid
+from collections import Counter
+from datetime import datetime, timezone
+from typing import Any
+
+from serverless_data_mesh.types.workload import DataWriteWorkload
+
+
+def _coerce_records(records: list[dict[str, Any]]) -> list[dict[str, str]]:
+    return [{key: str(value) for key, value in record.items()} for record in records]
+
+
+def _identity_rule(fields: tuple[str, ...]) -> str:
+    if len(fields) == 1:
+        return f"field:{fields[0]}"
+    return f"composite:[{','.join(fields)}]"
+
+
+def _record_fingerprint(
+    record: dict[str, str],
+    *,
+    identity_fields: tuple[str, ...],
+    content_fields: tuple[str, ...],
+    salt: str,
+) -> str:
+    identity = "|".join(record.get(f, "") for f in identity_fields)
+    content = "|".join(record.get(f, "") for f in content_fields)
+    payload = f"{salt}:{identity}:{content}".encode()
+    return hashlib.sha256(payload).hexdigest()
+
+
+def reconcile_multiset(
+    *,
+    source: list[dict[str, Any]],
+    sink: list[dict[str, Any]],
+    identity_fields: tuple[str, ...],
+    content_fields: tuple[str, ...],
+    salt: str = "sdm-fallback-salt",
+) -> dict[str, Any]:
+    """Compare source and sink multisets; same verdict shape as veridata-recon."""
+    src = _coerce_records(source)
+    snk = _coerce_records(sink)
+
+    src_fps = [
+        _record_fingerprint(
+            row,
+            identity_fields=identity_fields,
+            content_fields=content_fields,
+            salt=salt,
+        )
+        for row in src
+    ]
+    snk_fps = [
+        _record_fingerprint(
+            row,
+            identity_fields=identity_fields,
+            content_fields=content_fields,
+            salt=salt,
+        )
+        for row in snk
+    ]
+
+    src_counter = Counter(src_fps)
+    snk_counter = Counter(snk_fps)
+
+    missing: list[str] = []
+    duplicated: list[str] = []
+    mutated: list[str] = []
+
+    all_keys = set(src_counter) | set(snk_counter)
+    for key in sorted(all_keys):
+        src_n = src_counter.get(key, 0)
+        snk_n = snk_counter.get(key, 0)
+        if snk_n < src_n:
+            missing.extend([key] * (src_n - snk_n))
+        if snk_n > src_n:
+            duplicated.extend([key] * (snk_n - src_n))
+
+    # Mutation: same identity, different content fingerprint in sink vs source
+    if identity_fields:
+        src_by_id: dict[str, str] = {}
+        snk_by_id: dict[str, str] = {}
+        for row in src:
+            ident = "|".join(row.get(f, "") for f in identity_fields)
+            fp = _record_fingerprint(
+                row,
+                identity_fields=identity_fields,
+                content_fields=content_fields,
+                salt=salt,
+            )
+            src_by_id[ident] = fp
+        for row in snk:
+            ident = "|".join(row.get(f, "") for f in identity_fields)
+            fp = _record_fingerprint(
+                row,
+                identity_fields=identity_fields,
+                content_fields=content_fields,
+                salt=salt,
+            )
+            snk_by_id[ident] = fp
+        for ident, src_fp in src_by_id.items():
+            snk_fp = snk_by_id.get(ident)
+            if snk_fp is not None and snk_fp != src_fp:
+                mutated.append(ident)
+
+    verdict = "PASS" if not missing and not duplicated and not mutated else "FAIL"
+    return {
+        "verdict": verdict,
+        "missing": missing[:100],
+        "duplicated": duplicated[:100],
+        "mutated": mutated[:100],
+        "source_count": len(src),
+        "sink_count": len(snk),
+        "backend": "pure-python-fallback",
+    }
+
+
+class FallbackProofGenerator:
+    """Drop-in proof generator using pure-Python multiset reconciliation."""
+
+    producer: str = "serverless-data-mesh/fallback-verifier"
+
+    def __init__(self, *, salt_hex: str | None = None) -> None:
+        self.salt_hex = salt_hex or uuid.uuid4().hex
+
+    def build_proof(
+        self,
+        *,
+        source_records: list[dict[str, Any]],
+        sink_records: list[dict[str, Any]],
+        workload: DataWriteWorkload,
+        chunk_start: int,
+        chunk_end: int,
+        prev_proof_hash: str | None = None,
+    ) -> dict[str, Any]:
+        reconciliation = reconcile_multiset(
+            source=source_records,
+            sink=sink_records,
+            identity_fields=workload.identity_fields,
+            content_fields=workload.content_fields,
+            salt=self.salt_hex,
+        )
+        boundary_value = base64.b64encode(
+            json.dumps(
+                {
+                    "workload_id": workload.workload_id,
+                    "domain_id": workload.boundary.domain_id,
+                    "start": chunk_start,
+                    "end": chunk_end,
+                    "partition": workload.boundary.partition_spec,
+                },
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode()
+        ).decode("ascii")
+
+        document: dict[str, Any] = {
+            "proof_version": "0.1-fallback",
+            "created_at": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+            "producer": self.producer,
+            "boundary": {"mode": "OFFSET_RANGE", "value": boundary_value},
+            "source_ref": workload.source_uri,
+            "sink_ref": workload.target_uri,
+            "hash_algorithm": "sha256",
+            "salt": self.salt_hex,
+            "identity_rule": _identity_rule(workload.identity_fields),
+            "content_fields": list(workload.content_fields),
+            "reconciliation": reconciliation,
+            "public_key": None,
+            "chain": {"prev_proof_hash": prev_proof_hash},
+        }
+        document["proof_id"] = hashlib.sha256(
+            json.dumps(document, separators=(",", ":"), sort_keys=True).encode()
+        ).hexdigest()
+        return document
+
+    def persist_proof(
+        self,
+        proof: dict[str, Any],
+        *,
+        bucket: str,
+        key_prefix: str,
+        chunk_index: int,
+        s3_client: Any | None = None,
+    ) -> str:
+        from pathlib import Path
+
+        root = Path(bucket)
+        rel = f"{key_prefix.rstrip('/')}/proofs/chunk-{chunk_index:06d}.vrp.json"
+        dest = root / rel
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(json.dumps(proof, indent=2, sort_keys=True), encoding="utf-8")
+        return f"file://{dest}"

serverless_data_mesh/verification/vrp.py

@@ -0,0 +1,202 @@
+"""Cryptographic verification via veridata-recon (VRP v0.1)."""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import os
+import tempfile
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+import boto3
+
+from serverless_data_mesh.types.workload import DataWriteWorkload
+
+logger = logging.getLogger(__name__)
+
+
+def _vr() -> Any:
+    try:
+        import veridata_recon as vr
+
+        return vr
+    except ImportError as exc:
+        msg = (
+            "veridata-recon is required for VRPProofGenerator. "
+            "Use create_proof_generator() for automatic fallback, or "
+            "pip install veridata-recon (Python 3.12+, Linux/macOS wheels)."
+        )
+        raise ImportError(msg) from exc
+
+
+@dataclass(frozen=True, slots=True)
+class VerifyResult:
+    """Outcome of a validate-then-commit reconciliation check."""
+
+    outcome: str
+    reason: str | None = None
+
+
+ValidateResult = VerifyResult
+
+
+def _identity_rule(fields: tuple[str, ...]) -> str:
+    if len(fields) == 1:
+        return f"field:{fields[0]}"
+    return f"composite:[{','.join(fields)}]"
+
+
+def _coerce_records(records: list[dict[str, Any]]) -> list[dict[str, str]]:
+    """veridata-recon requires string field values for canonical hashing."""
+    return [{key: str(value) for key, value in record.items()} for record in records]
+
+
+@dataclass(slots=True)
+class VRPProofGenerator:
+    """Generate offline, tamper-evident reconciliation proofs for pipeline chunks."""
+
+    private_key_b64: str
+    public_key_b64: str
+    salt_hex: str
+    producer: str = "serverless-data-mesh/0.1.0"
+
+    @classmethod
+    def from_env(cls) -> VRPProofGenerator:
+        """Load signing keys from ``VRP_SIGNING_KEY_B64`` or generate ephemeral ones."""
+        raw = os.environ.get("VRP_SIGNING_KEY_B64")
+        vr = _vr()
+        if raw:
+            keys = vr.keypair_from_private(raw)
+        else:
+            keys = vr.generate_keypair()
+        return cls(
+            private_key_b64=keys["private_key"],
+            public_key_b64=keys["public_key"],
+            salt_hex=vr.generate_salt(),
+        )
+
+    def build_proof(
+        self,
+        *,
+        source_records: list[dict[str, Any]],
+        sink_records: list[dict[str, Any]],
+        workload: DataWriteWorkload,
+        chunk_start: int,
+        chunk_end: int,
+        prev_proof_hash: str | None = None,
+    ) -> dict[str, Any]:
+        """Hash and compare source vs target partition, returning a proof envelope."""
+        vr = _vr()
+        identity_rule = _identity_rule(workload.identity_fields)
+        content_fields = list(workload.content_fields)
+
+        reconciliation = vr.reconcile(
+            source=_coerce_records(source_records),
+            sink=_coerce_records(sink_records),
+            identity_rule=identity_rule,
+            content_fields=content_fields,
+            salt=self.salt_hex,
+        )
+
+        boundary_value = base64.b64encode(
+            json.dumps(
+                {
+                    "workload_id": workload.workload_id,
+                    "domain_id": workload.boundary.domain_id,
+                    "start": chunk_start,
+                    "end": chunk_end,
+                    "partition": workload.boundary.partition_spec,
+                },
+                separators=(",", ":"),
+                sort_keys=True,
+            ).encode()
+        ).decode("ascii")
+
+        document: dict[str, Any] = {
+            "proof_version": "0.1",
+            "created_at": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+            "producer": self.producer,
+            "boundary": {"mode": "OFFSET_RANGE", "value": boundary_value},
+            "source_ref": workload.source_uri,
+            "sink_ref": workload.target_uri,
+            "hash_algorithm": "sha256",
+            "salt": self.salt_hex,
+            "identity_rule": identity_rule,
+            "content_fields": content_fields,
+            "reconciliation": reconciliation,
+            "public_key": self.public_key_b64,
+            "chain": {"prev_proof_hash": prev_proof_hash},
+        }
+        document["proof_id"] = vr.hash_bytes(
+            json.dumps(document, separators=(",", ":"), sort_keys=True).encode("utf-8")
+        )
+        return document
+
+    def persist_proof(
+        self,
+        proof: dict[str, Any],
+        *,
+        bucket: str,
+        key_prefix: str,
+        chunk_index: int,
+        s3_client: Any | None = None,
+    ) -> str:
+        """Write the reconciliation proof JSON alongside IceGuard Parquet artifacts."""
+        client = s3_client or boto3.client("s3")
+        key = f"{key_prefix.rstrip('/')}/proofs/chunk-{chunk_index:06d}.vrp.json"
+        body = json.dumps(proof, indent=2, sort_keys=True).encode("utf-8")
+        verdict = proof["reconciliation"]["verdict"]
+        client.put_object(
+            Bucket=bucket,
+            Key=key,
+            Body=body,
+            ContentType="application/json",
+            Metadata={"proof-id": proof["proof_id"], "verdict": verdict},
+        )
+        uri = f"s3://{bucket}/{key}"
+        logger.info("Persisted VRP proof to %s (verdict=%s)", uri, verdict)
+        return uri
+
+
+def validate_then_commit(
+    proof: dict[str, Any],
+    *,
+    public_key_b64: str | None = None,
+) -> VerifyResult:
+    """Validate-then-commit hook: verify reconciliation before metadata commit."""
+    verdict = proof["reconciliation"]["verdict"]
+    if verdict == "PASS":
+        return VerifyResult("PASS")
+
+    missing = len(proof["reconciliation"].get("missing", []))
+    mutated = len(proof["reconciliation"].get("mutated", []))
+    duplicated = len(proof["reconciliation"].get("duplicated", []))
+    reason = (
+        f"reconciliation {verdict}: missing={missing}, "
+        f"mutated={mutated}, duplicated={duplicated}"
+    )
+    logger.error("VRP validation blocked metadata commit: %s", reason)
+
+    pubkey = public_key_b64 or proof.get("public_key")
+    if pubkey:
+        try:
+            vr = _vr()
+            with tempfile.NamedTemporaryFile(
+                mode="w",
+                suffix=".vrp.json",
+                delete=False,
+                encoding="utf-8",
+            ) as handle:
+                json.dump(proof, handle, indent=2, sort_keys=True)
+                temp_path = handle.name
+            offline = vr.verify_proof(temp_path, pubkey)
+            os.unlink(temp_path)
+            if offline != verdict:
+                reason = f"{reason}; offline_verify={offline}"
+        except Exception as exc:
+            logger.warning("Offline veridata-recon verify_proof skipped: %s", exc)
+
+    return VerifyResult(verdict, reason)

serverless_data_mesh-0.2.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: serverless-data-mesh
+Version: 0.2.0
+Summary: Federated data mesh framework for proof-gated, exactly-once Iceberg data product publication on AWS Lambda.
+Project-URL: Homepage, https://github.com/vaquarkhan/aws-serverless-datamesh-framework
+Project-URL: Documentation, https://github.com/vaquarkhan/aws-serverless-datamesh-framework#readme
+Project-URL: Repository, https://github.com/vaquarkhan/aws-serverless-datamesh-framework
+Project-URL: Changelog, https://github.com/vaquarkhan/aws-serverless-datamesh-framework/blob/main/CHANGELOG.md
+Project-URL: PyPI, https://pypi.org/project/serverless-data-mesh/
+Author: Serverless Data Mesh Contributors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: aws,data-as-a-product,data-mesh,domain-oriented,durable-execution,federated-data-mesh,federated-governance,iceberg,iceguard,lakehouse,lambda,pyiceberg,rule-engine,serverless,sparkrules,vaquar-pattern,veridata-recon
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aws-durable-execution-sdk-python>=1.0.0
+Requires-Dist: boto3>=1.34
+Requires-Dist: iceguard>=1.0.0
+Requires-Dist: pyiceberg[glue,rest-sigv4]>=0.7.0
+Requires-Dist: veridata-recon>=0.1.0
+Provides-Extra: all
+Requires-Dist: pyspark>=3.5.0; extra == 'all'
+Requires-Dist: sparkrules>=1.2.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pre-commit>=4; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Provides-Extra: publish
+Requires-Dist: build>=1.2; extra == 'publish'
+Requires-Dist: twine>=5; extra == 'publish'
+Provides-Extra: rules
+Requires-Dist: sparkrules>=1.2.0; extra == 'rules'
+Provides-Extra: spark
+Requires-Dist: pyspark>=3.5.0; extra == 'spark'
+Requires-Dist: sparkrules>=1.2.0; extra == 'spark'
+Description-Content-Type: text/markdown
+
+# Serverless Data Mesh
+
+**Federated data mesh lakehouse publication on AWS Lambda - with cryptographic proof, not just green job logs.**
+
+An open Python framework for **domain-oriented**, **federated data mesh** teams on AWS. Implements **data as a product**, **self-serve write infrastructure**, and **federated computational governance** at the Iceberg lakehouse layer.
+
+- **Producer** domains publish governed **data products**
+- **Steward** notaries enforce mesh contracts with VRP proofs
+- **Publisher** zones expose consumer-ready **Iceberg data products**
+
+Introduces the **[Vaquar Pattern](https://github.com/vaquarkhan/aws-serverless-datamesh-framework/blob/main/docs/vaquar-pattern.md)** (PVDM): Physical → Verify → Durable → Metadata. Invariant: `commit_metadata ⟹ VRP = PASS`.
+
+## Install
+
+```bash
+pip install serverless-data-mesh
+serverless-data-mesh demo    # <60s local PVDM demo, no AWS
+pip install "serverless-data-mesh[rules]"   # + SparkRules on Lambda
+pip install "serverless-data-mesh[spark]"   # + PySpark + SparkRules
+pip install "serverless-data-mesh[all]"     # rules + spark
+pip install "serverless-data-mesh[dev]"     # pytest, ruff, pre-commit
+```
+
+**Works on **Windows, Mac, and Linux**. Uses veridata-recon cryptographic VRP when wheels are available; **pure-Python fallback** otherwise (same PASS/FAIL gate).**
+
+## What it solves
+
+| Problem | Answer |
+|---------|--------|
+| Silent data loss on backfill | VRP `FAIL` blocks Iceberg snapshot |
+| "Job succeeded" is not proof | Cryptographic multiset proof per chunk |
+| Lambda 15-minute limit | Durable Execution + Step Functions (90+ min) |
+| Retry duplicates data | IceGuard rollback + `workload_id` checkpoints |
+| Central ETL bottleneck | Per-domain Lambda writer + transaction boundary |
+| Federated blast radius | Producer · Steward · Publisher accounts |
+
+## Building blocks
+
+| Package | Role |
+|---------|------|
+| [iceguard](https://pypi.org/project/iceguard/) | Physical SafeWriter, timeout rollback, S3 resume |
+| [veridata-recon](https://pypi.org/project/veridata-recon/) | VRP proof generation and validation |
+| [aws-durable-execution-sdk-python](https://pypi.org/project/aws-durable-execution-sdk-python/) | Cross-invocation step replay |
+| [pyiceberg](https://pypi.org/project/pyiceberg/) | Glue Iceberg REST metadata via `GlueCatalogConnector` |
+| [sparkrules](https://pypi.org/project/sparkrules/) | Optional DRL business rules (`[rules]` extra) |
+
+## Quick example
+
+```python
+from serverless_data_mesh import (
+    IceGuardDurableCoordinator,
+    DomainTransactionBoundary,
+    VRPProofGenerator,
+)
+
+boundary = DomainTransactionBoundary(
+    domain_id="orders-domain",
+    source_namespace="raw_orders",
+    target_table="orders_curated",
+    partition_spec={"dt": "2026-06-14"},
+)
+
+coordinator = IceGuardDurableCoordinator(
+    durable_context=durable_ctx,
+    lambda_context=lambda_ctx,
+    proof_generator=VRPProofGenerator(),
+    catalog_adapter=glue_adapter,
+)
+outcome = coordinator.run_workload(workload)
+```
+
+## Optional extras
+
+| Extra | Adds |
+|-------|------|
+| `rules` | SparkRules DRL on Lambda |
+| `spark` | PySpark + SparkRules |
+| `all` | `rules` + `spark` |
+| `dev` | pytest, ruff, mypy, pre-commit |
+| `publish` | build, twine |
+
+## Documentation
+
+- [GitHub README](https://github.com/vaquarkhan/aws-serverless-datamesh-framework#readme)
+- [Vaquar Pattern](https://github.com/vaquarkhan/aws-serverless-datamesh-framework/blob/main/docs/vaquar-pattern.md)
+- [Getting started](https://github.com/vaquarkhan/aws-serverless-datamesh-framework/blob/main/docs/getting-started.md)
+- [PyPI guide](https://github.com/vaquarkhan/aws-serverless-datamesh-framework/blob/main/docs/pypi.md)
+- [Full documentation](https://github.com/vaquarkhan/aws-serverless-datamesh-framework/tree/main/docs)
+
+## License
+
+Apache-2.0

serverless_data_mesh-0.2.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+serverless_data_mesh/__init__.py,sha256=FZjdbKzWnsjXoLwC1Y5gvRVU2zCUYamqlQHulVyKjvM,2893
+serverless_data_mesh/cli.py,sha256=Ui1gaaNEAcCYRGIdI1BNa4LOVmpLjAbWF4jxIDzXg6c,6821
+serverless_data_mesh/config.py,sha256=SAIu88NV_cD6UgglCzenp8INJjvQtj5HCZBVDnBKFpg,1561
+serverless_data_mesh/exceptions.py,sha256=PhqfjsZtKIX_Q87GfsG1T09ds3Dhv5eS9FMJoNKCsRY,717
+serverless_data_mesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+serverless_data_mesh/catalog/__init__.py,sha256=CGzY2FK-biSn2mLoq2C7RhW1CTOdyvV25ht43DwuT3Y,278
+serverless_data_mesh/catalog/glue_connector.py,sha256=qXQ8xNirQKhMsMElb4aIgCnfZJxOQwExH_-2rN59srM,762
+serverless_data_mesh/catalog/glue_rest.py,sha256=8ZnBVpxYzSKxqppmBPHbFkdfWd6yVUxpNzgowt9aAOo,5217
+serverless_data_mesh/dashboard/__init__.py,sha256=wAKG7m8Ttiamrji1xGOMyNMc-rpCTuPudnlfuL5sab4,139
+serverless_data_mesh/dashboard/cloudwatch.py,sha256=Cozj4u0SdB1MLvoMmhsz3O7CAwL3DBJLeX8KMJULZ3E,2675
+serverless_data_mesh/dashboard/trust.py,sha256=jCZ-AIWFElZgFYsZfPEe3tNKf1MlbrP9y43U2MdrsP4,5582
+serverless_data_mesh/governance/__init__.py,sha256=fpue3dnoX3ejHxPBJ4uKbJM1nsgPfJkF8SvYt-ZyDEM,303
+serverless_data_mesh/governance/consumer_sla.py,sha256=_ToDdWvxqtdhC8hrr8Yt79TrSi2MWIPGYcofnT9CT9M,3475
+serverless_data_mesh/lineage/__init__.py,sha256=QveXUN3hAvcPnBwCp6vuzi-VWgF6q3nzIUaLEq2io10,178
+serverless_data_mesh/lineage/openlineage.py,sha256=y9704cnVWt5-pGCyGblwfy04omuvKRgTZrrtW0PV1ak,3125
+serverless_data_mesh/local/__init__.py,sha256=m9IQo8ChzXnK2sePE90Q3NW_zSTwgatNmE-Fp4GnfK0,197
+serverless_data_mesh/local/runtime.py,sha256=5NgpeqYcPYLNdKja_Pl96DbOPqE65pTjW8hFdH1izJY,14447
+serverless_data_mesh/metrics/__init__.py,sha256=eiExi2A4Q40FtHxd6flaeJ4p83CkVeHjVtA8Kv9-5O8,159
+serverless_data_mesh/metrics/mesh_trust.py,sha256=drWNVxHumYz-1uDS_uo5_x5bLe-vHWjvWXS5xXSFJRc,1530
+serverless_data_mesh/orchestration/__init__.py,sha256=igvZy4X8EXMS8fpAvYdnF1CCQuM68oFAfpxJHZqmlMc,900
+serverless_data_mesh/orchestration/canary.py,sha256=yGosZWu8GxVVPktw7FVChgMUA-4-4-FZLUTIWgh7AxY,4209
+serverless_data_mesh/orchestration/coordinator.py,sha256=hi29bUP7DEsV4K9O6v30PgbDc4F_LRgB2XdwwJmuGpI,11237
+serverless_data_mesh/orchestration/durable_steps.py,sha256=MKKYpeo_t-sHySVFf7ciLPKY6-9xRbGpP1wdRpmrGl4,2496
+serverless_data_mesh/orchestration/reprocess.py,sha256=ISJ4zwNGoBEPvR-cRiiRnxbC3SMz96U6SmxTuLydpaA,4599
+serverless_data_mesh/orchestration/state.py,sha256=SJa6KtaqV5Ik3RoP3tSyBQcmrmIP_mbOyfJR-D81uGQ,414
+serverless_data_mesh/rules/__init__.py,sha256=uBYdsx7FOTT9lbLjE4Gsdr2BBtFUiqAT15lhtg3kOn8,222
+serverless_data_mesh/rules/sparkrules_connector.py,sha256=AtRZBHvKPYW-1gwYZdy7zFfzNVbTh0wgUzWztiyq7cs,6858
+serverless_data_mesh/scaffold/__init__.py,sha256=lMgJiPbQmk1286pUXtxbDsVe9CI2gvCSX7-4VaY2L48,152
+serverless_data_mesh/scaffold/init_domain.py,sha256=Pg3mXGr8sc4ZcXhqeoMbhGgB9DXvOBfs4aCyS4QpG1w,5940
+serverless_data_mesh/types/__init__.py,sha256=Fjr6s4FbgdXy6I28hGc5z7OY9SzzU2wB2efsMpGCzqU,441
+serverless_data_mesh/types/workload.py,sha256=jBr3UAlcKWOdC4KsKL_Pn5jtyuDTRJ1SU2GJEgfSjFQ,3986
+serverless_data_mesh/verification/__init__.py,sha256=wywzfPwErYPSv41I98B4E01k3aRllhOOhuxP9rp96wE,619
+serverless_data_mesh/verification/backend.py,sha256=rmvpXNIzG5fUR2Tm1dF74Vmp2w5viIf4TNBVi09t5Yc,1175
+serverless_data_mesh/verification/fallback.py,sha256=f3Gh32E8D-F6GxuF8bpjb943_u0o-AHXuDoVNwXZLLI,6489
+serverless_data_mesh/verification/vrp.py,sha256=puxMNcST3zssZ61KPQ7pS0hWDNHIH9HrHeebSgKubQU,6660
+serverless_data_mesh-0.2.0.dist-info/METADATA,sha256=g8qYTlRJ1KFM2nwpy_sAZSZOTZvMkrVfe_3Tf_IB-e8,6312
+serverless_data_mesh-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+serverless_data_mesh-0.2.0.dist-info/entry_points.txt,sha256=1_fRcmiQPvr5xbO3aPnzHUyPCPsdsr6ICRs2NdwsG5E,71
+serverless_data_mesh-0.2.0.dist-info/licenses/LICENSE,sha256=aHcoSYkPQgkZb342Axbb4Gj0EMM7A_1wriqtBBC0MgQ,762
+serverless_data_mesh-0.2.0.dist-info/RECORD,,

serverless_data_mesh-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

serverless_data_mesh-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+serverless-data-mesh = serverless_data_mesh.cli:main

serverless_data_mesh-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Serverless Data Mesh Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.