lltp 0.1.0a1__py3-none-any.whl

lltp/__init__.py

@@ -0,0 +1,15 @@
+"""LLTP v0.1 — Python reference SDK."""
+
+from lltp.lifecycle import derive_order_status, merge_requirements
+from lltp.validate import ValidationError, validate_catalog, validate_envelope
+
+__version__ = "0.1.0a1"
+
+__all__ = [
+    "__version__",
+    "ValidationError",
+    "derive_order_status",
+    "merge_requirements",
+    "validate_catalog",
+    "validate_envelope",
+]

lltp/client.py

@@ -0,0 +1,85 @@
+"""HTTP client for LLTP v0.1 lab providers."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+from urllib.parse import urljoin
+
+import httpx
+
+from lltp.validate import validate_catalog, validate_envelope
+
+JsonDict = Dict[str, Any]
+
+
+class LLTPClient:
+    """Thin httpx wrapper for LLTP v0.1 provider endpoints."""
+
+    def __init__(
+        self,
+        *,
+        timeout: float = 30.0,
+        validate_outgoing: bool = True,
+        client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._validate_outgoing = validate_outgoing
+        self._owns_client = client is None
+        self._client = client or httpx.Client(timeout=timeout)
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> "LLTPClient":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def fetch_catalog(self, base_url: str) -> JsonDict:
+        url = self._url(base_url, "/.well-known/lltp-catalog.json")
+        response = self._client.get(url)
+        response.raise_for_status()
+        data = response.json()
+        validate_catalog(data)
+        return data
+
+    def submit_order(self, base_url: str, envelope: JsonDict) -> JsonDict:
+        if self._validate_outgoing:
+            validate_envelope(envelope)
+        url = self._url(base_url, "/.lltp/orders")
+        response = self._client.post(url, json=envelope)
+        response.raise_for_status()
+        return response.json()
+
+    def get_order(self, base_url: str, order_id: str) -> JsonDict:
+        url = self._url(base_url, f"/.lltp/orders/{order_id}")
+        response = self._client.get(url)
+        response.raise_for_status()
+        return response.json()
+
+    def get_order_status(self, base_url: str, order_id: str) -> JsonDict:
+        url = self._url(base_url, f"/.lltp/orders/{order_id}/status")
+        response = self._client.get(url)
+        response.raise_for_status()
+        return response.json()
+
+    def fulfill_requirement(
+        self,
+        base_url: str,
+        order_id: str,
+        requirement_id: str,
+        envelope: JsonDict,
+    ) -> JsonDict:
+        if self._validate_outgoing:
+            validate_envelope(envelope)
+        path = f"/.lltp/orders/{order_id}/requirements/{requirement_id}"
+        url = self._url(base_url, path)
+        response = self._client.post(url, json=envelope)
+        response.raise_for_status()
+        return response.json()
+
+    @staticmethod
+    def _url(base_url: str, path: str) -> str:
+        base = base_url if base_url.endswith("/") else base_url + "/"
+        return urljoin(base, path.lstrip("/"))

lltp/lifecycle.py

@@ -0,0 +1,80 @@
+"""Order lifecycle derivation and requirement merge semantics."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import List, Optional
+
+from lltp.types import MUTABLE_REQUIREMENT_FIELDS, RequirementDict
+
+_SATISFIED = frozenset({"FULFILLED", "SKIPPED"})
+
+
+def derive_order_status(
+    requirements: List[RequirementDict],
+    *,
+    cancelled: bool = False,
+) -> str:
+    """
+    Derive order status from the requirement set.
+
+    Implements rules in spec/0.1/lifecycle.md. SUBMITTED is not produced here —
+    it is an optional HTTP 202 courtesy only.
+    """
+    if cancelled:
+        return "CANCELLED"
+    if any(r.get("status") == "REJECTED" for r in requirements):
+        return "FAILED"
+    if requirements and all(r.get("status") in _SATISFIED for r in requirements):
+        return "COMPLETED"
+    if any(
+        r.get("status") == "AWAITING" and r.get("assigned_to") == "REQUESTER"
+        for r in requirements
+    ):
+        return "BLOCKED"
+    requester_done = all(
+        r.get("status") in _SATISFIED
+        for r in requirements
+        if r.get("assigned_to") == "REQUESTER"
+    )
+    if requester_done and any(
+        r.get("status") == "AWAITING"
+        and r.get("assigned_to") in ("PROVIDER", "EXTERNAL")
+        for r in requirements
+    ):
+        return "IN_PROGRESS"
+    if any(r.get("status") == "AWAITING" for r in requirements):
+        return "ACTIVE"
+    return "ACTIVE"
+
+
+def merge_requirements(
+    current: List[RequirementDict],
+    delta: List[RequirementDict],
+) -> List[RequirementDict]:
+    """
+    Merge STATUS delta entries into the current requirement list.
+
+    Upserts by requirement_id. Only mutable fields from the delta are applied
+    to existing entries; immutable template fields are preserved.
+    """
+    by_id = {r["requirement_id"]: deepcopy(r) for r in current}
+    for patch in delta:
+        req_id = patch["requirement_id"]
+        if req_id not in by_id:
+            by_id[req_id] = deepcopy(patch)
+            continue
+        existing = by_id[req_id]
+        for key, value in patch.items():
+            if key in MUTABLE_REQUIREMENT_FIELDS or key == "requirement_id":
+                if key == "requirement_id":
+                    continue
+                existing[key] = value
+            elif key not in existing:
+                existing[key] = value
+    return list(by_id.values())
+
+
+def requirement_index(requirements: List[RequirementDict]) -> dict:
+    """Map requirement_id -> requirement dict."""
+    return {r["requirement_id"]: r for r in requirements}

lltp/schemas/__init__.py

@@ -0,0 +1 @@
+"""Vendored LLTP JSON Schema files."""