aigp-python 1.0.0__py3-none-any.whl

aigp/openlineage.py

@@ -0,0 +1,249 @@
+"""
+AIGP OpenLineage Facet Builder
+==============================
+
+Constructs OpenLineage-compatible facet dicts from AIGP governance events.
+No OpenLineage library dependency -- produces plain dicts conforming to
+the OpenLineage custom facet JSON Schema.
+
+AIGP defines two custom facets for OpenLineage:
+
+1. **AIGPGovernanceRunFacet** (run facet) -- aggregate governance proof
+   attached to ``run.facets.aigp_governance``.
+2. **AIGPResourceInputFacet** (input dataset facet) -- per-resource
+   governance metadata attached to ``inputs[].inputFacets.aigp_resource``.
+
+Usage::
+
+    from aigp.openlineage import (
+        build_governance_run_facet,
+        build_resource_input_facets,
+        build_openlineage_run_event,
+    )
+
+    # From an existing AIGP event dict:
+    run_facet = build_governance_run_facet(aigp_event)
+    input_facets = build_resource_input_facets(aigp_event)
+
+    # Or build a complete OpenLineage RunEvent:
+    ol_event = build_openlineage_run_event(
+        aigp_event,
+        job_namespace="finco.trading",
+        job_name="trading-bot-v2.invoke",
+    )
+
+Architectural note -- Emission Granularity:
+    Implementations SHOULD emit at most one OpenLineage RunEvent per
+    governance session or task, using ``trace_id`` as the ``runId``.
+    Individual agent steps within a session SHOULD be tracked as OTel
+    spans, not as separate OpenLineage runs.  OpenLineage was designed
+    for discrete Job Runs in a DAG; AI agents are conversational and
+    iterative -- emitting per-step runs overwhelms lineage backends.
+
+Architectural note -- Active vs. Passive Lineage:
+    OpenLineage integration is PASSIVE (eventually consistent).  It MUST
+    NOT be used for real-time enforcement decisions.  Enforcement MUST use
+    the AIGP + OTel path.  When pre-execution lineage context is needed
+    for governance, snapshot it, hash it as a ``"context"`` resource in
+    the Merkle tree -- making it an active governed artifact.
+"""
+
+import uuid as _uuid
+from datetime import datetime, timezone
+from typing import Any
+
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+PRODUCER = "https://github.com/open-aigp/aigp"
+
+RUN_FACET_SCHEMA_URL = (
+    "https://github.com/open-aigp/aigp/blob/v0.9.0/"
+    "integrations/openlineage/facets/AIGPGovernanceRunFacet.json"
+)
+
+RESOURCE_FACET_SCHEMA_URL = (
+    "https://github.com/open-aigp/aigp/blob/v0.9.0/"
+    "integrations/openlineage/facets/AIGPResourceInputFacet.json"
+)
+
+OPENLINEAGE_SCHEMA_URL = (
+    "https://openlineage.io/spec/2-0-2/OpenLineage.json#/$defs/RunEvent"
+)
+
+
+# ---------------------------------------------------------------------------
+# Facet Builders
+# ---------------------------------------------------------------------------
+
+def build_governance_run_facet(aigp_event: dict[str, Any]) -> dict[str, Any]:
+    """
+    Build an AIGPGovernanceRunFacet from an AIGP event dict.
+
+    The returned dict conforms to the ``AIGPGovernanceRunFacet`` JSON Schema
+    and is ready to be placed in ``run.facets.aigp_governance`` of an
+    OpenLineage RunEvent.
+
+    Args:
+        aigp_event: AIGP event dict (from ``create_aigp_event`` or any
+            ``AIGPInstrumentor`` method).
+
+    Returns:
+        Dict conforming to AIGPGovernanceRunFacet schema.
+    """
+    merkle_tree = aigp_event.get("governance_merkle_tree")
+    leaf_count = merkle_tree["leaf_count"] if merkle_tree else 1
+
+    facet: dict[str, Any] = {
+        "_producer": PRODUCER,
+        "_schemaURL": RUN_FACET_SCHEMA_URL,
+        "governanceHash": aigp_event.get("governance_hash", ""),
+        "hashType": aigp_event.get("hash_type", "sha256"),
+        "leafCount": leaf_count,
+        "agentId": aigp_event.get("agent_id", ""),
+        "traceId": aigp_event.get("trace_id", ""),
+        "specVersion": "0.9.0",
+    }
+
+    # Infer enforcement result from event type
+    event_type = aigp_event.get("event_type", "")
+    if "DENIED" in event_type or "VIOLATION" in event_type or "BLOCKED" in event_type:
+        facet["enforcementResult"] = "denied"
+    elif event_type:
+        facet["enforcementResult"] = "allowed"
+
+    # Optional: data classification
+    classification = aigp_event.get("data_classification", "")
+    if classification:
+        facet["dataClassification"] = classification
+
+    return facet
+
+
+def build_resource_input_facets(
+    aigp_event: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """
+    Build AIGPResourceInputFacet dicts from an AIGP event's governed resources.
+
+    If the event has a ``governance_merkle_tree``, produces one facet per leaf.
+    Otherwise, produces a single facet from the event's primary resource
+    (``policy_name`` or ``prompt_name``).
+
+    Args:
+        aigp_event: AIGP event dict.
+
+    Returns:
+        List of dicts, each conforming to AIGPResourceInputFacet schema.
+        Each dict is meant for ``inputs[].inputFacets.aigp_resource``.
+    """
+    merkle_tree = aigp_event.get("governance_merkle_tree")
+
+    if merkle_tree:
+        facets: list[dict[str, Any]] = []
+        for leaf in merkle_tree.get("leaves", []):
+            facets.append({
+                "_producer": PRODUCER,
+                "_schemaURL": RESOURCE_FACET_SCHEMA_URL,
+                "resourceType": leaf["resource_type"],
+                "resourceName": leaf["resource_name"],
+                "leafHash": leaf["hash"],
+            })
+        return facets
+
+    # Single resource: infer from event fields
+    facet: dict[str, Any] = {
+        "_producer": PRODUCER,
+        "_schemaURL": RESOURCE_FACET_SCHEMA_URL,
+    }
+
+    if aigp_event.get("policy_name"):
+        facet["resourceType"] = "policy"
+        facet["resourceName"] = aigp_event["policy_name"]
+        if aigp_event.get("policy_version"):
+            facet["resourceVersion"] = aigp_event["policy_version"]
+    elif aigp_event.get("prompt_name"):
+        facet["resourceType"] = "prompt"
+        facet["resourceName"] = aigp_event["prompt_name"]
+        if aigp_event.get("prompt_version"):
+            facet["resourceVersion"] = aigp_event["prompt_version"]
+    else:
+        return []  # No identifiable resource
+
+    if aigp_event.get("governance_hash"):
+        facet["leafHash"] = aigp_event["governance_hash"]
+
+    return [facet]
+
+
+def build_openlineage_run_event(
+    aigp_event: dict[str, Any],
+    job_namespace: str,
+    job_name: str,
+    run_id: str = "",
+    event_type: str = "COMPLETE",
+) -> dict[str, Any]:
+    """
+    Build a complete OpenLineage RunEvent with AIGP governance facets.
+
+    This convenience function creates a full RunEvent dict that can be
+    sent to any OpenLineage-compatible lineage backend.
+
+    Governed resources become OpenLineage InputDatasets with the
+    ``aigp_resource`` input facet.
+
+    **Emission granularity:** Use ``trace_id`` as ``run_id`` to ensure
+    one RunEvent per governance session (not per agent step).
+
+    Args:
+        aigp_event: AIGP event dict.
+        job_namespace: OpenLineage job namespace (e.g., ``"finco.trading"``).
+        job_name: OpenLineage job name (e.g., ``"trading-bot-v2.invoke"``).
+        run_id: Optional run ID (UUID string).  If not provided, uses the
+            AIGP event's ``trace_id``; falls back to a generated UUID.
+        event_type: OpenLineage event type.  One of ``"START"``,
+            ``"RUNNING"``, ``"COMPLETE"``, ``"FAIL"``, ``"ABORT"``.
+
+    Returns:
+        Dict conforming to OpenLineage RunEvent schema with AIGP facets.
+    """
+    if not run_id:
+        # Prefer trace_id as run_id (one RunEvent per session).
+        run_id = aigp_event.get("trace_id") or str(_uuid.uuid4())
+
+    run_facet = build_governance_run_facet(aigp_event)
+    resource_facets = build_resource_input_facets(aigp_event)
+
+    # Each governed resource becomes an OpenLineage InputDataset.
+    inputs: list[dict[str, Any]] = []
+    for rf in resource_facets:
+        inputs.append({
+            "namespace": job_namespace,
+            "name": rf.get("resourceName", "unknown"),
+            "inputFacets": {
+                "aigp_resource": rf,
+            },
+        })
+
+    now = datetime.now(timezone.utc)
+
+    return {
+        "eventType": event_type,
+        "eventTime": now.strftime("%Y-%m-%dT%H:%M:%S.") + f"{now.microsecond // 1000:03d}Z",
+        "run": {
+            "runId": run_id,
+            "facets": {
+                "aigp_governance": run_facet,
+            },
+        },
+        "job": {
+            "namespace": job_namespace,
+            "name": job_name,
+        },
+        "inputs": inputs,
+        "outputs": [],
+        "producer": PRODUCER,
+        "schemaURL": OPENLINEAGE_SCHEMA_URL,
+    }

aigp/tracestate.py

@@ -0,0 +1,149 @@
+"""
+AIGP W3C tracestate Vendor Key
+===============================
+
+Manages the `aigp` vendor key in the W3C tracestate header for
+lightweight governance signaling that survives through proxies
+and load balancers.
+
+Format:
+    tracestate: aigp=cls:{classification};pol:{policy_name};ver:{policy_version}
+
+Unlike Baggage, tracestate is part of the W3C Trace Context standard
+and is preserved by all compliant tracing infrastructure.
+"""
+
+from aigp.attributes import AIGPAttributes
+
+
+class AIGPTraceState:
+    """
+    Encodes and decodes AIGP governance context for the W3C tracestate header.
+    """
+
+    VENDOR_KEY = "aigp"
+
+    @staticmethod
+    def encode(
+        data_classification: str = "",
+        policy_name: str = "",
+        policy_version: int = 0,
+    ) -> str:
+        """
+        Encode AIGP governance context as a tracestate vendor value.
+
+        Args:
+            data_classification: AIGP classification level.
+            policy_name: AGRN policy name.
+            policy_version: Policy version number.
+
+        Returns:
+            Encoded vendor value string (e.g., "cls:con;pol:policy.trading-limits;ver:4").
+        """
+        parts = []
+
+        if data_classification:
+            abbrev = AIGPAttributes.CLASSIFICATION_ABBREV.get(
+                data_classification, data_classification[:3]
+            )
+            parts.append(f"cls:{abbrev}")
+
+        if policy_name:
+            parts.append(f"pol:{policy_name}")
+
+        if policy_version > 0:
+            parts.append(f"ver:{policy_version}")
+
+        return ";".join(parts)
+
+    @staticmethod
+    def decode(vendor_value: str) -> dict[str, str]:
+        """
+        Decode AIGP governance context from a tracestate vendor value.
+
+        Args:
+            vendor_value: The value portion of the aigp tracestate entry
+                          (e.g., "cls:con;pol:policy.trading-limits;ver:4").
+
+        Returns:
+            Dict with decoded governance context.
+        """
+        result = {}
+        abbrev_reverse = {v: k for k, v in AIGPAttributes.CLASSIFICATION_ABBREV.items()}
+
+        for part in vendor_value.split(";"):
+            if ":" not in part:
+                continue
+            key, value = part.split(":", 1)
+
+            if key == "cls":
+                result["data_classification"] = abbrev_reverse.get(value, value)
+            elif key == "pol":
+                result["policy_name"] = value
+            elif key == "ver":
+                result["policy_version"] = value
+
+        return result
+
+    @staticmethod
+    def inject_into_tracestate(
+        existing_tracestate: str,
+        data_classification: str = "",
+        policy_name: str = "",
+        policy_version: int = 0,
+    ) -> str:
+        """
+        Inject AIGP vendor entry into an existing tracestate header value.
+
+        Per W3C spec, the most recently updated vendor entry moves to the front.
+
+        Args:
+            existing_tracestate: Current tracestate header value.
+            data_classification: AIGP classification level.
+            policy_name: AGRN policy name.
+            policy_version: Policy version number.
+
+        Returns:
+            Updated tracestate header value with aigp entry prepended.
+        """
+        aigp_value = AIGPTraceState.encode(
+            data_classification=data_classification,
+            policy_name=policy_name,
+            policy_version=policy_version,
+        )
+
+        if not aigp_value:
+            return existing_tracestate
+
+        aigp_entry = f"{AIGPTraceState.VENDOR_KEY}={aigp_value}"
+
+        # Remove existing aigp entry if present
+        if existing_tracestate:
+            entries = [
+                e.strip()
+                for e in existing_tracestate.split(",")
+                if not e.strip().startswith(f"{AIGPTraceState.VENDOR_KEY}=")
+            ]
+            if entries:
+                return f"{aigp_entry},{','.join(entries)}"
+
+        return aigp_entry
+
+    @staticmethod
+    def extract_from_tracestate(tracestate: str) -> dict[str, str]:
+        """
+        Extract AIGP governance context from a tracestate header value.
+
+        Args:
+            tracestate: The full tracestate header value.
+
+        Returns:
+            Dict with decoded governance context, or empty dict if no aigp entry.
+        """
+        for entry in tracestate.split(","):
+            entry = entry.strip()
+            if entry.startswith(f"{AIGPTraceState.VENDOR_KEY}="):
+                vendor_value = entry[len(f"{AIGPTraceState.VENDOR_KEY}="):]
+                return AIGPTraceState.decode(vendor_value)
+
+        return {}

aigp_python-1.0.0.dist-info/METADATA

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: aigp-python
+Version: 1.0.0
+Summary: AIGP — AI Governance Proof. Open standard for proving your AI agents used the approved policies, prompts, and tools.
+Project-URL: Homepage, https://github.com/open-aigp/aigp
+Project-URL: Documentation, https://github.com/open-aigp/aigp/tree/main/sdks/python
+Project-URL: Repository, https://github.com/open-aigp/aigp
+Project-URL: Issues, https://github.com/open-aigp/aigp/issues
+Author: AIGP Community
+License-Expression: Apache-2.0
+Keywords: ai-agents,ai-governance,aigp,audit,governance,lineage,merkle-proof,openlineage,opentelemetry,tracing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Requires-Dist: opentelemetry-api>=1.20.0
+Requires-Dist: opentelemetry-sdk>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: exporters
+Requires-Dist: opentelemetry-exporter-otlp>=1.20.0; extra == 'exporters'
+Description-Content-Type: text/markdown
+
+# AIGP-OpenTelemetry Python SDK
+
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](../../LICENSE)
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
+
+**Bridge between AIGP governance events and OpenTelemetry spans.**
+
+AIGP is the governance-proof semantic payload. OpenTelemetry is the transport and correlation layer. This SDK handles dual-emit: every governance action produces both an AIGP event (compliance store) and an OTel span event (observability backend).
+
+---
+
+## Installation
+
+```bash
+pip install opentelemetry-api opentelemetry-sdk
+
+# Then add this package to your project
+# (from the AIGP repo root)
+pip install -e sdks/python/
+```
+
+## Quick Start
+
+```python
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.resources import Resource
+
+from aigp import AIGPInstrumentor
+
+# 1. Initialize with AIGP Resource attributes
+instrumentor = AIGPInstrumentor(
+    agent_id="agent.trading-bot-v2",
+    agent_name="Trading Bot",
+    org_id="org.finco",
+    event_callback=send_to_store,  # your AI governance store
+)
+
+resource = Resource.create({
+    **instrumentor.get_resource_attributes(),
+    "service.name": "trading-bot-v2",
+})
+provider = TracerProvider(resource=resource)
+trace.set_tracer_provider(provider)
+tracer = trace.get_tracer("aigp.example")
+
+# 2. Emit governance events within OTel spans
+with tracer.start_as_current_span("invoke_agent") as span:
+    event = instrumentor.inject_success(
+        policy_name="policy.trading-limits",
+        policy_version=4,
+        content="Max position: $10M...",
+        data_classification="confidential",
+    )
+    # -> AIGP event sent to AI governance store (compliance)
+    # -> OTel span event with aigp.* attributes (observability)
+```
+
+## Features
+
+### Dual-Emit Architecture
+
+Every call produces two outputs automatically:
+
+```
+instrumentor.inject_success(...)
+    |
+    +---> AIGP Event (JSON) ---> event_callback (AI governance store)
+    |
+    +---> OTel Span Event -----> OTel-compatible observability backend
+```
+
+### Supported Event Types
+
+| Method | AIGP Event Type | OTel Span Event |
+|--------|----------------|-----------------|
+| `inject_success()` | `INJECT_SUCCESS` | `aigp.inject.success` |
+| `inject_denied()` | `INJECT_DENIED` | `aigp.inject.denied` |
+| `prompt_used()` | `PROMPT_USED` | `aigp.prompt.used` |
+| `prompt_denied()` | `PROMPT_DENIED` | `aigp.prompt.denied` |
+| `policy_violation()` | `POLICY_VIOLATION` | `aigp.policy.violation` |
+| `a2a_call()` | `A2A_CALL` | `aigp.a2a.call` |
+| `governance_proof()` | `GOVERNANCE_PROOF` | `aigp.governance.proof` |
+| `multi_policy_inject()` | `INJECT_SUCCESS` | `aigp.inject.success` (with array attributes) |
+| `multi_resource_governance_proof()` | `GOVERNANCE_PROOF` | `aigp.governance.proof` (with Merkle tree) |
+
+### Multi-Policy / Multi-Prompt Support
+
+When an agent is governed by multiple policies simultaneously:
+
+```python
+event = instrumentor.multi_policy_inject(
+    policies=[
+        {"name": "policy.trading-limits", "version": 4},
+        {"name": "policy.risk-controls", "version": 2},
+    ],
+    content="Combined governed content...",
+    data_classification="confidential",
+)
+```
+
+This produces OTel array-valued attributes:
+```
+aigp.policies.names = ["policy.trading-limits", "policy.risk-controls"]
+aigp.policies.versions = [4, 2]
+```
+
+### Merkle Tree Governance Hash
+
+When an agent is governed by multiple resources (policies, prompts, tools, contexts, lineage), compute a Merkle tree for per-resource verification:
+
+```python
+from aigp.events import compute_merkle_governance_hash
+
+resources = [
+    ("policy", "policy.refund-limits", "Refund max: $500..."),
+    ("prompt", "prompt.customer-support-v3", "You are a helpful..."),
+    ("tool", "tool.order-lookup", '{"name": "order-lookup", "scope": "read"}'),
+    ("context", "context.env-config", '{"env": "production", "region": "us-east-1"}'),
+    ("lineage", "lineage.upstream-orders", '{"datasets": ["orders", "customers"]}'),
+]
+
+root_hash, merkle_tree = compute_merkle_governance_hash(resources)
+# root_hash: "a3f2b8..." (Merkle root, used as governance_hash)
+# merkle_tree: {"algorithm": "sha256", "leaf_count": 5, "leaves": [...]}
+```
+
+Or use the instrumentor for triple-emit with Merkle:
+
+```python
+event = instrumentor.multi_resource_governance_proof(
+    resources=[
+        ("policy", "policy.refund-limits", "Refund max: $500..."),
+        ("prompt", "prompt.customer-support-v3", "You are a helpful..."),
+        ("tool", "tool.order-lookup", '{"name": "order-lookup"}'),
+        ("context", "context.env-config", '{"env": "production"}'),
+        ("lineage", "lineage.upstream-orders", '{"datasets": ["orders"]}'),
+    ],
+    data_classification="confidential",
+)
+# governance_hash is the Merkle root
+# hash_type is "merkle-sha256"
+# governance_merkle_tree contains per-resource leaf hashes
+# OTel span event carries aigp.governance.merkle.leaf_count
+```
+
+Single-resource calls continue to produce flat SHA-256 hashes for full backward compatibility.
+
+### Baggage Propagation (Agent-to-Agent)
+
+```python
+from aigp.baggage import AIGPBaggage
+
+# Calling agent: inject governance context
+ctx = AIGPBaggage.inject(
+    policy_name="policy.trading-limits",
+    data_classification="confidential",
+    org_id="org.finco",
+)
+
+# Receiving agent: extract governance context
+extracted = AIGPBaggage.extract()
+# {'aigp.policy.name': 'policy.trading-limits', ...}
+```
+
+### W3C tracestate Vendor Key
+
+```python
+from aigp.tracestate import AIGPTraceState
+
+# Encode AIGP into tracestate
+tracestate = AIGPTraceState.inject_into_tracestate(
+    existing_tracestate="dd=s:1",
+    data_classification="confidential",
+    policy_name="policy.trading-limits",
+    policy_version=4,
+)
+# "aigp=cls:con;pol:policy.trading-limits;ver:4,dd=s:1"
+
+# Decode on receiving side
+context = AIGPTraceState.extract_from_tracestate(tracestate)
+# {'data_classification': 'confidential', 'policy_name': 'policy.trading-limits', ...}
+```
+
+### OpenLineage Facet Builder
+
+```python
+from aigp.openlineage import build_openlineage_run_event
+from aigp.events import compute_merkle_governance_hash, create_aigp_event
+
+# Context + lineage resources as governed inputs
+resources = [
+    ("policy", "policy.fair-lending", policy_content),
+    ("prompt", "prompt.scoring-v3", prompt_content),
+    ("context", "context.env-config", env_config_json),
+    ("lineage", "lineage.upstream-orders", lineage_snapshot_json),
+]
+root, tree = compute_merkle_governance_hash(resources)
+
+aigp_event = create_aigp_event(
+    event_type="GOVERNANCE_PROOF",
+    event_category="governance-proof",
+    agent_id="agent.credit-scorer-v2",
+    trace_id="abc123...",
+    governance_hash=root,
+    hash_type="merkle-sha256",
+    governance_merkle_tree=tree,
+)
+
+# Build OpenLineage RunEvent (zero OL dependency)
+ol_event = build_openlineage_run_event(
+    aigp_event,
+    job_namespace="finco.scoring",
+    job_name="credit-scorer-v2.invoke",
+)
+# Send to any OpenLineage-compatible lineage backend
+```
+
+## Modules
+
+| Module | Purpose |
+|--------|---------|
+| `aigp.instrumentor` | Core triple-emit bridge (`AIGPInstrumentor`) |
+| `aigp.attributes` | `aigp.*` semantic attribute constants |
+| `aigp.events` | AIGP event creation, hash computation, and Merkle tree |
+| `aigp.openlineage` | OpenLineage facet builder (zero OL dependency) |
+| `aigp.baggage` | OTel Baggage propagation for A2A calls |
+| `aigp.tracestate` | W3C tracestate vendor key encode/decode |
+
+## Running Tests
+
+```bash
+cd sdks/python
+pip install opentelemetry-api opentelemetry-sdk pytest
+PYTHONPATH=. pytest tests/ -v
+```
+
+## Running the End-to-End Example
+
+```bash
+cd sdks/python
+PYTHONPATH=. python examples/end_to_end.py
+```
+
+## Related Documentation
+
+- [AIGP Specification](../../spec/aigp-spec.md) (Sections 11.4-11.7)
+- [AIGP OTel Semantic Conventions](../../integrations/opentelemetry/semantic-conventions.md)
+- [OTel Collector Reference Config](../../integrations/opentelemetry/collector-config.yaml)

aigp_python-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+aigp/__init__.py,sha256=ie0jSZRTFaQwYn2BPse1OBTnZWp-bgXecEhyQQyfOOk,3824
+aigp/attributes.py,sha256=RI04tuQJMLEQTfKj3ELqIJDDqClXEHcRbd6Fy_LceuA,5345
+aigp/baggage.py,sha256=u3pUVWDNbNra1P_qUkFs-NhkcGs3w3cG6sIugP8DP_s,3820
+aigp/cloudevents.py,sha256=ltokwfuB5Qm5Vc9y8K_s20wsCUN05aVAM4KcNexIVrY,7718
+aigp/decorators.py,sha256=e6w9nNGF0F8Qqa3ip0ALUwyICvTnEvbStzwKlA2xTxc,26129
+aigp/events.py,sha256=tuDXWL5j5qGMmDeDfJMFKPILkpMoYU3cncHnFpn0fnI,19392
+aigp/instrumentor.py,sha256=zKJzZCBMAuxB7evD2AAvw1zSkl6qz3eOlKAGNvp-hxs,50179
+aigp/openlineage.py,sha256=fEtXa75caZualGZcJvbdZlMRaiYtr2IPNplHQkFNPw4,8669
+aigp/tracestate.py,sha256=cim3Bl2KFp0HQuUduXpH21qLDO86NS81og967HpTGQM,4581
+aigp_python-1.0.0.dist-info/METADATA,sha256=FqaIkQ9Di_ZlkAYyYgCsjz5aeoCK_ZxVmLtcY0miqio,9520
+aigp_python-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+aigp_python-1.0.0.dist-info/RECORD,,

aigp_python-1.0.0.dist-info/WHEEL

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