maigp-client 5.0.0__py3-none-any.whl

aigp_client/__init__.py

@@ -0,0 +1,64 @@
+"""AIGP Client v4.0 — Universal AI Governance Protocol client.
+
+Provides:
+- Protocol transport (CHECK/RECORD/TRACE)
+- Session context for multi-agent linking
+- Token accumulation for streaming/multi-cycle
+- Tool governance (per-tool CHECK)
+- Delegation tokens (agent-to-agent scoping)
+- Stream accumulator (periodic RECORD during streaming)
+- Rate-limit backoff
+"""
+
+__version__ = "4.0.0"
+
+# Core protocol
+from .client import AigpClient, GovernanceDecision
+from .trace_builder import TraceBuilder, STAGE_NAMES
+from .context import HumanitarianContext
+from .regulatory import RegulatoryContext
+from .african_context import AfricanContext
+from .japanese_context import JapaneseContext
+
+# v3.0+ — Agent support
+from .session import SessionContext
+from .tokens import TokenAccumulator
+from .tools import ToolGovernance
+from .delegation import DelegationToken
+from .streaming import StreamAccumulator
+from .backoff import retry_on_rate_limit
+
+# One-line governance wrapper
+from .govern import govern
+
+# RFC-032: Anticipation
+from .anticipation import AnticipationBuilder, Criterion
+
+# Provider-based config
+from .config import ClientConfig, ClientComponents
+from .providers.model import ModelProviderBase
+from .providers.transport import TransportProviderBase
+from .providers.consent import ConsentHelperBase, TokenMap
+from .schemas import GeoContext
+
+__all__ = [
+    # Core
+    "AigpClient", "GovernanceDecision",
+    "TraceBuilder", "STAGE_NAMES",
+    "HumanitarianContext",
+    "RegulatoryContext",
+    "AfricanContext",
+    "JapaneseContext",
+    # v3.0+ Agent support
+    "SessionContext", "TokenAccumulator", "ToolGovernance",
+    "DelegationToken", "StreamAccumulator", "retry_on_rate_limit",
+    # Config/Providers
+    "ClientConfig", "ClientComponents",
+    "ModelProviderBase", "TransportProviderBase",
+    "ConsentHelperBase", "TokenMap",
+    "GeoContext",
+    # Governance wrapper
+    "govern",
+    # RFC-032: Anticipation
+    "AnticipationBuilder", "Criterion",
+]

aigp_client/african_context.py

@@ -0,0 +1,102 @@
+"""RFC-029: African Context — typed context for AU Continental AI Strategy alignment.
+
+Usage:
+    from aigp_client.african_context import AfricanContext
+
+    ctx = AfricanContext(
+        active=True,
+        governance_framework="AU_CONTINENTAL_AI_STRATEGY",
+        member_state="KE",
+        rec="EAC",
+    )
+    client.declare_african_context(ctx)
+"""
+
+from dataclasses import dataclass, field
+
+VALID_FRAMEWORKS = {"AU_CONTINENTAL_AI_STRATEGY"}
+VALID_RECS = {"EAC", "ECOWAS", "SADC", "COMESA", "AMU", "IGAD", "ECCAS", "CEN-SAD"}
+VALID_SECTORS = {"HEALTH", "AGRICULTURE", "EDUCATION", "PUBLIC_SERVICES", "FINANCE", "ENVIRONMENT"}
+VALID_BENEFICIARIES = {"YOUTH", "WOMEN", "RURAL_COMMUNITIES", "DISABLED", "ELDERLY"}
+VALID_CROSS_BORDER = {"MALABO_CONVENTION", "AU_DATA_POLICY_FRAMEWORK"}
+
+
+@dataclass
+class AfricanContext:
+    """AU Continental AI Strategy context declaration per RFC-029."""
+
+    active: bool
+    governance_framework: str
+    member_state: str
+    rec: str = ""
+    local_first: bool = False
+    ubuntu_principle: bool = False
+    priority_sector: str = ""
+    beneficiary_groups: list[str] = field(default_factory=list)
+    language_context: list[str] = field(default_factory=list)
+    data_sovereignty: dict = field(default_factory=dict)
+    cultural_sensitivity: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.validate()
+
+    def validate(self) -> None:
+        """Raise ValueError if context is invalid."""
+        if self.governance_framework not in VALID_FRAMEWORKS:
+            raise ValueError(f"Invalid governance_framework: {self.governance_framework}. Must be one of {VALID_FRAMEWORKS}")
+        if not self.member_state or len(self.member_state) != 2:
+            raise ValueError("member_state must be a 2-letter ISO 3166-1 alpha-2 code")
+        if self.rec and self.rec not in VALID_RECS:
+            raise ValueError(f"Invalid rec: {self.rec}. Must be one of {VALID_RECS}")
+        if self.priority_sector and self.priority_sector not in VALID_SECTORS:
+            raise ValueError(f"Invalid priority_sector: {self.priority_sector}. Must be one of {VALID_SECTORS}")
+        for bg in self.beneficiary_groups:
+            if bg not in VALID_BENEFICIARIES:
+                raise ValueError(f"Invalid beneficiary_group: {bg}. Must be one of {VALID_BENEFICIARIES}")
+        if self.data_sovereignty:
+            cbf = self.data_sovereignty.get("cross_border_framework")
+            if cbf and cbf not in VALID_CROSS_BORDER:
+                raise ValueError(f"Invalid cross_border_framework: {cbf}. Must be one of {VALID_CROSS_BORDER}")
+
+    def to_dict(self) -> dict:
+        """Serialize for protocol transmission."""
+        d = {
+            "active": self.active,
+            "governance_framework": self.governance_framework,
+            "member_state": self.member_state,
+            "local_first": self.local_first,
+            "ubuntu_principle": self.ubuntu_principle,
+        }
+        if self.rec:
+            d["rec"] = self.rec
+        if self.priority_sector:
+            d["priority_sector"] = self.priority_sector
+        if self.beneficiary_groups:
+            d["beneficiary_groups"] = self.beneficiary_groups
+        if self.language_context:
+            d["language_context"] = self.language_context
+        if self.data_sovereignty:
+            d["data_sovereignty"] = self.data_sovereignty
+        if self.cultural_sensitivity:
+            d["cultural_sensitivity"] = self.cultural_sensitivity
+        return d
+
+    def merge(self, request_level: dict) -> "AfricanContext":
+        """Merge request-level context. Escalation only — cannot downgrade."""
+        if not request_level:
+            return self
+        if request_level.get("active") is False:
+            request_level["active"] = True
+        return AfricanContext(
+            active=True,
+            governance_framework=request_level.get("governance_framework", self.governance_framework),
+            member_state=request_level.get("member_state", self.member_state),
+            rec=request_level.get("rec", self.rec),
+            local_first=request_level.get("local_first", self.local_first),
+            ubuntu_principle=request_level.get("ubuntu_principle", self.ubuntu_principle),
+            priority_sector=request_level.get("priority_sector", self.priority_sector),
+            beneficiary_groups=list(set(self.beneficiary_groups + request_level.get("beneficiary_groups", []))),
+            language_context=list(set(self.language_context + request_level.get("language_context", []))),
+            data_sovereignty=request_level.get("data_sovereignty", self.data_sovereignty),
+            cultural_sensitivity=request_level.get("cultural_sensitivity", self.cultural_sensitivity),
+        )