atcn 1.3.0__py3-none-any.whl

atcn/__init__.py

@@ -0,0 +1,60 @@
+"""ATCN Python SDK."""
+
+from .canonical import canonicalize
+from .client import SDK_HEADER, SDK_VERSION, AtcnApiError, AtcnClient
+from .crypto import (
+    digest_of,
+    generate_key_pair,
+    public_key_from_private,
+    sha256_digest,
+    sign_payload,
+    verify_payload,
+)
+from .events import EventSigner, EvidenceInput, acceptance_data, evidence_envelope, utc_now
+from .ids import new_id
+from .subledger import (
+    CaptureQueue,
+    ReceiptLinkClient,
+    SubledgerClient,
+    build_response_statement,
+    countersign_payload,
+    ext,
+    sign_statement,
+    stable_key,
+    verify_countersignature,
+    verify_statement_signature,
+)
+from .webhooks import WEBHOOK_SIGNATURE_HEADER, sign_webhook, verify_webhook
+
+__all__ = [
+    "SDK_HEADER",
+    "SDK_VERSION",
+    "AtcnApiError",
+    "AtcnClient",
+    "CaptureQueue",
+    "EventSigner",
+    "EvidenceInput",
+    "ReceiptLinkClient",
+    "SubledgerClient",
+    "WEBHOOK_SIGNATURE_HEADER",
+    "acceptance_data",
+    "build_response_statement",
+    "canonicalize",
+    "countersign_payload",
+    "digest_of",
+    "evidence_envelope",
+    "ext",
+    "generate_key_pair",
+    "new_id",
+    "public_key_from_private",
+    "sha256_digest",
+    "sign_payload",
+    "sign_statement",
+    "sign_webhook",
+    "stable_key",
+    "utc_now",
+    "verify_countersignature",
+    "verify_payload",
+    "verify_statement_signature",
+    "verify_webhook",
+]

atcn/__main__.py

@@ -0,0 +1,41 @@
+"""`python -m atcn init [--share-usage yes|no]`: records whether this machine shares anonymous usage metrics."""
+
+import argparse
+import sys
+from collections.abc import Callable
+from typing import Any
+
+from .client import SDK_VERSION
+from .usage import Env, ask_to_share_usage, save_usage_choice, send_usage_report, settings_path, usage_status
+
+
+def main(argv: list[str] | None = None, read_line: Callable[[str], str] = input, write: Callable[[str], Any] = print, interactive: bool | None = None, env: Env | None = None) -> int:
+    """Returns the exit code: 0 saved, 2 usage error or no answer. On a yes, reports integration_initialized."""
+    parser = argparse.ArgumentParser(prog="python -m atcn")
+    parser.add_argument("command", choices=["init"])
+    parser.add_argument("--share-usage", choices=["yes", "no"])
+    try:
+        args = parser.parse_args(argv)
+    except SystemExit as exit_:
+        return int(exit_.code or 0)
+
+    if args.share_usage is not None:
+        shared: bool | None = save_usage_choice(args.share_usage == "yes", env)["share_usage"]
+    elif interactive if interactive is not None else sys.stdin.isatty():
+        shared = ask_to_share_usage(read_line, write, env)
+    else:
+        write("Not an interactive terminal: pass --share-usage yes or --share-usage no.")
+        return 2
+    if shared is None:
+        write("No answer given; nothing saved.")
+        return 2
+
+    if shared:
+        send_usage_report({"event": "integration_initialized", "sdk_version": f"python/{SDK_VERSION}", "workflow": "custom", "delegations": None, "charges": None}, env)
+    write(f"Saved your choice to {settings_path(env)}.")
+    write(f"Usage metrics: {usage_status(env)['reason']}.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

atcn/canonical.py

@@ -0,0 +1,38 @@
+"""Canonical JSON (RFC 8785 JCS, restricted to safe integers) - byte-identical to the TypeScript SDK."""
+
+import json
+from typing import Any
+
+MAX_SAFE_INTEGER = 2**53 - 1
+
+
+def _utf16_sort_key(key: str) -> bytes:
+    # JCS orders object members by UTF-16 code units, like JavaScript's default sort.
+    return key.encode("utf-16-be")
+
+
+def canonicalize(value: Any) -> str:
+    """Serializes a value canonically. Floats are rejected: amounts are integer minor units."""
+    if value is None:
+        return "null"
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+    if isinstance(value, int):
+        if abs(value) > MAX_SAFE_INTEGER:
+            raise ValueError(f"integer {value} exceeds the safe integer range")
+        return str(value)
+    if isinstance(value, float):
+        raise ValueError("floats are not allowed in canonical payloads; use integer minor units")
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=False)
+    if isinstance(value, (list, tuple)):
+        return "[" + ",".join(canonicalize(item) for item in value) + "]"
+    if isinstance(value, dict):
+        for key in value:
+            if not isinstance(key, str):
+                raise ValueError("object keys must be strings")
+        members = sorted(value.items(), key=lambda item: _utf16_sort_key(item[0]))
+        return "{" + ",".join(json.dumps(k, ensure_ascii=False) + ":" + canonicalize(v) for k, v in members) + "}"
+    raise ValueError(f"unsupported type {type(value).__name__}")

atcn/client.py

@@ -0,0 +1,123 @@
+"""Minimal ATCN API client using only the standard library for HTTP."""
+
+import json
+import time
+import uuid
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+from .crypto import Signed
+
+# Must equal the version in pyproject.toml (checked by a test).
+SDK_VERSION = "1.3.0"
+# Names the SDK and its version on every request, so the API operator can count SDK versions in use. Nothing else is sent.
+SDK_HEADER = "atcn-sdk"
+
+
+class AtcnApiError(Exception):
+    def __init__(self, status: int, code: str, message: str, reason: str | None, retryable: bool, correlation_id: str | None):
+        super().__init__(f"{code}{f' ({reason})' if reason else ''}: {message}")
+        self.status = status
+        self.code = code
+        self.reason = reason
+        self.retryable = retryable
+        self.correlation_id = correlation_id
+
+
+class AtcnClient:
+    """Every mutating call carries an Idempotency-Key; signed events use event:<event_id>.
+
+    With share_token, requests authenticate as a receipt-link holder (x-atcn-share-token) instead of with an API key.
+    default_headers are sent on every request.
+    """
+
+    def __init__(self, base_url: str, api_key: str, retries: int = 2, timeout: float = 30.0, share_token: str | None = None, default_headers: dict[str, str] | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.retries = retries
+        self.timeout = timeout
+        self.share_token = share_token
+        self.default_headers = default_headers or {}
+
+    def request(self, method: str, path: str, body: Any = None, idempotency_key: str | None = None, query: dict[str, Any] | None = None, raw: bytes | None = None, headers: dict[str, str] | None = None, content_type: str = "application/octet-stream") -> Any:
+        url = self.base_url + path
+        if query:
+            url += "?" + urllib.parse.urlencode({k: v for k, v in query.items() if v is not None})
+        auth_header = {"x-atcn-share-token": self.share_token} if self.share_token else {"authorization": f"Bearer {self.api_key}"}
+        all_headers = {SDK_HEADER: f"python/{SDK_VERSION}", **auth_header, **self.default_headers, **(headers or {})}
+        data: bytes | None = None
+        if method != "GET":
+            all_headers["idempotency-key"] = idempotency_key or str(uuid.uuid4())
+        if raw is not None:
+            all_headers["content-type"] = content_type
+            data = raw
+        elif body is not None:
+            all_headers["content-type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+
+        attempt = 0
+        while True:
+            attempt += 1
+            request = urllib.request.Request(url, data=data, method=method, headers=all_headers)
+            try:
+                with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                    text = response.read().decode("utf-8")
+                    return json.loads(text) if text and "json" in response.headers.get("content-type", "") else text
+            except urllib.error.HTTPError as http_error:
+                text = http_error.read().decode("utf-8")
+                parsed = json.loads(text) if text.startswith("{") else {}
+                err = parsed.get("error", {})
+                api_error = AtcnApiError(http_error.code, err.get("code", "http_error"), err.get("message", text), err.get("reason"), bool(err.get("retryable")), parsed.get("correlation_id"))
+                if api_error.retryable and attempt <= self.retries:
+                    time.sleep(0.1 * 2**attempt)
+                    continue
+                raise api_error from None
+
+    # Obligations
+    def create_obligation(self, signed: Signed, subledger: dict[str, Any] | None = None) -> Any:
+        """With subledger={"task_id": ..., "parent_delegation_id": ...}, the obligation also becomes a delegation of that task.
+
+        The link is not part of the signed event and is never shared with the counterparty.
+        """
+        body = {**signed, "subledger": subledger} if subledger else signed
+        return self.request("POST", "/v1/obligations", body, f"event:{signed['payload']['event_id']}")
+
+    def accept_obligation(self, obligation_id: str, signed: Signed) -> Any:
+        return self.request("POST", f"/v1/obligations/{obligation_id}/accept", signed, f"event:{signed['payload']['event_id']}")
+
+    def append_event(self, obligation_id: str, signed: Signed) -> Any:
+        return self.request("POST", f"/v1/obligations/{obligation_id}/events", signed, f"event:{signed['payload']['event_id']}")
+
+    def get_obligation(self, obligation_id: str) -> Any:
+        return self.request("GET", f"/v1/obligations/{obligation_id}")
+
+    def list_events(self, obligation_id: str) -> Any:
+        return self.request("GET", f"/v1/obligations/{obligation_id}/events")
+
+    # Evidence and clearing
+    def upload_blob(self, content: bytes, media_type: str = "application/octet-stream") -> Any:
+        return self.request("POST", "/v1/blobs", raw=content, headers={"x-media-type": media_type})
+
+    def submit_evidence(self, obligation_id: str, signed: Signed) -> Any:
+        return self.request("POST", f"/v1/obligations/{obligation_id}/evidence", signed, f"event:{signed['payload']['event_id']}")
+
+    def evaluate(self, obligation_id: str, policy_id: str, policy_version: str, idempotency_key: str | None = None) -> Any:
+        return self.request("POST", f"/v1/obligations/{obligation_id}/evaluate", {"policy_id": policy_id, "policy_version": policy_version}, idempotency_key)
+
+    def finalize(self, decision_id: str, idempotency_key: str | None = None) -> Any:
+        return self.request("POST", f"/v1/decisions/{decision_id}/finalize", None, idempotency_key)
+
+    # Journal, settlement, export
+    def journal(self, **filters: Any) -> Any:
+        return self.request("GET", "/v1/journal", query=filters)
+
+    def report_settlement_event(self, event: dict[str, Any], idempotency_key: str | None = None) -> Any:
+        return self.request("POST", "/v1/settlements/events", event, idempotency_key)
+
+    def export_closure_package(self, obligation_id: str) -> Any:
+        return self.request("GET", f"/v1/exports/{obligation_id}")
+
+    def service_keys(self) -> Any:
+        return self.request("GET", "/v1/service/keys")

atcn/crypto.py

@@ -0,0 +1,78 @@
+"""Ed25519 signing over canonical JSON, SHA-256 digests, and base64url encoding."""
+
+import base64
+import hashlib
+from typing import Any, TypedDict
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+
+from .canonical import canonicalize
+
+SIGNATURE_ALGORITHM = "Ed25519"
+
+
+class Signature(TypedDict):
+    key_id: str
+    key_version: int
+    algorithm: str
+    value: str
+
+
+class Signed(TypedDict):
+    payload: Any
+    signature: Signature
+
+
+def b64url_encode(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def b64url_decode(text: str) -> bytes:
+    return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
+
+
+def sha256_digest(data: bytes | str) -> str:
+    raw = data.encode("utf-8") if isinstance(data, str) else data
+    return "sha256:" + hashlib.sha256(raw).hexdigest()
+
+
+def digest_of(value: Any) -> str:
+    """Digest of the canonical JSON form of a value (terms digests, payload hashes)."""
+    return sha256_digest(canonicalize(value))
+
+
+def generate_key_pair() -> tuple[str, str]:
+    """Returns (private_key, public_key) as base64url strings; the private key is the 32-byte seed."""
+    private = Ed25519PrivateKey.generate()
+    seed = private.private_bytes_raw()
+    return b64url_encode(seed), public_key_from_private(b64url_encode(seed))
+
+
+def public_key_from_private(private_key: str) -> str:
+    private = Ed25519PrivateKey.from_private_bytes(b64url_decode(private_key))
+    return b64url_encode(private.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw))
+
+
+def sign_bytes(data: bytes, private_key: str) -> str:
+    return b64url_encode(Ed25519PrivateKey.from_private_bytes(b64url_decode(private_key)).sign(data))
+
+
+def verify_bytes(data: bytes, signature: str, public_key: str) -> bool:
+    try:
+        Ed25519PublicKey.from_public_bytes(b64url_decode(public_key)).verify(b64url_decode(signature), data)
+        return True
+    except (InvalidSignature, ValueError):
+        return False
+
+
+def sign_payload(payload: Any, key_id: str, key_version: int, private_key: str) -> Signed:
+    value = sign_bytes(canonicalize(payload).encode("utf-8"), private_key)
+    return {"payload": payload, "signature": {"key_id": key_id, "key_version": key_version, "algorithm": SIGNATURE_ALGORITHM, "value": value}}
+
+
+def verify_payload(signed: Signed, public_key: str) -> bool:
+    if signed["signature"].get("algorithm") != SIGNATURE_ALGORITHM:
+        return False
+    return verify_bytes(canonicalize(signed["payload"]).encode("utf-8"), signed["signature"]["value"], public_key)

atcn/events.py

@@ -0,0 +1,80 @@
+"""Event signing and evidence envelopes."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+from .crypto import Signed, digest_of, sha256_digest, sign_payload
+from .ids import new_id
+
+
+def utc_now() -> str:
+    """ISO-8601 UTC timestamp with milliseconds and a Z suffix, as ATCN timestamps require."""
+    now = datetime.now(timezone.utc)
+    return now.strftime("%Y-%m-%dT%H:%M:%S.") + f"{now.microsecond // 1000:03d}Z"
+
+
+@dataclass
+class EventSigner:
+    """Signs events for one actor. The private key never leaves the caller."""
+
+    actor_id: str
+    platform_id: str
+    key_id: str
+    private_key: str
+    key_version: int = 1
+
+    def sign(self, event_type: str, obligation_id: str, data: dict[str, Any] | None = None, causation_ids: list[str] | None = None) -> Signed:
+        payload = {
+            "schema_version": "1.0",
+            "event_id": new_id("event"),
+            "event_type": event_type,
+            "obligation_id": obligation_id,
+            "actor_id": self.actor_id,
+            "actor_platform_id": self.platform_id,
+            "event_time": utc_now(),
+            "causation_ids": causation_ids or [],
+            "data": data or {},
+        }
+        return sign_payload(payload, self.key_id, self.key_version, self.private_key)
+
+
+def acceptance_data(terms: dict[str, Any], accepting_agent_id: str) -> dict[str, Any]:
+    """Data for obligation.accepted: binds the acceptance to the exact terms version, digest, and policy."""
+    return {
+        "terms_version": terms["terms_version"],
+        "terms_digest": digest_of(terms),
+        "policy_id": terms["acceptance_policy"]["policy_id"],
+        "policy_version": terms["acceptance_policy"]["policy_version"],
+        "counterparty_agent_id": accepting_agent_id,
+    }
+
+
+@dataclass
+class EvidenceInput:
+    evidence_type: str
+    producer_id: str
+    content: bytes
+    uri: str
+    retrieval_method: str
+    media_type: str
+    verifiers: list[str]
+    deliverable_ids: list[str]
+    visible_to: list[str] = field(default_factory=lambda: ["issuer", "counterparty", "reviewer", "verifier"])
+
+
+def evidence_envelope(item: EvidenceInput) -> dict[str, Any]:
+    """Evidence envelope whose content_digest is computed from the bytes the producer holds."""
+    return {
+        "evidence_id": new_id("evidence"),
+        "evidence_type": item.evidence_type,
+        "producer_id": item.producer_id,
+        "created_at": utc_now(),
+        "content_digest": sha256_digest(item.content),
+        "uri": item.uri,
+        "retrieval_method": item.retrieval_method,
+        "media_type": item.media_type,
+        "access_policy": {"visible_to": item.visible_to},
+        "verifiers": item.verifiers,
+        "deliverable_ids": item.deliverable_ids,
+    }

atcn/ids.py

@@ -0,0 +1,29 @@
+"""Prefixed ULIDs, matching the TypeScript ids (e.g. evt_01J9Z...)."""
+
+import secrets
+import time
+
+CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+
+PREFIXES = {
+    "obligation": "obl",
+    "event": "evt",
+    "evidence": "evd",
+    "agent": "agt",
+    "principal": "prn",
+    "platform": "plt",
+}
+
+
+def ulid(now_ms: int | None = None) -> str:
+    remaining = int(time.time() * 1000) if now_ms is None else now_ms
+    time_part = ""
+    for _ in range(10):
+        time_part = CROCKFORD[remaining % 32] + time_part
+        remaining //= 32
+    random_part = "".join(CROCKFORD[b % 32] for b in secrets.token_bytes(16))
+    return time_part + random_part
+
+
+def new_id(kind: str) -> str:
+    return f"{PREFIXES[kind]}_{ulid()}"

atcn/subledger.py

@@ -0,0 +1,376 @@
+"""Agent Work Subledger (PRD v1.2) client, receipt-link client, capture queue, and signing helpers.
+
+Mirrors the TypeScript SDK (@atcn/sdk): same idempotency keys, same canonical statements, same signatures.
+"""
+
+import json
+import time
+import urllib.parse
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+from .canonical import canonicalize
+from .client import AtcnApiError, AtcnClient
+from .crypto import sha256_digest, sign_bytes, verify_bytes
+
+Json = dict[str, Any]
+
+RESPONSE_STATEMENT_TYPE = "atcn.subledger.receipt_response"
+
+
+def ext(external_ref: str) -> str:
+    """Caller-supplied references address records before their server IDs are known: ext("job-42")."""
+    return f"ext:{external_ref}"
+
+
+def stable_key(kind: str, *parts: str) -> str:
+    """Idempotency key derived from the caller's stable references; long references are hashed to fit 8-200 chars."""
+    key = f"sl:{kind}:{':'.join(parts)}"
+    return key if len(key) <= 200 else f"sl:{kind}:{sha256_digest(':'.join(parts))}"
+
+
+def _path(ref: str) -> str:
+    return urllib.parse.quote(ref, safe="")
+
+
+# ---------- Statements and signatures ----------
+
+
+def build_response_statement(receipt: Json, response_type: str, fields: list[str] | None = None, note: str | None = None, evidence: list[Json] | None = None, corrections: list[Json] | None = None) -> Json:
+    """The statement a provider responds with. receipt needs receipt_id, digest, revision, and issuer_operator_id."""
+    return {
+        "document_type": RESPONSE_STATEMENT_TYPE,
+        "receipt_id": receipt["receipt_id"],
+        "receipt_digest": receipt["digest"],
+        "receipt_revision": receipt["revision"],
+        "issuer_operator_id": receipt["issuer_operator_id"],
+        "response_type": response_type,
+        "fields": sorted(set(fields or [])),
+        "note": note,
+        "evidence": evidence or [],
+        "corrections": corrections or [],
+    }
+
+
+def sign_statement(statement: Json, private_key: str) -> str:
+    """Provider-side signing. The service never sees the private key."""
+    return sign_bytes(canonicalize(statement).encode("utf-8"), private_key)
+
+
+def verify_statement_signature(statement: Json, signature: str, public_key: str) -> bool:
+    return verify_bytes(canonicalize(statement).encode("utf-8"), signature, public_key)
+
+
+def countersign_payload(payload: Any, private_key: str) -> str:
+    """Operator-side countersignature over a closure or receipt payload, made with a key the operator holds."""
+    return sign_bytes(canonicalize(payload).encode("utf-8"), private_key)
+
+
+def verify_countersignature(payload: Any, signature: str, public_key: str) -> bool:
+    return verify_bytes(canonicalize(payload).encode("utf-8"), signature, public_key)
+
+
+# ---------- Operator client ----------
+
+
+class SubledgerClient:
+    """Small, independent subledger operations. Default idempotency keys derive from the caller's stable references."""
+
+    def __init__(self, base_url: str, api_key: str, retries: int = 2, timeout: float = 30.0, default_headers: dict[str, str] | None = None):
+        self.http = AtcnClient(base_url, api_key, retries=retries, timeout=timeout, default_headers=default_headers)
+
+    # Tasks, delegations, delivery claims
+    def create_task(self, task: Json, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", "/v1/tasks", task, idempotency_key or stable_key("task", task["external_ref"]))
+
+    def get_task(self, task_id: str) -> Json:
+        return self.http.request("GET", f"/v1/tasks/{_path(task_id)}")
+
+    def list_tasks(self, status: str | None = None, external_ref: str | None = None) -> Json:
+        return self.http.request("GET", "/v1/tasks", query={"status": status, "external_ref": external_ref})
+
+    def get_task_access(self, task_id: str) -> Json:
+        """Admin only. Principals are "user:<id>" or "api_key:<id>"."""
+        return self.http.request("GET", f"/v1/tasks/{_path(task_id)}/access")
+
+    def update_task_access(self, task_id: str, restricted: bool | None = None, grant: list[str] | None = None, revoke: list[str] | None = None, idempotency_key: str | None = None) -> Json:
+        body: Json = {"grant": grant or [], "revoke": revoke or []}
+        if restricted is not None:
+            body["restricted"] = restricted
+        return self.http.request("POST", f"/v1/tasks/{_path(task_id)}/access", body, idempotency_key)
+
+    def create_delegation(self, task_id: str, delegation: Json, idempotency_key: str | None = None) -> Json:
+        key = idempotency_key or (stable_key("delegation", delegation["external_ref"]) if delegation.get("external_ref") else None)
+        return self.http.request("POST", f"/v1/tasks/{_path(task_id)}/delegations", delegation, key)
+
+    def assign_provider(self, delegation_id: str, provider_id: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/delegations/{_path(delegation_id)}/provider", {"provider_id": provider_id}, idempotency_key)
+
+    def append_delegation_event(self, delegation_id: str, event: Json, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/delegations/{_path(delegation_id)}/events", event, idempotency_key)
+
+    def report_capture_gap(self, task_id: str, kind: str, detail: str, delegation_id: str | None = None, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/tasks/{_path(task_id)}/capture-gaps", {"kind": kind, "detail": detail, "delegation_id": delegation_id}, idempotency_key)
+
+    # Financial events, matching, allocation
+    def record_financial_event(self, event: Json, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", "/v1/financial-events", event, idempotency_key or stable_key("financial", event["source"], event["source_event_id"]))
+
+    def import_csv(self, csv_text: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", "/v1/financial-events/import", idempotency_key=idempotency_key, raw=csv_text.encode("utf-8"), content_type="text/csv")
+
+    def list_financial_events(self, unattributed: bool | None = None, source: str | None = None) -> Json:
+        return self.http.request("GET", "/v1/financial-events", query={"unattributed": None if unattributed is None else str(unattributed).lower(), "source": source})
+
+    def allocate(self, financial_event_id: str, allocation: Json, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/financial-events/{financial_event_id}/allocations", allocation, idempotency_key)
+
+    def create_allocation_rule(self, rule: Json, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", "/v1/allocation-rules", rule, idempotency_key)
+
+    def list_matches(self, status: str | None = None) -> Json:
+        return self.http.request("GET", "/v1/matches", query={"status": status})
+
+    def confirm_match(self, match_id: str, task_id: str, delegation_id: str | None = None, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/matches/{match_id}/confirm", {"task_id": task_id, "delegation_id": delegation_id}, idempotency_key)
+
+    def financial_summary(self, task_id: str, report_currency: str | None = None, as_of: str | None = None) -> Json:
+        return self.http.request("GET", f"/v1/tasks/{_path(task_id)}/financial-summary", query={"report_currency": report_currency, "as_of": as_of})
+
+    def list_exceptions(self, task_id: str | None = None, status: str | None = None) -> Json:
+        return self.http.request("GET", "/v1/subledger-exceptions", query={"task_id": task_id, "status": status})
+
+    def resolve_exception(self, exception_id: str, status: str, resolution: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/subledger-exceptions/{exception_id}/resolve", {"status": status, "resolution": resolution}, idempotency_key)
+
+    # Closures and receipts
+    def close_task(self, task_id: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/tasks/{_path(task_id)}/close", {}, idempotency_key)
+
+    def get_closure(self, task_id: str, version: int | None = None) -> Json:
+        return self.http.request("GET", f"/v1/tasks/{_path(task_id)}/closure", query={"version": version})
+
+    def create_receipt(self, task_id: str, delegation_id: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/tasks/{_path(task_id)}/receipts", {"delegation_id": delegation_id}, idempotency_key)
+
+    def get_receipt(self, receipt_id: str) -> Json:
+        return self.http.request("GET", f"/v1/receipts/{receipt_id}")
+
+    def mark_receipt_delivered(self, receipt_id: str, channel: str, reference: str | None = None, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/receipts/{receipt_id}/delivered", {"channel": channel, "reference": reference}, idempotency_key)
+
+    def create_receipt_share(self, receipt_id: str, allowed_actions: list[str] | None = None, ttl_hours: int | None = None, idempotency_key: str | None = None) -> Json:
+        body: Json = {"receipt_id": receipt_id, "allowed_actions": allowed_actions or ["view"]}
+        if ttl_hours is not None:
+            body["ttl_hours"] = ttl_hours
+        return self.http.request("POST", "/v1/receipt-shares", body, idempotency_key)
+
+    def revoke_receipt_share(self, share_id: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("DELETE", f"/v1/receipt-shares/{share_id}", None, idempotency_key)
+
+    def list_responses(self, receipt_id: str) -> Json:
+        return self.http.request("GET", f"/v1/receipts/{receipt_id}/responses")
+
+    def decide_correction(self, response_id: str, status: str, reason: str, financial_events: list[Json] | None = None, idempotency_key: str | None = None) -> Json:
+        """Accepting appends the corrected records. A correction of financial fields needs the corrected events."""
+        body = {"status": status, "reason": reason, "financial_events": financial_events or []}
+        return self.http.request("POST", f"/v1/receipt-responses/{response_id}/decision", body, idempotency_key)
+
+    # Provider identity
+    def create_provider(self, provider: Json, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", "/v1/provider-identities", provider, idempotency_key or stable_key("provider", provider["name"]))
+
+    def bind_provider_key(self, provider_id: str, key_id: str, public_key: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/provider-identities/{provider_id}/key-bindings", {"key_id": key_id, "public_key": public_key}, idempotency_key)
+
+    def start_domain_challenge(self, provider_id: str, key_id: str, public_key: str, domain: str | None = None, idempotency_key: str | None = None) -> Json:
+        """Admin only. The provider publishes the returned txt_value at txt_name; then call verify_domain_challenge."""
+        body: Json = {"key_id": key_id, "public_key": public_key}
+        if domain is not None:
+            body["domain"] = domain
+        return self.http.request("POST", f"/v1/provider-identities/{provider_id}/domain-challenges", body, idempotency_key)
+
+    def verify_domain_challenge(self, challenge_id: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/domain-challenges/{challenge_id}/verify", {}, idempotency_key)
+
+    # Operator-held signing keys
+    def register_operator_key(self, key_id: str, public_key: str, idempotency_key: str | None = None) -> Json:
+        """Admin only. Registers the public half of a key the operator holds; the private key stays with the operator."""
+        return self.http.request("POST", "/v1/operator-keys", {"key_id": key_id, "public_key": public_key}, idempotency_key)
+
+    def revoke_operator_key(self, key_id: str, reason: str, idempotency_key: str | None = None) -> Json:
+        return self.http.request("POST", f"/v1/operator-keys/{_path(key_id)}/revoke", {"reason": reason}, idempotency_key)
+
+    def operator_keys(self, operator_id: str) -> Json:
+        return self.http.request("GET", f"/v1/operators/{operator_id}/keys")
+
+    def countersign(self, signed: Json, key_id: str, private_key: str, idempotency_key: str | None = None) -> Json:
+        """Signs a closure or receipt payload locally with the operator's private key and records the countersignature."""
+        payload = signed["payload"]
+        path = f"closures/{payload['closure_id']}" if "closure_id" in payload else f"receipts/{payload['receipt_id']}"
+        return self.http.request("POST", f"/v1/{path}/countersign", {"key_id": key_id, "signature": countersign_payload(payload, private_key)}, idempotency_key)
+
+    # Metrics and keys
+    def product_metrics(self) -> Json:
+        return self.http.request("GET", "/v1/metrics/product")
+
+    def service_keys(self) -> Json:
+        return self.http.request("GET", "/v1/service/keys")
+
+
+# ---------- Provider-side client ----------
+
+
+class ReceiptLinkClient:
+    """Provider-side access through a receipt link: no account, no API key, only the link's scope."""
+
+    def __init__(self, base_url: str, share_token: str, retries: int = 2, timeout: float = 30.0):
+        self.http = AtcnClient(base_url, "", retries=retries, timeout=timeout, share_token=share_token)
+
+    def current(self) -> Json:
+        return self.http.request("GET", "/v1/receipt-shares/current")
+
+    def verification(self, receipt_id: str) -> Json:
+        return self.http.request("GET", f"/v1/receipts/{receipt_id}/verification")
+
+    def respond(
+        self,
+        receipt: Json,
+        response_type: str,
+        fields: list[str] | None = None,
+        note: str | None = None,
+        evidence: list[Json] | None = None,
+        corrections: list[Json] | None = None,
+        signing: Json | None = None,
+        idempotency_key: str | None = None,
+    ) -> Json:
+        """receipt needs receipt_id, digest, and revision. signing needs binding_id, key_id, private_key, issuer_operator_id."""
+        provider_signature = None
+        if signing:
+            statement = build_response_statement({**receipt, "issuer_operator_id": signing["issuer_operator_id"]}, response_type, fields, note, evidence, corrections)
+            provider_signature = {"binding_id": signing["binding_id"], "key_id": signing["key_id"], "value": sign_statement(statement, signing["private_key"])}
+        body = {
+            "receipt_digest": receipt["digest"],
+            "receipt_revision": receipt["revision"],
+            "response_type": response_type,
+            "fields": fields or [],
+            "note": note,
+            "evidence": evidence or [],
+            "corrections": corrections or [],
+            "provider_signature": provider_signature,
+        }
+        return self.http.request("POST", f"/v1/receipts/{receipt['receipt_id']}/responses", body, idempotency_key)
+
+
+# ---------- Capture queue ----------
+
+
+class CaptureQueue:
+    """Bounded local capture queue. enqueue() and flush() never raise, so a capture outage never stops the work.
+
+    Each operation keeps one idempotency key for its lifetime, so replays and retries create exactly one record.
+    Overflow policy: reject the newest operation and count it in `dropped`; older operations keep their order,
+    because later events (completions, charges) depend on earlier ones (tasks, delegations).
+    """
+
+    def __init__(self, client: SubledgerClient, max_size: int = 1000, max_attempts: int = 5):
+        self.client = client
+        self.max_size = max_size
+        self.max_attempts = max_attempts
+        self._pending: list[Json] = []
+        self._failed: list[Json] = []
+        self._dropped = 0
+        self._sequence = 0
+
+    @property
+    def dropped(self) -> int:
+        return self._dropped
+
+    @property
+    def size(self) -> int:
+        return len(self._pending)
+
+    def enqueue(self, path: str, body: Any, idempotency_key: str | None = None) -> bool:
+        """Queues one mutation. Returns False (and counts a drop) when the queue is full; never raises."""
+        if len(self._pending) >= self.max_size:
+            self._dropped += 1
+            return False
+        self._sequence += 1
+        self._pending.append(
+            {
+                "id": f"op_{int(time.time() * 1000)}_{self._sequence}",
+                "method": "POST",
+                "path": path,
+                "body": body,
+                "idempotencyKey": idempotency_key or stable_key("capture", str(uuid.uuid4())),
+                "enqueued_at": datetime.now(timezone.utc).isoformat(),
+                "attempts": 0,
+                "last_error": None,
+            }
+        )
+        return True
+
+    def task(self, task: Json) -> bool:
+        return self.enqueue("/v1/tasks", task, stable_key("task", task["external_ref"]))
+
+    def delegation(self, task_ref: str, delegation: Json) -> bool:
+        key = stable_key("delegation", delegation["external_ref"]) if delegation.get("external_ref") else None
+        return self.enqueue(f"/v1/tasks/{_path(task_ref)}/delegations", delegation, key)
+
+    def delegation_event(self, delegation_ref: str, event: Json, idempotency_key: str | None = None) -> bool:
+        return self.enqueue(f"/v1/delegations/{_path(delegation_ref)}/events", event, idempotency_key)
+
+    def financial_event(self, event: Json) -> bool:
+        return self.enqueue("/v1/financial-events", event, stable_key("financial", event["source"], event["source_event_id"]))
+
+    def flush(self) -> Json:
+        """Sends queued operations in order. A retryable failure (network, 5xx, 429) stops the flush and keeps the
+        operation; a non-retryable rejection moves it to the failed list. Never raises."""
+        sent = 0
+        failed = 0
+        while self._pending:
+            op = self._pending[0]
+            op["attempts"] += 1
+            try:
+                self.client.http.request(op["method"], op["path"], op["body"], op["idempotencyKey"])
+                self._pending.pop(0)
+                sent += 1
+            except Exception as error:  # noqa: BLE001 - a capture failure must never stop the caller's work
+                op["last_error"] = str(error)
+                retryable = not isinstance(error, AtcnApiError) or error.retryable
+                if retryable and op["attempts"] < self.max_attempts:
+                    break
+                self._failed.append(self._pending.pop(0))
+                failed += 1
+        return {"sent": sent, "failed": failed, "remaining": len(self._pending)}
+
+    def failed_operations(self) -> list[Json]:
+        return list(self._failed)
+
+    def export_failed(self) -> str:
+        """Failed operations as JSON lines (same format as the TypeScript SDK), for replay after the cause is fixed."""
+        return "\n".join(json.dumps(op) for op in self._failed)
+
+    def replay(self, json_lines: str) -> int:
+        """Puts exported operations back in the queue with their original idempotency keys."""
+        replayed: set[str] = set()
+        for line in json_lines.splitlines():
+            if not line.strip():
+                continue
+            op = json.loads(line)
+            if self.enqueue(op["path"], op["body"], op["idempotencyKey"]):
+                replayed.add(op["idempotencyKey"])
+        self._failed = [op for op in self._failed if op["idempotencyKey"] not in replayed]
+        return len(replayed)
+
+    def report_gaps(self, task_ref: str) -> bool:
+        """Reports drops and permanent failures for a task as capture gaps (marks its lineage incomplete). Never raises."""
+        if self._dropped == 0 and not self._failed:
+            return True
+        detail = f"{self._dropped} capture operation(s) dropped by queue overflow; {len(self._failed)} failed permanently"
+        try:
+            self.client.report_capture_gap(task_ref, "queue_overflow" if self._dropped > 0 else "capture_failed", detail)
+            return True
+        except Exception:  # noqa: BLE001
+            return False

atcn/usage.py

@@ -0,0 +1,127 @@
+"""Opt-in anonymous usage reporting: the saved choice (the same file the TypeScript SDK uses) and the sender.
+
+The SDK client never reports anything; only `python -m atcn init` does, after an explicit yes.
+"""
+
+import json
+import os
+import urllib.request
+import uuid
+from collections.abc import Callable, Mapping
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+# The ATCN-operated collector. There is none yet, so reports are only sent when ATCN_USAGE_URL is set.
+DEFAULT_USAGE_URL: str | None = None
+
+CONSENT_QUESTION = "Share anonymous usage metrics to help improve ATCN?"
+CONSENT_EXPLANATION = "\n".join(
+    [
+        "If you answer yes, this machine sends: a random installation ID, the event (integration initialized, task closed,",
+        "closure verified, exception resolved), a timestamp, the SDK version, whether it was a demo, and counts of",
+        "delegations and charges. Never task data, references, amounts, names, or keys.",
+        "Change your answer with `python -m atcn init`, or turn reporting off with ATCN_USAGE_DISABLED=1. Details: docs/USAGE_DATA.md",
+    ]
+)
+
+Env = Mapping[str, str]
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+
+def _is_set(value: str | None) -> bool:
+    return value is not None and value != "" and value != "0" and value.lower() != "false"
+
+
+def settings_path(env: Env | None = None) -> Path:
+    env = os.environ if env is None else env
+    config_dir = env.get("ATCN_CONFIG_DIR") or str(Path.home() / ".config" / "atcn")
+    return Path(config_dir) / "usage.json"
+
+
+def read_usage_settings(env: Env | None = None) -> dict[str, Any] | None:
+    path = settings_path(env)
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text())
+    except (OSError, ValueError):
+        return None
+
+
+def save_usage_choice(share_usage: bool, env: Env | None = None) -> dict[str, Any]:
+    """Saves an explicit choice. Opting in keeps an existing installation ID or creates a random one; opting out deletes it."""
+    previous = read_usage_settings(env) or {}
+    settings = {
+        "share_usage": share_usage,
+        "installation_id": (previous.get("installation_id") or str(uuid.uuid4())) if share_usage else None,
+        "decided_at": _now(),
+    }
+    path = settings_path(env)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(settings, indent=2) + "\n")
+    return settings
+
+
+def disabled_by(env: Env | None = None) -> str | None:
+    """The environment variable that turns reporting off, if one is set. It wins over any saved choice."""
+    env = os.environ if env is None else env
+    for name in ("ATCN_USAGE_DISABLED", "DO_NOT_TRACK"):
+        if _is_set(env.get(name)):
+            return name
+    return None
+
+
+def usage_status(env: Env | None = None) -> dict[str, Any]:
+    """Reporting is on only after an explicit yes, and ATCN_USAGE_DISABLED or DO_NOT_TRACK always turn it off."""
+    env = os.environ if env is None else env
+    url = env.get("ATCN_USAGE_URL") or DEFAULT_USAGE_URL
+
+    def off(reason: str) -> dict[str, Any]:
+        return {"enabled": False, "reason": reason, "installation_id": None, "url": url}
+
+    variable = disabled_by(env)
+    if variable:
+        return off(f"off: {variable} is set")
+    settings = read_usage_settings(env)
+    if settings is None:
+        return off("off: not chosen yet (run python -m atcn init)")
+    if not settings.get("share_usage") or not settings.get("installation_id"):
+        return off("off: you chose not to share usage metrics")
+    if not url:
+        return off("off until a collector is configured (set ATCN_USAGE_URL)")
+    return {"enabled": True, "reason": f"on: sharing anonymous usage metrics with {url}", "installation_id": settings["installation_id"], "url": url}
+
+
+def send_usage_report(event: dict[str, Any], env: Env | None = None, timeout: float = 2.0) -> bool:
+    """Sends one report if the user opted in, adding the installation ID and timestamp. Never raises."""
+    status = usage_status(env)
+    if not status["enabled"]:
+        return False
+    report = {"installation_id": status["installation_id"], "occurred_at": _now(), **event}
+    request = urllib.request.Request(status["url"], data=json.dumps(report).encode("utf-8"), method="POST", headers={"content-type": "application/json"})
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return 200 <= response.status < 300
+    except Exception:
+        return False
+
+
+def ask_to_share_usage(read_line: Callable[[str], str] = input, write: Callable[[str], Any] = print, env: Env | None = None) -> bool | None:
+    """Asks the question and saves the answer. Only y/yes or n/no count; anything else asks again.
+
+    Returns None, saving nothing, if the input ends before an answer.
+    """
+    write(CONSENT_EXPLANATION)
+    while True:
+        try:
+            answer = read_line(f"{CONSENT_QUESTION} [y/n] ").strip().lower()
+        except EOFError:
+            return None
+        if answer in ("y", "yes"):
+            return save_usage_choice(True, env)["share_usage"]
+        if answer in ("n", "no"):
+            return save_usage_choice(False, env)["share_usage"]

atcn/webhooks.py

@@ -0,0 +1,45 @@
+"""Webhook signature verification (header: ATCN-Signature: t=..,key_id=..,key_version=..,sig=..)."""
+
+import time
+from dataclasses import dataclass
+
+from .crypto import sign_bytes, verify_bytes
+
+WEBHOOK_SIGNATURE_HEADER = "atcn-signature"
+
+
+@dataclass
+class WebhookVerification:
+    valid: bool
+    reason: str | None = None
+    key_id: str | None = None
+    key_version: int | None = None
+
+
+def parse_webhook_header(header: str) -> dict[str, str]:
+    parts: dict[str, str] = {}
+    for item in header.split(","):
+        name, sep, value = item.partition("=")
+        if sep:
+            parts[name.strip()] = value.strip()
+    return parts
+
+
+def sign_webhook(body: str, key_id: str, key_version: int, private_key: str, timestamp: int | None = None) -> str:
+    t = int(time.time()) if timestamp is None else timestamp
+    sig = sign_bytes(f"{t}.{body}".encode("utf-8"), private_key)
+    return f"t={t},key_id={key_id},key_version={key_version},sig={sig}"
+
+
+def verify_webhook(body: str, header: str, public_key: str, tolerance_seconds: int = 300, now: int | None = None) -> WebhookVerification:
+    """Verifies the raw request body against the header using the published ATCN service key."""
+    parts = parse_webhook_header(header)
+    if "t" not in parts or "sig" not in parts or not parts["t"].lstrip("-").isdigit():
+        return WebhookVerification(False, "malformed_header")
+    timestamp = int(parts["t"])
+    current = int(time.time()) if now is None else now
+    if abs(current - timestamp) > tolerance_seconds:
+        return WebhookVerification(False, "timestamp_outside_tolerance")
+    if not verify_bytes(f"{timestamp}.{body}".encode("utf-8"), parts["sig"], public_key):
+        return WebhookVerification(False, "bad_signature")
+    return WebhookVerification(True, None, parts.get("key_id"), int(parts.get("key_version", "0")))

atcn-1.3.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: atcn
+Version: 1.3.0
+Summary: Python SDK for the Agent Transaction Closure Network: canonical JSON, Ed25519 event signing, webhook verification, API client, Agent Work Subledger
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/fadnisnikhil/atcn
+Project-URL: Source, https://github.com/fadnisnikhil/atcn/tree/main/packages/sdk-python
+Project-URL: Issues, https://github.com/fadnisnikhil/atcn/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=42
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# atcn (Python SDK)
+
+The ATCN Python SDK. It covers:
+
+- **Signing.** RFC 8785 canonical JSON, Ed25519 signing, and obligation event signing with `EventSigner`.
+- **Webhooks.** `verify_webhook` and `sign_webhook`.
+- **API clients.** `AtcnClient` is for the clearing network. `SubledgerClient` and `CaptureQueue` record tasks, delegations and charges. `ReceiptLinkClient` is for providers.
+- **Provider response statements.** `build_response_statement`, `sign_statement` and `verify_statement_signature`.
+
+It passes the same signing test vectors as the TypeScript SDK.
+
+```bash
+pip install atcn
+```
+
+```python
+from atcn import canonicalize, generate_key_pair, sign_payload, verify_payload
+
+canonicalize({"b": 1, "a": 2})  # '{"a":2,"b":1}'
+private_key, public_key = generate_key_pair()
+signed = sign_payload({"hello": "world"}, "key_1", 1, private_key)
+assert verify_payload(signed, public_key)
+```
+
+The API clients need an ATCN API at `base_url`. The hosted API is not open for signup yet.
+
+The Python SDK does not verify task closures or receipts. Use `npx @atcn/verify-cli` or the TypeScript SDK for that.
+
+`python -m atcn init` records whether this machine shares anonymous usage metrics. Reporting is off by default and needs `ATCN_USAGE_URL`; see the [usage data documentation](https://github.com/fadnisnikhil/atcn/blob/main/docs/USAGE_DATA.md).
+
+Apache-2.0.

atcn-1.3.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+atcn/__init__.py,sha256=DrC9q_powW-Dj6ufCycx7vFMzNFRDy3Uy6TiA_WYx4E,1401
+atcn/__main__.py,sha256=GBFOEIx7_L1fJ1_gP4iaMbrZALvPxrnNufXybDX7rWQ,1771
+atcn/canonical.py,sha256=SxEQIm0eqsjJOYRHIr9W9rUCudvPLfD8c57Dtlq39_A,1538
+atcn/client.py,sha256=k7uymK0qvi8ea8qzm_gaLMq8gr8GKqSRTMUeXDfayxU,6320
+atcn/crypto.py,sha256=w6Um9EKDph26yWSuZqjYoi2UhYBh9v3K0ydOZhf8i3c,2725
+atcn/events.py,sha256=wz5pRzkXtlQ6vs2YmPSJSTQ93V0sPS3G_9oTRWdXCOA,2793
+atcn/ids.py,sha256=0H5BgjjrBdPRI1efOFlOP_OhDHV9budh0YM8r44fivc,725
+atcn/subledger.py,sha256=7Hz3JU9RoU4lHLrbkba5P7pl8EsC3ficg93gRKbWdF4,20165
+atcn/usage.py,sha256=A4OpWjVHjTrvjTH9kAELygQJPDEm5CqLF_XTnaWA0gc,5291
+atcn/webhooks.py,sha256=JcKF3xdoPKplqgSSYQ14yj87_I07-tVPZZz3VTSGGoY,1847
+atcn-1.3.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+atcn-1.3.0.dist-info/METADATA,sha256=mOzWhiEnWKS5R3-3FGrqOtmrwj49sWY3wNMX-z5p_XQ,2016
+atcn-1.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+atcn-1.3.0.dist-info/top_level.txt,sha256=9hXjjNYfYciBocVulEJW1qUxz-JrGh2xsdNdnA9nzfo,5
+atcn-1.3.0.dist-info/RECORD,,

atcn-1.3.0.dist-info/WHEEL

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

atcn-1.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

atcn-1.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+atcn