constellation-node-sdk 1.0.1__py3-none-any.whl

constellation_node_sdk/transport/packet.py

@@ -0,0 +1,331 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+from uuid import uuid4
+
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
+
+from .errors import TransportIntegrityError
+from .hashing import compute_payload_hash, compute_transport_hash
+from .models import (
+    DelegationLink,
+    TransportAddress,
+    TransportAttachment,
+    TransportGovernance,
+    TransportHeader,
+    TransportHop,
+    TransportLineage,
+    TransportSecurity,
+    utc_now,
+)
+from .provenance import RoutingProvenance
+from .tenant import TenantContext, assert_tenant_immutable, ensure_tenant_context
+
+
+class TransportPacket(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    header: TransportHeader
+    address: TransportAddress
+    tenant: TenantContext
+    payload: dict[str, Any]
+    security: TransportSecurity
+    governance: TransportGovernance
+    provenance: RoutingProvenance
+    delegation_chain: tuple[DelegationLink, ...] = ()
+    hop_trace: tuple[TransportHop, ...] = ()
+    lineage: TransportLineage
+    attachments: tuple[TransportAttachment, ...] = ()
+
+    @field_validator("payload")
+    @classmethod
+    def validate_payload(cls, value: dict[str, Any]) -> dict[str, Any]:
+        if not isinstance(value, dict):
+            raise TypeError("payload must be a dict")
+        return value
+
+    @model_validator(mode="after")
+    def validate_integrity(self) -> TransportPacket:
+        expected_payload_hash = compute_payload_hash(self.payload)
+        if self.security.payload_hash != expected_payload_hash:
+            raise TransportIntegrityError("payload_hash does not match payload")
+
+        expected_transport_hash = compute_transport_hash(self)
+        if self.security.transport_hash != expected_transport_hash:
+            raise TransportIntegrityError("transport_hash does not match packet")
+
+        return self
+
+    def model_dump_json_dict(self) -> dict[str, Any]:
+        """Return a JSON-safe dict representation."""
+        return self.model_dump(mode="json", exclude_none=True)
+
+    def with_hop(self, hop: TransportHop) -> TransportPacket:
+        """
+        Append a hop without mutating the signed transport core.
+
+        hop_trace is intentionally excluded from transport_hash, so a hop append
+        must preserve payload_hash, transport_hash, and any existing transport
+        signature.
+        """
+        if hop.packet_id != self.header.packet_id:
+            raise ValueError("hop.packet_id must match packet.header.packet_id")
+
+        appended = self.model_copy(update={"hop_trace": self.hop_trace + (hop,)})
+        return TransportPacket(
+            header=appended.header,
+            address=appended.address,
+            tenant=appended.tenant,
+            payload=appended.payload,
+            security=appended.security,
+            governance=appended.governance,
+            provenance=appended.provenance,
+            delegation_chain=tuple(appended.delegation_chain),
+            hop_trace=tuple(appended.hop_trace),
+            lineage=appended.lineage,
+            attachments=tuple(appended.attachments),
+        )
+
+    def derive(
+        self,
+        *,
+        packet_type: str | None = None,
+        action: str | None = None,
+        source_node: str | None = None,
+        destination_node: str | None = None,
+        reply_to: str | None = None,
+        payload: dict[str, Any] | None = None,
+        provenance: RoutingProvenance | None = None,
+        hop: TransportHop | None = None,
+        delegation_link: DelegationLink | None = None,
+        governance: TransportGovernance | None = None,
+        priority: int | None = None,
+        expires_at: datetime | None = None,
+        timeout_ms: int | None = None,
+        not_before: datetime | None = None,
+        replay_mode: bool | None = None,
+    ) -> TransportPacket:
+        """Create an immutable child packet with correct lineage and refreshed hashes."""
+        new_header = TransportHeader(
+            packet_id=uuid4(),
+            packet_type=packet_type or self.header.packet_type,
+            action=action or self.header.action,
+            priority=self.header.priority if priority is None else priority,
+            created_at=utc_now(),
+            expires_at=self.header.expires_at if expires_at is None else expires_at,
+            timeout_ms=self.header.timeout_ms if timeout_ms is None else timeout_ms,
+            schema_version=self.header.schema_version,
+            idempotency_key=self.header.idempotency_key,
+            trace_id=self.header.trace_id,
+            correlation_id=self.header.correlation_id,
+            causation_id=self.header.packet_id,
+            retry_count=0,
+            replay_mode=self.header.replay_mode if replay_mode is None else replay_mode,
+            not_before=self.header.not_before if not_before is None else not_before,
+        )
+
+        new_address = TransportAddress(
+            source_node=(source_node or self.address.source_node).strip().lower(),
+            destination_node=(destination_node or self.address.destination_node).strip().lower(),
+            reply_to=(reply_to or self.address.reply_to).strip().lower(),
+        )
+
+        new_payload = dict(self.payload if payload is None else payload)
+        new_governance = governance or self.governance
+        new_provenance = provenance or self.provenance
+        new_delegation_chain = self.delegation_chain + (
+            (delegation_link,) if delegation_link is not None else ()
+        )
+        new_hop_trace = self.hop_trace + ((hop,) if hop is not None else ())
+        new_lineage = TransportLineage(
+            parent_id=self.header.packet_id,
+            root_id=self.lineage.root_id,
+            generation=self.lineage.generation + 1,
+        )
+
+        provisional = TransportPacket.model_construct(
+            header=new_header,
+            address=new_address,
+            tenant=self.tenant,
+            payload=new_payload,
+            security=TransportSecurity(
+                payload_hash="0" * 64,
+                transport_hash="0" * 64,
+                signature=None,
+                signature_algorithm=None,
+                signing_key_id=None,
+                classification=self.security.classification,
+                encryption_status=self.security.encryption_status,
+                pii_fields=self.security.pii_fields,
+            ),
+            governance=new_governance,
+            provenance=new_provenance,
+            delegation_chain=new_delegation_chain,
+            hop_trace=new_hop_trace,
+            lineage=new_lineage,
+            attachments=self.attachments,
+        )
+        child = _finalize_transport_packet(provisional, preserve_signature=False)
+        assert_tenant_immutable(self.tenant, child.tenant)
+        return child
+
+
+def _default_provenance(*, source_node: str, action: str) -> RoutingProvenance:
+    source = source_node.strip().lower()
+    origin_kind = "client" if source == "client" else "gate" if source == "gate" else "node"
+    return RoutingProvenance(
+        origin_kind=origin_kind,
+        requested_action=action.strip().lower(),
+        resolved_by_gate=False,
+        original_source_node=None if origin_kind == "client" else source,
+    )
+
+
+def _finalize_transport_packet(
+    packet: TransportPacket, *, preserve_signature: bool
+) -> TransportPacket:
+    payload_hash = compute_payload_hash(packet.payload)
+    provisional = packet.model_copy(
+        update={
+            "security": packet.security.model_copy(
+                update={
+                    "payload_hash": payload_hash,
+                    "transport_hash": "0" * 64,
+                    "signature": packet.security.signature if preserve_signature else None,
+                    "signature_algorithm": packet.security.signature_algorithm
+                    if preserve_signature
+                    else None,
+                    "signing_key_id": packet.security.signing_key_id
+                    if preserve_signature
+                    else None,
+                }
+            )
+        }
+    )
+    transport_hash = compute_transport_hash(provisional)
+    signature_still_valid = (
+        preserve_signature
+        and packet.security.payload_hash == payload_hash
+        and packet.security.transport_hash == transport_hash
+    )
+
+    finalized = provisional.model_copy(
+        update={
+            "security": provisional.security.model_copy(
+                update={
+                    "transport_hash": transport_hash,
+                    "signature": packet.security.signature if signature_still_valid else None,
+                    "signature_algorithm": packet.security.signature_algorithm
+                    if signature_still_valid
+                    else None,
+                    "signing_key_id": packet.security.signing_key_id
+                    if signature_still_valid
+                    else None,
+                }
+            )
+        }
+    )
+    return TransportPacket(
+        header=finalized.header,
+        address=finalized.address,
+        tenant=finalized.tenant,
+        payload=finalized.payload,
+        security=finalized.security,
+        governance=finalized.governance,
+        provenance=finalized.provenance,
+        delegation_chain=tuple(finalized.delegation_chain),
+        hop_trace=tuple(finalized.hop_trace),
+        lineage=finalized.lineage,
+        attachments=tuple(finalized.attachments),
+    )
+
+
+def create_transport_packet(
+    *,
+    action: str,
+    payload: dict[str, Any],
+    tenant: str | dict[str, Any] | TenantContext,
+    destination_node: str = "gate",
+    source_node: str = "client",
+    reply_to: str = "client",
+    priority: int = 2,
+    timeout_ms: int = 30_000,
+    classification: str = "internal",
+    compliance_tags: tuple[str, ...] = (),
+    retention_days: int = 90,
+    expires_at: datetime | None = None,
+    idempotency_key: str | None = None,
+    trace_id: str | None = None,
+    correlation_id: str | None = None,
+    provenance: RoutingProvenance | None = None,
+) -> TransportPacket:
+    """Build a canonical root transport packet with initialized lineage and hashes."""
+    packet_id = uuid4()
+    normalized_tenant = ensure_tenant_context(tenant)
+    normalized_action = action.strip().lower()
+    normalized_source = source_node.strip().lower()
+    normalized_destination = destination_node.strip().lower()
+    normalized_reply_to = reply_to.strip().lower()
+
+    header = TransportHeader(
+        packet_id=packet_id,
+        packet_type="request",
+        action=normalized_action,
+        priority=priority,
+        created_at=utc_now(),
+        expires_at=expires_at,
+        timeout_ms=timeout_ms,
+        schema_version="1.0",
+        idempotency_key=idempotency_key,
+        trace_id=trace_id or str(packet_id),
+        correlation_id=correlation_id or str(packet_id),
+        causation_id=None,
+        retry_count=0,
+        replay_mode=False,
+        not_before=None,
+    )
+
+    address = TransportAddress(
+        source_node=normalized_source,
+        destination_node=normalized_destination,
+        reply_to=normalized_reply_to,
+    )
+
+    governance = TransportGovernance(
+        intent=normalized_action,
+        compliance_tags=compliance_tags,
+        retention_days=retention_days,
+        redaction_applied=False,
+        audit_required=False,
+        data_subject_id=None,
+    )
+
+    packet = TransportPacket.model_construct(
+        header=header,
+        address=address,
+        tenant=normalized_tenant,
+        payload=dict(payload),
+        security=TransportSecurity(
+            payload_hash="0" * 64,
+            transport_hash="0" * 64,
+            signature=None,
+            signature_algorithm=None,
+            signing_key_id=None,
+            classification=classification,
+            encryption_status="plaintext",
+            pii_fields=(),
+        ),
+        governance=governance,
+        provenance=provenance
+        or _default_provenance(source_node=normalized_source, action=normalized_action),
+        delegation_chain=(),
+        hop_trace=(),
+        lineage=TransportLineage(
+            parent_id=None,
+            root_id=packet_id,
+            generation=0,
+        ),
+        attachments=(),
+    )
+    return _finalize_transport_packet(packet, preserve_signature=False)

constellation_node_sdk/transport/provenance.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+
+class RoutingProvenance(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    origin_kind: str
+    requested_action: str
+    resolved_by_gate: bool = False
+    route_kind: str | None = None
+    original_source_node: str | None = None
+
+    @field_validator("origin_kind")
+    @classmethod
+    def validate_origin_kind(cls, value: str) -> str:
+        normalized = value.strip().lower()
+        allowed = {"client", "node", "gate"}
+        if normalized not in allowed:
+            msg = f"origin_kind must be one of {sorted(allowed)}"
+            raise ValueError(msg)
+        return normalized
+
+    @field_validator("requested_action")
+    @classmethod
+    def validate_requested_action(cls, value: str) -> str:
+        normalized = value.strip().lower()
+        if not normalized:
+            raise ValueError("requested_action must not be empty")
+        return normalized
+
+    @field_validator("route_kind")
+    @classmethod
+    def validate_route_kind(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        normalized = value.strip().lower()
+        allowed = {"external_ingress", "gate_relay"}
+        if normalized not in allowed:
+            msg = f"route_kind must be one of {sorted(allowed)}"
+            raise ValueError(msg)
+        return normalized
+
+    @field_validator("original_source_node")
+    @classmethod
+    def validate_original_source_node(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        normalized = value.strip().lower()
+        if not normalized:
+            raise ValueError("original_source_node must not be blank")
+        return normalized

constellation_node_sdk/transport/tenant.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+from .errors import TenantMutationError
+
+
+class TenantContext(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    actor: str
+    on_behalf_of: str
+    originator: str
+    org_id: str
+    user_id: str | None = None
+
+    @field_validator("actor", "on_behalf_of", "originator", "org_id")
+    @classmethod
+    def validate_required_strings(cls, value: str) -> str:
+        normalized = value.strip()
+        if not normalized:
+            raise ValueError("tenant fields must not be empty")
+        return normalized
+
+    @field_validator("user_id")
+    @classmethod
+    def validate_optional_string(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        normalized = value.strip()
+        if not normalized:
+            raise ValueError("user_id must not be blank")
+        return normalized
+
+
+def ensure_tenant_context(value: str | dict[str, Any] | TenantContext) -> TenantContext:
+    """Normalize a string, dict, or TenantContext into a canonical TenantContext."""
+    if isinstance(value, TenantContext):
+        return value
+
+    if isinstance(value, str):
+        normalized = value.strip()
+        if not normalized:
+            raise ValueError("tenant string must not be empty")
+        return TenantContext(
+            actor=normalized,
+            on_behalf_of=normalized,
+            originator=normalized,
+            org_id=normalized,
+            user_id=None,
+        )
+
+    payload = dict(value or {})
+    if "tenant_id" in payload and "org_id" not in payload:
+        payload["org_id"] = payload["tenant_id"]
+
+    org_id = str(payload.get("org_id") or payload.get("actor") or "default").strip()
+    actor = str(payload.get("actor") or org_id).strip()
+    on_behalf_of = str(payload.get("on_behalf_of") or actor).strip()
+    originator = str(payload.get("originator") or actor).strip()
+
+    return TenantContext(
+        actor=actor,
+        on_behalf_of=on_behalf_of,
+        originator=originator,
+        org_id=org_id,
+        user_id=payload.get("user_id"),
+    )
+
+
+def assert_tenant_immutable(parent: TenantContext, child: TenantContext) -> None:
+    """Raise if a derived packet mutates tenant context."""
+    if parent != child:
+        raise TenantMutationError("tenant context is immutable across derived packets")

constellation_node_sdk-1.0.1.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: constellation-node-sdk
+Version: 1.0.1
+Summary: L9 Constellation Node SDK — TransportPacket runtime, Gate client, and node factory
+License: Proprietary
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn[standard]>=0.32.0
+Requires-Dist: pydantic>=2.9.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: cryptography>=43.0.0
+Requires-Dist: prometheus-client>=0.21.0
+Requires-Dist: python-json-logger>=3.2.0
+Requires-Dist: pyyaml>=6.0.2
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11.0; extra == "dev"
+Requires-Dist: pytest>=8.3.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.8; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0.12; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+
+# Constellation Node SDK
+
+`constellation-node-sdk` is the canonical Python SDK for Constellation worker and orchestrator nodes.
+
+It defines the packet-native transport contract used by the Constellation system:
+
+- `TransportPacket` is the single canonical wire format
+- all node-originated follow-up work goes back through **Gate**
+- hop trace is append-only and tamper-evident
+- transport integrity, lineage, provenance, and delegation are first-class protocol concepts
+
+## What this SDK provides
+
+- canonical `TransportPacket` models and helpers
+- transport hashing, signing, verification, and validation
+- Gate-only outbound client
+- reusable node runtime with `/v1/execute` and `/v1/health`
+- orchestrator helpers for workflow composition through Gate
+- tests and examples for worker and orchestrator nodes
+
+## Architectural rules
+
+1. Nodes **must not** know peer node URLs.
+2. Nodes **must only** send follow-up work to `GATE_URL`.
+3. Gate is the sole routing authority.
+4. `TransportPacket` is the only supported transport format.
+5. Semantic packet changes create child packets via `derive()`.
+6. Observational movement appends hop trace entries without changing `transport_hash`.
+
+## Install
+
+```bash
+pip install -e .
+For development:
+
+pip install -e ".[dev]"
+Quick start
+Worker node
+from constellation_node_sdk import create_node_app, register_handler
+
+@register_handler("score")
+async def handle_score(_tenant: str, payload: dict) -> dict:
+    return {
+        "status": "completed",
+        "score": 91,
+        "entity_id": payload["entity_id"],
+    }
+
+app = create_node_app(
+    service_name="score-node",
+    version="1.0.0",
+)
+Orchestrator node
+from constellation_node_sdk import create_node_app, register_handler
+from constellation_node_sdk.gate import GateClient, get_gate_client_config_from_env
+from constellation_node_sdk.orchestrator.step_executor import StepExecutor
+
+gate_client = GateClient(get_gate_client_config_from_env())
+step_executor = StepExecutor(gate_client=gate_client, source_node="orchestrator")
+
+@register_handler("full_pipeline")
+async def handle_full_pipeline(_tenant: str, payload: dict, packet):
+    enrich = await step_executor.execute_step(
+        parent=packet,
+        action="enrich",
+        payload={"entity_id": payload["entity_id"]},
+    )
+    score = await step_executor.execute_step(
+        parent=packet,
+        action="score",
+        payload={**payload, **enrich.payload},
+    )
+    return {
+        "status": "completed",
+        "entity_id": payload["entity_id"],
+        "enrich": enrich.payload,
+        "score": score.payload,
+    }
+
+app = create_node_app(
+    service_name="orchestrator",
+    version="1.0.0",
+)
+Environment
+See .env.example for runtime configuration.
+
+Repo structure
+src/constellation_node_sdk/transport/ — transport contract and hashing
+
+src/constellation_node_sdk/security/ — signing, verification, validation
+
+src/constellation_node_sdk/gate/ — Gate-only client and registration
+
+src/constellation_node_sdk/runtime/ — reusable node runtime
+
+src/constellation_node_sdk/orchestrator/ — workflow composition helpers
+
+contracts/ — formal contract specs
+
+examples/ — runnable worker and orchestrator examples
+
+tests/ — unit and integration coverage
+
+Status
+This repo is intended to be:
+
+packet-native
+
+Gate-routed
+
+composable
+
+production-oriented
+
+strict about protocol correctness
+
+
+```markdown

constellation_node_sdk-1.0.1.dist-info/RECORD

@@ -0,0 +1,45 @@
+constellation_node_sdk/__init__.py,sha256=7DIaR8opok0gPv4VUvorlrVEoEkJQKnPTX4tBR8VQHQ,3197
+constellation_node_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+constellation_node_sdk/gate/__init__.py,sha256=0BmOmw0BGZnNIUJBaZmoaoy8tSaSZiE-p0bEapDbx5M,1275
+constellation_node_sdk/gate/client.py,sha256=MzAreAblo2uQ2NPYbDIHh8fPtd6ZU-eadsBke6O_OFk,4070
+constellation_node_sdk/gate/config.py,sha256=HPn3mIm6zZ_rNd_RpfJy7Xuav1eftxlBEA44CjjETvw,5726
+constellation_node_sdk/gate/errors.py,sha256=-gQmOrRuFU3KoOBuuUPWAUHbU9dazk527kFctUMgydw,473
+constellation_node_sdk/gate/policy.py,sha256=Qtwt8jR6nNnWfd0DajbRvIBAIQiyEWyXqu-E7bx7DTc,2592
+constellation_node_sdk/gate/registration.py,sha256=9uymIBmBA6yfKAKYzDSoX79PDXyBAWpogYE1Uzqs1ng,4609
+constellation_node_sdk/orchestrator/__init__.py,sha256=RmS0Ok-1-CwWOZL_socLWksEk9MfsshL9eQx879I4mU,60
+constellation_node_sdk/orchestrator/base.py,sha256=2YjLWfoplVCu1EAECrKiFkPQluJCYHS9Y6hBbCjfkTo,1739
+constellation_node_sdk/orchestrator/merge.py,sha256=k6PWq7eTacz_lmAdnmaSXbGhr-FOb3RUQ5ZoB0xMM_U,1344
+constellation_node_sdk/orchestrator/packet_builder.py,sha256=e6gyeGwgRcLIFF1Q4Fjl7RPWORvFMevXOBvH8bpujSs,1472
+constellation_node_sdk/orchestrator/retry.py,sha256=GMpWjnYP0QowL4ik2tjAjzkyQmqNnJcGZYkQkKxSjBA,2108
+constellation_node_sdk/orchestrator/state.py,sha256=bh82_Jpq3UnegSrXZuogNVf4YtESVAfD8FNVXlbjjxk,2618
+constellation_node_sdk/orchestrator/step_executor.py,sha256=q_TMyCichml0GpQWLEvpSEipYb2YjQFoMCkon78T5no,2902
+constellation_node_sdk/runtime/__init__.py,sha256=EQ6fwCQRamm78Kq8UMVL2q5lDUIL9OfZKE-r4JDfpJg,1547
+constellation_node_sdk/runtime/app.py,sha256=bcIvglSfRwGlQAQ_dgk6LmYbb-DgRbkMAM2OyNNYgxc,11127
+constellation_node_sdk/runtime/config.py,sha256=pEhjf26Uy7tr1LjKpdKVmPos2EoouS1NSofcCaR68lk,12916
+constellation_node_sdk/runtime/errors.py,sha256=TbQMtDi4yZL1WAqGcTMlpsHsBD1PfgwYkKU2FByB4i4,3014
+constellation_node_sdk/runtime/execution.py,sha256=DFHxEPHgeOKUABkBZv9NXmjfS7SNMpZoQ4O8GwjHvhg,8436
+constellation_node_sdk/runtime/handlers.py,sha256=VBU3kdon0gR3xsPDEh7V5IoP4i7wxfrEe2S_QWwmbcM,1223
+constellation_node_sdk/runtime/inbound_policy.py,sha256=sqTJr6ur0n-_qmFSaTf7cLBDyfU-2K9Do4jNQkmy8xs,3140
+constellation_node_sdk/runtime/lifecycle.py,sha256=17ZNWTRdg4rA8Bi7-Gh0CIunYdXlYgWCn1Gri33UvoQ,651
+constellation_node_sdk/runtime/observability.py,sha256=JRLwQ_97_GnYTQSoqsGMRaacHMdnSgWaoJRlGtsPuK8,1799
+constellation_node_sdk/runtime/preflight.py,sha256=5SHhoPJWomjJgUr6Ve9l4ZRF7h0CBoPMomxjkYjXeXc,4735
+constellation_node_sdk/security/__init__.py,sha256=4JTsEHsO5d6tHo_H4yeqTo0rRTtlFlVkd3b7fVBJxn4,1202
+constellation_node_sdk/security/delegation.py,sha256=MlT81UFxRhiNsi25r8GxKNlUXs0KuH2q2gWFR_iK-JM,1707
+constellation_node_sdk/security/errors.py,sha256=l6Eel5pbr3meFib0qvDPdGXkMueVoqvLIjJhn1W6SOY,596
+constellation_node_sdk/security/signing.py,sha256=ahniFXeXdV7EDhg1LxpPXVPpIX2_l5kHWgecTakj9QU,4122
+constellation_node_sdk/security/validation.py,sha256=nktaWgSdleZvm5lxsKfrT6g8iDaUWj2039-Nwug3ACU,9453
+constellation_node_sdk/security/verification.py,sha256=-JOavVW7CZHrq3fMolkDnv_g2UX08Whmv3RD6BWMpn0,3508
+constellation_node_sdk/transport/__init__.py,sha256=AvwIqfzguRjCCsz7R3ASFKJF_uzZ5dPrVIHzcCh3E-0,2267
+constellation_node_sdk/transport/codec.py,sha256=SFalmKhwxcv7V-USPxnmK1lKDHh3q-n-kgFtah6vZ98,618
+constellation_node_sdk/transport/errors.py,sha256=ohgC0NoRYepEKeh3EkgZZCMZIJ5D8cQjJfxp-0ndg5k,1279
+constellation_node_sdk/transport/hashing.py,sha256=Ds6Z109gCDUVLbLQO7-3fBZdFYqSUf5n--kjvb0H_KM,2477
+constellation_node_sdk/transport/hop_trace.py,sha256=bgydTputZNimNJAVON89tLsvFfjJT6DGTYWEFdbixtU,11761
+constellation_node_sdk/transport/lineage.py,sha256=xswFwlfELGZcgd-alncuMR6lOxFP-i4uv5awQ_TsPmE,1172
+constellation_node_sdk/transport/models.py,sha256=-xc0KYLMrXSK_iLIKmMxx-vWI0MHbOq4TCKDLduQaLo,16174
+constellation_node_sdk/transport/packet.py,sha256=aaqY_BZVWDT4zSpKPkqUeHu6bkbb0ZTVQFcjEUg-0f8,12295
+constellation_node_sdk/transport/provenance.py,sha256=QwmAJvnxB7254nNkySzmkv93OHM_z-dsySyWFpmMJOw,1781
+constellation_node_sdk/transport/tenant.py,sha256=YJxAZ6aLoXt7WHy4rV01VEaaon90FPEVSI9B6s7Vcpo,2427
+constellation_node_sdk-1.0.1.dist-info/METADATA,sha256=obHcV6S2efypObELHH0nlj0jK2GzYcKMmlHjD2bo4yA,4220
+constellation_node_sdk-1.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+constellation_node_sdk-1.0.1.dist-info/top_level.txt,sha256=JBNbpbcgca5h--BJwxqRpIXRW4VCWqufmj_djAZI6Fk,23
+constellation_node_sdk-1.0.1.dist-info/RECORD,,

constellation_node_sdk-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

constellation_node_sdk-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+constellation_node_sdk