entropy-sdk 0.1.5__py3-none-any.whl

entropy_sdk/__init__.py

@@ -0,0 +1,25 @@
+"""
+entropy-sdk — EntropyRuntime 控制层的可嵌入 SDK
+
+论文同款核心抽象（arXiv:2607.00334）：
+Gear 五级档位 · Utility Gate 效用门 · 事件驱动 Fallback · append-only 审计链。
+
+设计铁律：
+1. 核心纯 stdlib，零依赖；
+2. fail-closed —— 效用函数必须显式注入，门是唯一调度通道；
+3. 每次判定自动落审计链，为经验验证生产数据。
+"""
+from .adapters.raw import RawAction, action, observe
+from .fallback import FallbackConfig
+from .gate import GateDecision, UtilityGate
+from .gear import Gear
+from .policy import GearPolicy
+from .runtime import CycleResult, EntropyRuntime
+from .state import AuditLog, RuntimeState
+
+__version__ = "0.1.5"
+__all__ = [
+    "Gear", "UtilityGate", "GateDecision", "GearPolicy", "FallbackConfig",
+    "RuntimeState", "AuditLog", "EntropyRuntime", "CycleResult",
+    "RawAction", "action", "observe",
+]

entropy_sdk/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Agent 框架适配器。raw 零依赖；langchain/pydanticai 按需 extras 安装。"""
+from .base import AgentAdapter, GatedAction
+from .raw import RawAction, action, observe
+
+__all__ = ["AgentAdapter", "GatedAction", "RawAction", "action", "observe"]

entropy_sdk/adapters/base.py

@@ -0,0 +1,31 @@
+"""适配器基座：一个动作协议 + 一个提案协议，接任何 agent 框架。"""
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+from ..gear import Gear
+
+
+@runtime_checkable
+class GatedAction(Protocol):
+    """被门控的动作必须声明自己需要的最低档位。
+
+    这是嵌套动作空间 A0⊂…⊂A4 的实现侧契约：
+    required_gear=G0 的动作（只读）在任何档位都允许；
+    required_gear=G3 的动作（有副作用）只在 Execute 以上放行。
+    """
+
+    required_gear: int | Gear
+
+
+class AgentAdapter(Protocol):
+    """Agent 框架适配协议（对齐生产仓 interfaces/agent_adapter.py 的轻量版）。"""
+
+    def propose(self, state: Any, gear: Gear, history: list[dict]) -> GatedAction:
+        """按当前档位生成候选动作。实现侧应遵守档位语义：
+        档位越低，生成的动作越保守。"""
+        ...
+
+    def execute(self, action: GatedAction) -> Any:
+        """真正执行。只会在门放行后被调用。"""
+        ...

entropy_sdk/adapters/langchain.py

@@ -0,0 +1,52 @@
+"""LangChain 适配：把 Tool 包成"门不过就不执行"的安全工具。
+
+需要 ``pip install entropy-sdk[langchain]``。
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from ..gear import Gear
+from ..runtime import EntropyRuntime, _safe_gear
+
+
+def gated_tool(runtime: EntropyRuntime, tool: Any, required_gear: int | Gear = Gear.EXECUTE,
+               state_fn=lambda *a, **k: None):
+    """把一个 LangChain Tool 包装成受 EntropyRuntime 门控的工具。
+
+    门拒绝时返回拒绝说明字符串（不执行、不抛异常），
+    让 LLM 在下一轮自行调整——拒绝本身是反馈信号。
+    """
+    # FIX5-2：与 runtime 同一严格度——构造期即拒非法 gear（3.0/"3"/True 等），
+    # 消灭「adapter 静默截断、runtime 拒绝」的两处判定不一致
+    gear = _safe_gear(required_gear)
+    if gear is None:
+        raise ValueError(f"invalid required_gear {required_gear!r} "
+                         "(want Gear instance or plain int 0-4)")
+
+    def _run(*args: Any, **kwargs: Any) -> str:
+        from .raw import action  # 延迟导入，避免硬依赖
+
+        # FIX-7：description 透传，效用函数可按工具身份定价
+        act = action(tool.func if hasattr(tool, "func") else tool,
+                     *args, required_gear=gear,
+                     description=getattr(tool, "description", "") or getattr(tool, "name", ""),
+                     **kwargs)
+        result = runtime.step(state=state_fn(), action=act, execute=lambda a: a())
+        if result.executed:
+            return str(result.result)
+        if result.suspended:
+            return "[GATE] runtime suspended after repeated rejections; human review required."
+        reason = result.gate.reason if result.gate else "gear does not permit this action"
+        return f"[GATE] action rejected: {reason}. Propose a safer alternative."
+
+    from langchain_core.tools import StructuredTool  # noqa: 仅在调用时需要
+
+    return StructuredTool.from_function(
+        func=_run,
+        name=f"gated_{getattr(tool, 'name', 'tool')}",
+        description=(getattr(tool, "description", "") or "")
+        + f" [safety-gated, requires gear {gear.label}]",
+        # FIX-6：透传原工具的 args_schema——不带它，带参工具没有正常调用路径
+        args_schema=getattr(tool, "args_schema", None),
+    )

entropy_sdk/adapters/pydanticai.py

@@ -0,0 +1,43 @@
+"""PydanticAI 适配：工具函数装饰器，门控逻辑与框架解耦。
+
+需要 ``pip install entropy-sdk[pydanticai]``。
+"""
+from __future__ import annotations
+
+import functools
+from typing import Any, Callable
+
+from ..gear import Gear
+from ..runtime import EntropyRuntime
+
+
+def gated(runtime: EntropyRuntime, required_gear: int | Gear = Gear.EXECUTE,
+          state_fn=lambda *a, **k: None):
+    """装饰任意工具函数，使其经过 EntropyRuntime 效用门。
+
+    拒绝时返回说明字符串而非抛异常，让 agent 把拒绝当作反馈。
+    用法::
+
+        @gated(runtime, required_gear=Gear.EXECUTE)
+        def delete_records(table: str) -> str: ...
+    """
+    def decorator(fn: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(fn)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            from .raw import action
+
+            # FIX-7：description 透传（docstring 优先，函数名兜底），效用可按工具身份定价
+            act = action(fn, *args, required_gear=required_gear,
+                         description=(fn.__doc__ or "").strip() or fn.__name__,
+                         **kwargs)
+            result = runtime.step(state=state_fn(), action=act, execute=lambda a: a())
+            if result.executed:
+                return result.result
+            if result.suspended:
+                return "[GATE] runtime suspended; human review required."
+            reason = result.gate.reason if result.gate else "gear does not permit this action"
+            return f"[GATE] rejected: {reason}"
+
+        return wrapper
+
+    return decorator

entropy_sdk/adapters/raw.py

@@ -0,0 +1,38 @@
+"""零框架适配：把任意 Python callable 包装成被门控的动作。"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ..gear import Gear
+
+
+@dataclass
+class RawAction:
+    """最小动作包装。"""
+
+    fn: Callable[..., Any]
+    args: tuple = ()
+    kwargs: dict = field(default_factory=dict)
+    required_gear: int | Gear = Gear.EXECUTE
+    description: str = ""
+
+    def __call__(self) -> Any:
+        return self.fn(*self.args, **self.kwargs)
+
+
+def action(
+    fn: Callable[..., Any],
+    *args: Any,
+    required_gear: int | Gear = Gear.EXECUTE,
+    description: str = "",
+    **kwargs: Any,
+) -> RawAction:
+    """一行包装：``action(send_email, to, body, required_gear=Gear.EXECUTE)``。"""
+    return RawAction(fn=fn, args=args, kwargs=kwargs,
+                     required_gear=required_gear, description=description)
+
+
+def observe(fn: Callable[..., Any], *args: Any, **kwargs: Any) -> RawAction:
+    """只读动作快捷包装：required_gear=G0，任何档位可执行。"""
+    return action(fn, *args, required_gear=Gear.OBSERVE, **kwargs)

entropy_sdk/fallback.py

@@ -0,0 +1,45 @@
+"""
+事件驱动 Fallback（论文 §4，Theorem 4）
+
+拒绝后的恢复路径：
+1. 记录拒绝，σ 上升；
+2. 由 proposer 生成备选动作 a′，重新过门；
+3. k 次备选全败 → 降一档，下周期待定；
+4. m 次连续拒绝 → 降到 G0 并挂起，等待人工复核。
+
+Theorem 4 保证：任何错误态至多 |G|−1=4 步降到 G0，
+G0 的只读动作平凡地满足 U ≥ 0 —— 系统永远有恢复路径，不需要重启。
+"""
+from __future__ import annotations
+
+import math
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class FallbackConfig:
+    max_alternatives: int = 3      # k：每档最多尝试的备选数
+    max_consecutive_rejections: int = 5  # m：连续拒绝上限，触发 G0 挂起
+
+    def __post_init__(self):
+        # FIX-3b + FIX2-2 + FIX2-3：构造期校验（fail-closed）
+        # max_alternatives：0 合法（关闭 fallback 的显式语义，v0.1.2 恢复；
+        # v0.1 的 >=1 校验误杀了该意图——CHANGELOG 标注破坏性恢复）；上界 100
+        # 防 10**9 级每周期巨大循环。两参数均须有限整数。
+        for name in ("max_alternatives", "max_consecutive_rejections"):
+            v = getattr(self, name)
+            if isinstance(v, bool) or not (
+                isinstance(v, int)
+                or (isinstance(v, float) and math.isfinite(v) and v.is_integer())
+            ):
+                raise ValueError(f"{name} must be a finite integer, got {v!r}")
+        if not 0 <= self.max_alternatives <= 100:
+            raise ValueError("max_alternatives must be in [0, 100] (0 = fallback off)")
+        if self.max_consecutive_rejections < 1:
+            raise ValueError("max_consecutive_rejections must be >= 1")
+
+
+# 备选生成器签名：(state, rejected_action, attempt_index) -> alternative action | None
+AlternativeProposer = Callable[[Any, Any, int], Any | None]

entropy_sdk/gate.py

@@ -0,0 +1,82 @@
+"""
+Utility Gate（论文 Definitions 2–3，Theorem 2）
+
+门是唯一调度通道：动作被执行当且仅当 Gate=1，即 U(s,a) >= theta。
+本 SDK 不内置任何效用函数——U 必须由使用者按领域注入。
+未注入效用函数时构造即报错（fail-closed，无 fail-open 开关）。
+"""
+from __future__ import annotations
+
+import math
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Protocol
+
+
+class UtilityFunction(Protocol):
+    """效用函数协议：U: S × A → R。
+
+    推荐形态（论文 §4）：U(s,a) = α·Δtask + β·safety − γ·cost，
+    多智能体场景可把传感器熵项 H_i 折进 cost（论文 §6.1）。
+    """
+
+    def __call__(self, state: Any, action: Any) -> float: ...
+
+
+@dataclass(frozen=True)
+class GateDecision:
+    """一次门判定的完整记录（审计用）。"""
+
+    admitted: bool
+    utility: float
+    theta: float
+    reason: str = ""
+    meta: dict = field(default_factory=dict)
+
+
+class UtilityGate:
+    """二元效用门：Gate(s,a) = 1 iff U(s,a) >= θ。"""
+
+    def __init__(self, utility: UtilityFunction | Callable[[Any, Any], float], theta: float = 0.0):
+        if utility is None:
+            raise ValueError(
+                "UtilityGate requires an explicit utility function. "
+                "There is no fail-open mode: the gate is the sole dispatch channel."
+            )
+        # FIX2-2：theta 必须有限（拒 NaN/±inf）且非负
+        if not math.isfinite(theta) or theta < 0:
+            raise ValueError("theta must be finite and >= 0 (paper Definition 3)")
+        self._utility = utility
+        self.theta = float(theta)
+
+    def evaluate(self, state: Any, action: Any) -> GateDecision:
+        # FIX-2：效用函数异常视同 U=−∞ 拒绝（fail-closed），不穿透 step()；
+        # meta 载明错误类型，由 runtime 落 gate_error 审计（与 execute 异常分属）。
+        try:
+            u = float(self._utility(state, action))
+        except Exception as exc:
+            err = f"{type(exc).__name__}: {exc}"
+            return GateDecision(
+                admitted=False,
+                utility=float("-inf"),
+                theta=self.theta,
+                reason=f"gate_error: utility raised {err} (treated as U=-inf)",
+                meta={"gate_error": err},
+            )
+        # FIX4-1：非有限效用门内校验——同一把尺两个方向都闭上：
+        # NaN 靠 IEEE 碰巧 fail-closed，但 +inf >= θ 恒真会放行（fail-open）。
+        # 非有限一律拒绝，reason 载明值（审计落盘时经 FIX2-6 带符号消毒标记）。
+        if not math.isfinite(u):
+            return GateDecision(
+                admitted=False,
+                utility=u,
+                theta=self.theta,
+                reason=f"nonfinite utility: {u!r} (fail-closed)",
+            )
+        admitted = u >= self.theta
+        return GateDecision(
+            admitted=admitted,
+            utility=u,
+            theta=self.theta,
+            reason="" if admitted else f"U={u:.4f} < theta={self.theta:.4f}",
+        )

entropy_sdk/gear.py

@@ -0,0 +1,35 @@
+"""
+Gear 状态系统（论文 Definition 1）
+
+五级执行档位，动作空间单调嵌套：A0 ⊂ A1 ⊂ A2 ⊂ A3 ⊂ A4 = A。
+档位的语义是"动作空间的上限"，不是速度——降级收缩的是 agent 能做什么，
+不是做得多慢。
+"""
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class Gear(IntEnum):
+    OBSERVE = 0    # G0: 只读观察 / 安全保持，无副作用
+    SUGGEST = 1    # G1: 生成候选计划，无外部副作用
+    PLAN = 2       # G2: 有界、可逆或保全性恢复动作
+    EXECUTE = 3    # G3: 可独立选择有副作用的动作
+    INTEGRATE = 4  # G4: 系统级协调（多智能体下为涌现属性，见论文 §6.3）
+
+    @property
+    def label(self) -> str:
+        return _LABELS[self]
+
+    def permits(self, required: "Gear") -> bool:
+        """嵌套动作空间：当前档位 g 允许所有 required_gear <= g 的动作。"""
+        return Gear(required) <= self
+
+
+_LABELS = {
+    Gear.OBSERVE: "Observe",
+    Gear.SUGGEST: "Suggest",
+    Gear.PLAN: "Plan",
+    Gear.EXECUTE: "Execute",
+    Gear.INTEGRATE: "Integrate",
+}

entropy_sdk/policy.py

@@ -0,0 +1,55 @@
+"""
+Gear 转移策略（论文 §4 Gear state machine）
+
+慢升快降（earned autonomy）：
+- 升档：σ < σ_low 且连续 h 个干净周期 → 升一档
+- 降档：σ > σ_high 或 ϵ=1 → 立即降一档
+- 否则：保持
+"""
+from __future__ import annotations
+
+import math
+
+from dataclasses import dataclass
+
+from .gear import Gear
+from .state import RuntimeState
+
+
+@dataclass(frozen=True)
+class GearPolicy:
+    sigma_low: float = 0.3    # 升档门槛
+    sigma_high: float = 1.0   # 降档门槛
+    patience: int = 3         # h：升档所需连续干净周期
+    sigma_decay: float = 0.1  # δ：动作被接受时 σ 的衰减
+    sigma_step: float = 0.1   # Δσ：fallback 失败时 σ 的增量
+
+    def __post_init__(self):
+        # FIX-3a + FIX2-2：非法参数构造即抛（fail-closed）
+        # ——finite 校验：patience=NaN 会静默锁死 G0（clean_streak>=NaN 恒 False），
+        #   patience=1.5 会静默变 2；σ 族 NaN/±inf 同理拒收
+        for name in ("sigma_low", "sigma_high", "sigma_decay", "sigma_step"):
+            v = getattr(self, name)
+            if not (isinstance(v, (int, float)) and math.isfinite(v)):
+                raise ValueError(f"{name} must be finite, got {v!r}")
+        if isinstance(self.patience, bool) or not (
+            isinstance(self.patience, int)
+            or (isinstance(self.patience, float) and self.patience.is_integer())
+        ):
+            raise ValueError(f"patience must be an integer, got {self.patience!r}")
+        if self.patience < 1:
+            raise ValueError("patience must be >= 1")
+        if self.sigma_decay < 0:
+            raise ValueError("sigma_decay must be >= 0")
+        if self.sigma_step < 0:
+            raise ValueError("sigma_step must be >= 0")
+        if not self.sigma_low < self.sigma_high:
+            raise ValueError("sigma_low must be < sigma_high")
+
+    def next_gear(self, state: RuntimeState) -> Gear:
+        g = state.gear
+        if state.sigma > self.sigma_high or state.error:
+            return Gear(max(int(g) - 1, int(Gear.OBSERVE)))
+        if state.sigma < self.sigma_low and state.clean_streak >= self.patience:
+            return Gear(min(int(g) + 1, int(Gear.INTEGRATE)))
+        return g

entropy_sdk/runtime.py

@@ -0,0 +1,278 @@
+"""
+EntropyRuntime 控制循环（论文 §4 Algorithm 1）
+
+每周期四阶段：观察与档位评估 → 动作生成 → 效用门 → 执行与反馈。
+门是唯一调度通道：被拒绝的动作绝不执行（Theorem 2）。
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from .fallback import AlternativeProposer, FallbackConfig
+from .gate import GateDecision, UtilityFunction, UtilityGate
+from .gear import Gear
+from .policy import GearPolicy
+from .state import AuditLog, RuntimeState
+
+
+def _safe_gear(value: Any) -> Gear | None:
+    """把调用方声明的 required_gear 收敛成合法 Gear；非法值返回 None（FIX-4）。
+
+    required_gear 是调用方声明契约（attestation）——标签不可信时
+    fail-closed：视同「不允许」，走档位前置闸拒绝路径，不抛栈穿透。
+    """
+    if isinstance(value, Gear):
+        return value
+    if isinstance(value, bool):
+        # IntEnum 值查找里 True==1 会静默成 SUGGEST——显式拒绝（已实测验证的洞）
+        return None
+    if not isinstance(value, int):
+        # 拒绝 float/str/None/object（含 3.9、3.7、"3"、"EXECUTE"）
+        return None
+    try:
+        return Gear(value)
+    except (TypeError, ValueError, OverflowError):
+        # OverflowError：±inf 的 int() 转换（DEF-1 并案）
+        return None
+
+
+@dataclass
+class CycleResult:
+    """单周期结果。"""
+
+    executed: bool
+    action: Any
+    gate: GateDecision | None
+    gear_before: Gear
+    gear_after: Gear
+    used_fallback: bool = False
+    suspended: bool = False
+    result: Any = None
+    error: str | None = None
+
+
+class EntropyRuntime:
+    """可嵌入的档位安全控制层。
+
+    用法（最小闭环）::
+
+        runtime = EntropyRuntime(utility=my_utility, theta=0.15)
+        result = runtime.step(
+            state=my_state,
+            action=agent_proposed_action,          # 必须带 required_gear
+            execute=lambda a: actually_do(a),
+        )
+
+    动作对象只需暴露 ``required_gear``（int 或 Gear）；
+    可用 ``adapters.raw.action()`` 一键包装任意 callable。
+    """
+
+    def __init__(
+        self,
+        utility: UtilityFunction,
+        theta: float = 0.0,
+        policy: GearPolicy | None = None,
+        fallback: FallbackConfig | None = None,
+        audit_log: AuditLog | str | None = None,
+        initial_gear: Gear = Gear.OBSERVE,
+    ):
+        self.gate = UtilityGate(utility, theta=theta)
+        self.policy = policy or GearPolicy()
+        self.fallback_cfg = fallback or FallbackConfig()
+        self.audit = audit_log if isinstance(audit_log, AuditLog) else AuditLog(audit_log)
+        # FIX3-4：initial_gear 与 required_gear 同一严格度（strict attestation）
+        gear0 = _safe_gear(initial_gear)
+        if gear0 is None:
+            raise ValueError(f"invalid initial_gear {initial_gear!r} "
+                             "(want Gear instance or plain int 0-4)")
+        self.state = RuntimeState(gear=gear0)
+        self.audit.record("init", gear=int(self.state.gear), theta=theta)
+
+    # ------------------------------------------------------------------ #
+
+    def step(
+        self,
+        state: Any,
+        action: Any,
+        execute: Callable[[Any], Any],
+        propose_alternative: AlternativeProposer | None = None,
+    ) -> CycleResult:
+        """执行一个控制周期（Algorithm 1 的一次迭代）。"""
+        if self.state.suspended:
+            self.audit.record("suspended_skip", cycle=self.state.cycle)
+            return CycleResult(
+                executed=False, action=None, gate=None,
+                gear_before=self.state.gear, gear_after=self.state.gear,
+                suspended=True, error="suspended: awaiting human review",
+            )
+
+        gear_before = self.state.gear
+        result = self._dispatch(state, action, execute, propose_alternative)
+
+        # 更新 σ / ϵ / clean_streak（Algorithm 1, lines 7/11/13）
+        if result.executed and not result.used_fallback:
+            self.state.sigma = max(0.0, self.state.sigma - self.policy.sigma_decay)
+            self.state.error = False
+            self.state.clean_streak += 1
+            self.state.consecutive_rejections = 0
+        elif result.executed and result.used_fallback:
+            self.state.error = False  # σ 保持不变
+            self.state.clean_streak += 1
+            self.state.consecutive_rejections = 0
+        else:
+            self.state.sigma += self.policy.sigma_step
+            self.state.error = True
+            self.state.clean_streak = 0
+            self.state.consecutive_rejections += 1
+
+        # 换挡（π_G）
+        gear_after = self.policy.next_gear(self.state)
+        if gear_after != self.state.gear:
+            self.audit.record(
+                "gear_transition", cycle=self.state.cycle,
+                **{"from": int(self.state.gear), "to": int(gear_after)},
+                sigma=round(self.state.sigma, 4),
+            )
+            # FIX2-4 + FIX3-2：换挡即清零 clean_streak——每一档都要重新挣满 h 个
+            # 连续干净周期。升降档同律：FIX2-4 原判词「拒绝分支已先清零」不覆盖
+            # σ 降档路径（成功执行但 σ 超阈的降档会残留 streak，窄 σ 带下提前 1 周期升档）。
+            if gear_after != self.state.gear:
+                self.state.clean_streak = 0
+            self.state.gear = gear_after
+
+        # m 次连续拒绝 → G0 挂起（Theorem 4 的终点）
+        if self.state.consecutive_rejections >= self.fallback_cfg.max_consecutive_rejections:
+            # FIX-5a：挂起导致的硬降档也要在链上留 gear_transition（换挡不许静默）
+            if self.state.gear != Gear.OBSERVE:
+                self.audit.record(
+                    "gear_transition", cycle=self.state.cycle,
+                    **{"from": int(self.state.gear), "to": int(Gear.OBSERVE)},
+                    sigma=round(self.state.sigma, 4), reason="suspend",
+                )
+            self.state.gear = Gear.OBSERVE
+            self.state.suspended = True
+            result.suspended = True
+            self.audit.record("suspend", cycle=self.state.cycle,
+                              consecutive_rejections=self.state.consecutive_rejections)
+
+        result.gear_before = gear_before
+        result.gear_after = self.state.gear
+        self.state.cycle += 1
+        return result
+
+    def resume(self) -> None:
+        """人工复核后解除挂起（从 G0 重新开始挣档位）。"""
+        self.state.suspended = False
+        self.state.consecutive_rejections = 0
+        self.state.error = False
+        self.audit.record("resume", cycle=self.state.cycle)
+
+    # ------------------------------------------------------------------ #
+
+    def _dispatch(
+        self,
+        state: Any,
+        action: Any,
+        execute: Callable[[Any], Any],
+        propose_alternative: AlternativeProposer | None,
+    ) -> CycleResult:
+        required = _safe_gear(getattr(action, "required_gear", Gear.EXECUTE))
+
+        # FIX-4：非法 required_gear 视同档位不允许（fail-closed），不抛栈穿透
+        if required is None:
+            self.audit.record(
+                "gate_decision", cycle=self.state.cycle, admitted=False,
+                reason=f"invalid required_gear "
+                       f"{getattr(action, 'required_gear', None)!r} (attestation rejected)",
+            )
+            alt = self._try_alternatives(state, action, execute, propose_alternative)
+            if alt is not None:
+                return alt
+            return CycleResult(False, action, None, self.state.gear, self.state.gear)
+
+        # 档位前置闸：超出当前动作空间的动作连门都不进
+        if not self.state.gear.permits(required):
+            self.audit.record(
+                "gate_decision", cycle=self.state.cycle, admitted=False,
+                reason=f"gear {self.state.gear.label} does not permit {required.label}",
+            )
+            alt = self._try_alternatives(state, action, execute, propose_alternative)
+            if alt is not None:
+                return alt
+            return CycleResult(False, action, None, self.state.gear, self.state.gear)
+
+        decision = self.gate.evaluate(state, action)
+        self.audit.record(
+            "gate_decision", cycle=self.state.cycle, admitted=decision.admitted,
+            utility=round(decision.utility, 4), theta=decision.theta, reason=decision.reason,
+        )
+        # FIX-2：效用异常视同 U=−∞ 拒绝（fail-closed），审计事件与 execute 异常分属
+        if decision.meta.get("gate_error"):
+            self.audit.record("gate_error", cycle=self.state.cycle,
+                              error=decision.meta["gate_error"])
+        if decision.admitted:
+            return self._run(action, execute, decision, used_fallback=False)
+
+        alt = self._try_alternatives(state, action, execute, propose_alternative)
+        if alt is not None:
+            return alt
+        return CycleResult(False, action, decision, self.state.gear, self.state.gear)
+
+    def _try_alternatives(
+        self,
+        state: Any,
+        rejected: Any,
+        execute: Callable[[Any], Any],
+        propose_alternative: AlternativeProposer | None,
+    ) -> CycleResult | None:
+        if propose_alternative is None or self.fallback_cfg.max_alternatives == 0:
+            # FIX2-3：max_alternatives=0 是合法配置——关闭 fallback，
+            # proposer 零调用，直接进 σ/降档/挂起流程
+            return None
+        for i in range(self.fallback_cfg.max_alternatives):
+            # FIX-1：proposer 异常视同无备选——记审计后走正常拒绝分支，
+            # 不穿透 step()（对齐 Theorem 4：拒绝路径的 σ/挂起语义照常生效）
+            try:
+                alt = propose_alternative(state, rejected, i)
+            except Exception as exc:
+                self.audit.record(
+                    "proposer_error", cycle=self.state.cycle, attempt_index=i,
+                    error=type(exc).__name__,
+                )
+                break
+            if alt is None:
+                break
+            required = _safe_gear(getattr(alt, "required_gear", Gear.EXECUTE))
+            if required is None:  # FIX-4：非法 gear 视同不允许
+                self.audit.record(
+                    "gate_decision", cycle=self.state.cycle, admitted=False,
+                    reason=f"fallback#{i}: invalid required_gear "
+                           f"{getattr(alt, 'required_gear', None)!r} (attestation rejected)",
+                )
+                continue
+            if not self.state.gear.permits(required):
+                continue
+            decision = self.gate.evaluate(state, alt)
+            self.audit.record(
+                "gate_decision", cycle=self.state.cycle, admitted=decision.admitted,
+                utility=round(decision.utility, 4), theta=decision.theta,
+                reason=f"fallback#{i}: {decision.reason}",
+            )
+            if decision.meta.get("gate_error"):
+                self.audit.record("gate_error", cycle=self.state.cycle,
+                                  error=decision.meta["gate_error"])
+            if decision.admitted:
+                return self._run(alt, execute, decision, used_fallback=True)
+        return None
+
+    def _run(self, action, execute, decision, used_fallback) -> CycleResult:
+        try:
+            out = execute(action)
+            self.audit.record("execute", cycle=self.state.cycle, fallback=used_fallback)
+            return CycleResult(True, action, decision, self.state.gear, self.state.gear,
+                               used_fallback=used_fallback, result=out)
+        except Exception as exc:  # 执行异常按拒绝处理：σ 上升、ϵ=1
+            self.audit.record("execute_error", cycle=self.state.cycle, error=str(exc))
+            return CycleResult(False, action, decision, self.state.gear, self.state.gear,
+                               used_fallback=used_fallback, error=str(exc))

entropy_sdk/state.py

@@ -0,0 +1,156 @@
+"""
+运行时状态 ρ=(g, σ, ϵ) 与 append-only 审计链（论文 Definition 4）
+
+审计链是 SDK 的一等公民：每次门判定、换挡、fallback、挂起都落一条 JSONL。
+这条链就是论文 Section 5/8 所需的实证数据来源（gate 接受率、gear 转移直方图）。
+"""
+from __future__ import annotations
+
+import json
+import math
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .gear import Gear
+
+
+@dataclass
+class RuntimeState:
+    """单 agent 运行时状态（环境状态 s 由使用者持有，此处只保留控制量）。"""
+
+    gear: Gear = Gear.OBSERVE
+    sigma: float = 0.0          # σ：累积不稳定度
+    error: bool = False         # ϵ：错误标志
+    cycle: int = 0              # t：离散周期计数
+    clean_streak: int = 0       # 连续干净周期数（升档耐心计数）
+    consecutive_rejections: int = 0
+    suspended: bool = False     # m 次连续拒绝后挂起，等待人工复核
+
+    def snapshot(self) -> dict:
+        d = asdict(self)
+        d["gear"] = int(self.gear)
+        d["gear_label"] = self.gear.label
+        return d
+
+
+# FIX5-1：嵌套容器内非有限 float 的递归消毒深度上限（防深递归炸栈）
+_SANITIZE_MAX_DEPTH = 32
+
+
+def _sanitize_nonfinite(value: Any, _depth: int = 0, _seen: set | None = None) -> Any:
+    """递归消毒嵌套 dict/list/tuple 里的非有限 float → 字符串标记
+    （"nan"/"+inf"/"-inf"，与顶层记号同族）。
+
+    防循环引用：沿当前递归路径的 id set（离开分支即摘除，故共享但不成环的
+    兄弟引用不误伤）；防深递归：深度超 _SANITIZE_MAX_DEPTH 截断为标记。
+    非容器、非浮点类型原样透传。
+    """
+    if isinstance(value, float):
+        if math.isfinite(value):
+            return value
+        return "nan" if math.isnan(value) else ("+inf" if value > 0 else "-inf")
+    if isinstance(value, (dict, list, tuple)):
+        if _seen is None:
+            _seen = set()
+        if _depth >= _SANITIZE_MAX_DEPTH or id(value) in _seen:
+            return "<truncated:depth-or-cycle>"
+        _seen.add(id(value))
+        try:
+            if isinstance(value, dict):
+                return {k: _sanitize_nonfinite(v, _depth + 1, _seen)
+                        for k, v in value.items()}
+            if isinstance(value, list):
+                return [_sanitize_nonfinite(v, _depth + 1, _seen) for v in value]
+            return tuple(_sanitize_nonfinite(v, _depth + 1, _seen) for v in value)
+        finally:
+            _seen.discard(id(value))
+    return value
+
+
+class AuditLog:
+    """append-only JSONL 审计链。只追加，不修改，不落盘失败则抛错（fail-closed）。"""
+
+    def __init__(self, path: str | Path | None = None):
+        self.path = Path(path) if path else None
+        self._buffer: list[dict] = []
+        self.corrupt_lines: int = 0  # FIX-5c：最近一次读盘跳过的坏行数（内存模式恒 0）
+        # FIX2-5：文件模式读缓存——按 (mtime_ns, size) 失效。
+        # 选型理由：iter_entries() 生成器救不了 metrics 的重复读
+        #（acceptance_rate + histogram 各过一遍），缓存一次失效模型两者通吃。
+        self._cache_key: tuple | None = None
+        self._cache_entries: list[dict] = []
+
+    def record(self, kind: str, **fields: Any) -> dict:
+        # FIX-5d：非有限浮点（NaN/Inf）消毒为 null + 同名字段加 _nonfinite 标记，
+        # 保证 JSONL 对严格解析器合法（门对 NaN 效用的 fail-closed 行为不变）
+        clean: dict[str, Any] = {}
+        for k, v in fields.items():
+            if isinstance(v, float) and not math.isfinite(v):
+                clean[k] = None
+                # FIX2-6：消毒标记带符号（+inf / -inf / nan），保住信息区分度
+                clean[f"{k}_nonfinite"] = (
+                    "nan" if math.isnan(v) else ("+inf" if v > 0 else "-inf")
+                )
+            else:
+                # FIX5-1：嵌套容器递归消毒（顶层既有行为与标记格式不动）
+                clean[k] = _sanitize_nonfinite(v)
+        entry = {"ts": time.time(), "kind": kind, **clean}
+        if self.path:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            with self.path.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(entry, ensure_ascii=False, default=str) + "\n")
+        else:
+            self._buffer.append(entry)
+        return entry
+
+    @property
+    def entries(self) -> list[dict]:
+        # FIX-5b：文件模式与 metrics 同语义——读盘返回（README 主推路径不再恒空）
+        # FIX2-5：经缓存（mtime+size 失效），metrics 连读不重复扫盘
+        # FIX3-1：对外逐条浅拷贝——调用方涂改返回值不污染缓存与磁盘真值
+        #（条目值无嵌套结构，浅拷贝足够；内部 metrics 继续用缓存引用）
+        return [dict(e) for e in self._read_all()]
+
+    def _read_all(self) -> list[dict]:
+        if self.path and self.path.exists():
+            st = self.path.stat()
+            key = (st.st_mtime_ns, st.st_size)
+            if key != self._cache_key:
+                entries = []
+                corrupt = 0
+                with self.path.open(encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            entries.append(json.loads(line))
+                        except json.JSONDecodeError:
+                            # FIX-5c：坏行跳过并计数，不崩
+                            corrupt += 1
+                self._cache_key = key
+                self._cache_entries = entries
+                self.corrupt_lines = corrupt
+            return list(self._cache_entries)
+        self.corrupt_lines = 0
+        return list(self._buffer)
+
+    def gear_histogram(self) -> dict[int, int]:
+        """gear 转移直方图（Theorem 3 最终镇定的经验证据）。"""
+        hist: dict[int, int] = {}
+        for e in self._iter_all():
+            if e.get("kind") == "gear_transition":
+                hist[e["to"]] = hist.get(e["to"], 0) + 1
+        return hist
+
+    def gate_acceptance_rate(self) -> float | None:
+        """门接受率（Theorem 1 关键假设 p1 >= p3 的经验观测口径）。"""
+        decisions = [e for e in self._iter_all() if e.get("kind") == "gate_decision"]
+        if not decisions:
+            return None
+        return sum(1 for e in decisions if e["admitted"]) / len(decisions)
+
+    def _iter_all(self):
+        yield from self._read_all()

entropy_sdk-0.1.5.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: entropy-sdk
+Version: 0.1.5
+Summary: Gear-based safety control layer for autonomous agents (EntropyRuntime core, embeddable SDK)
+Author-email: Wang Miaosheng <wmsmiaosheng@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/CYD-PRC/entropy-sdk
+Project-URL: Paper, https://arxiv.org/abs/2607.00334
+Keywords: ai-safety,agent,governance,runtime-verification,gear
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: langchain
+Requires-Dist: langchain-core<1.0,>=0.2.43; extra == "langchain"
+Provides-Extra: pydanticai
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# entropy-sdk
+
+**An embeddable, gear-based safety control layer for autonomous agents** — the
+SDK distillation of the EntropyRuntime paper's core abstractions
+([arXiv:2607.00334](https://arxiv.org/abs/2607.00334)).
+
+> Make an AI's degree of autonomy observable, governable, and accountable.
+
+[![test](https://github.com/CYD-PRC/entropy-sdk/actions/workflows/test.yml/badge.svg)](https://github.com/CYD-PRC/entropy-sdk/actions/workflows/test.yml)
+![license](https://img.shields.io/badge/license-MIT-blue)
+![python](https://img.shields.io/badge/python-%3E%3D3.10-blue)
+
+> Test readings are reported from **raw CI logs, not badge conclusions**:
+> latest verified reading — **96 passed / 0 skipped** across Python 3.10–3.13
+> (Actions run inspected line-by-line). A green badge alone is not evidence.
+
+Unlike [CYD-PRC/entropyruntime](https://github.com/CYD-PRC/entropyruntime)
+(the full production system — FastAPI + PostgreSQL + Redis + OPA), this
+repository is the **zero-dependency, embeddable** minimal control layer:
+`pip install` and five lines of code wire it into any agent loop.
+
+## Core abstractions
+
+| Abstraction | Paper | SDK |
+|---|---|---|
+| Five-level gear ladder G0–G4 | Definition 1 (𝒜₀⊂…⊂𝒜₄) | `Gear` |
+| Utility gate U(s,a) ≥ θ | Definitions 2–3, Theorem 2 | `UtilityGate` |
+| Slow-up-fast-down state machine | §4 Gear state machine | `GearPolicy` |
+| Event-driven fallback | Theorem 4 | `FallbackConfig` |
+| Runtime state ρ=(g,σ,ϵ) | Definition 4 | `RuntimeState` |
+| Audit chain | §5/§8 empirical requirements | `AuditLog` (append-only JSONL) |
+
+## Design rules
+
+1. **Pure stdlib core, zero dependencies.** Framework adapters (LangChain /
+   PydanticAI) ship as optional extras.
+2. **fail-closed.** The utility function must be injected explicitly; there is
+   no fail-open switch — the utility gate is the sole dispatch channel
+   (Theorem 2, enforced in code).
+3. **Audit chain built in.** Every gate decision, gear transition, and
+   suspension is appended to JSONL. `gate_acceptance_rate()` and
+   `gear_histogram()` produce the empirical data that the paper's Theorem 1
+   assumption and Theorem 3 prediction call for.
+
+## Quickstart
+
+```bash
+pip install entropy-sdk
+```
+
+```python
+from entropy_sdk import EntropyRuntime, Gear, action, observe
+
+# 1. Inject your domain utility function (the SDK ships no built-in U)
+def my_utility(state, act):
+    return state.task_gain(act) + 2.0 * state.safety(act) - 0.5 * act.cost
+
+# Note: action()'s **kwargs are call parameters of the wrapped function,
+# not utility metadata. Feed metadata to the utility via post-creation
+# assignment (act.utility_value = ... style).
+# 2. Create the runtime (theta is the only safety-vs-output knob)
+runtime = EntropyRuntime(utility=my_utility, theta=0.15,
+                         audit_log="audit.jsonl")
+
+# 3. Every agent action goes through the gate
+result = runtime.step(
+    state=my_state,
+    action=action(delete_records, "users", required_gear=Gear.EXECUTE),
+    execute=lambda a: a(),
+    propose_alternative=my_fallback_planner,  # optional: rejected-action fallback
+)
+
+if result.suspended:
+    alert_human()          # m consecutive rejections -> suspend at G0, await review
+    runtime.resume()       # after human review, gears must be re-earned
+```
+
+### Gear semantics
+
+| Gear | Name | Permitted actions |
+|---|---|---|
+| G0 | Observe | Read-only observation, safe holding |
+| G1 | Suggest | Side-effect-free candidate plans |
+| G2 | Plan | Bounded, reversible recovery actions |
+| G3 | Execute | Independently chosen side-effecting actions |
+| G4 | Integrate | System-level coordination (an emergent property of all-G3 fleets) |
+
+**Slow up, fast down** (earned autonomy): escalation requires σ < σ_low **and**
+h consecutive clean cycles — every gear must be re-earned (v0.1.2+);
+de-escalation on σ overflow or error is immediate. Autonomy is earned, and it
+can always be revoked.
+
+A runnable version of this narrative lives in
+[`examples/lifecycle_demo.py`](examples/lifecycle_demo.py)
+(`python examples/lifecycle_demo.py`).
+
+## Framework adapters
+
+```python
+# LangChain: pip install entropy-sdk[langchain]
+from entropy_sdk.adapters.langchain import gated_tool
+safe_tool = gated_tool(runtime, my_tool, required_gear=Gear.EXECUTE)
+
+# PydanticAI-compatible callable decorator: pip install entropy-sdk[pydanticai]
+from entropy_sdk.adapters.pydanticai import gated
+
+@gated(runtime, required_gear=Gear.EXECUTE)
+def delete_records(table: str) -> str: ...
+```
+
+On rejection the adapters **return an explanatory string instead of raising** —
+rejection itself is feedback the agent can act on next turn.
+
+(Note on naming: this is a **PydanticAI-compatible callable decorator**, not a
+true PydanticAI adapter — it is a pure stdlib decorator with zero framework
+dependencies (the `pydanticai` extra list is intentionally empty, FIX-8) and has
+**not been validated against a real PydanticAI runtime**. Just
+`from entropy_sdk.adapters.pydanticai import gated`.)
+
+(LangChain boundary: `args_schema` passthrough only works for real
+StructuredTool instances carrying a schema; bare tool objects (func only, no
+args_schema) remain limited by the wrapper's `*args/**kwargs` signature.)
+
+## Threat model boundaries (paper armor — read before deploying)
+
+1. **The gate is the sole dispatch channel — only inside execution paths the
+   SDK controls.** A caller holding the raw callable can bypass the gate
+   (`tool.func(...)` skips it); the SDK governs calls that go through
+   `runtime.step`, not references in the caller's hands.
+2. **`required_gear` is a caller-side attestation contract.** The SDK trusts
+   the label's truthfulness; whether labels may be trusted (who is allowed to
+   tag an action's gear) is the deployer's responsibility — the SDK
+   fail-closes on *invalid* values, but is not responsible for
+   under-tagged powerful actions.
+3. **The gate governs invocation, not transactions.** Side effects that
+   already happened inside `execute` are not rolled back — the semantics are
+   invocation control, not atomicity. Implement compensation in your own
+   `execute` if you need transactional behavior.
+4. **`resume()` does not clear σ** (design semantics, not a bug): human
+   review ≠ instant restoration of trust — σ persists after resuming, and
+   gears must be re-earned through clean cycles.
+5. **`except Exception` does not cover `BaseException`**: if a
+   proposer/execute callback raises SystemExit/KeyboardInterrupt, the state
+   machine can still desynchronize — this is standard Python practice;
+   callers must not raise BaseException inside callbacks.
+6. **Concurrency**: the runtime is lock-free. Under current CPython (GIL),
+   8000/8000 cycles measured with no lost updates; on free-threaded Python
+   (3.13t+), the read-modify-write of cycle/σ can lose updates — serialize
+   externally when using multiple threads.
+7. **A deleted audit file reads as empty** (fail-open read path): in file
+   mode, `entries`/metrics return empty results for a missing chain file
+   rather than raising — asymmetric with the fail-closed write path. Deployers
+   should monitor the audit file's existence (a missing append-only chain file
+   is itself an event).
+
+## Empirical data API
+
+```python
+runtime.audit.gate_acceptance_rate()  # gate acceptance rate (Theorem 1, p1≥p3)
+runtime.audit.gear_histogram()        # gear transition histogram (Theorem 3)
+```
+
+Every run produces data for the framework's empirical validation — a unique
+value of the SDK relative to the full system.
+
+## Changelog & security record
+
+- [CHANGELOG.md](CHANGELOG.md) — versioned changes, including behavior-change
+  and compatibility notes.
+- 中文文档：[README.zh-CN.md](README.zh-CN.md)
+
+## License
+
+MIT © Wang Miaosheng (ORCID: 0009-0003-2767-2421) — see [LICENSE](LICENSE).

entropy_sdk-0.1.5.dist-info/RECORD

@@ -0,0 +1,18 @@
+entropy_sdk/__init__.py,sha256=GVGNLD7hYPV8HiemshtT9Rf7Pr1nvNiJw6DqI6rITpI,909
+entropy_sdk/fallback.py,sha256=b0qq7OHj6o5EZHOJ2EJRZzFUyYQFC21RZneKG8H0S2A,1937
+entropy_sdk/gate.py,sha256=j6G979OiYmcpn940IfvN_5ymxVETjAfDLvk_0lZaypg,3121
+entropy_sdk/gear.py,sha256=XBBoYP4g5cev9jvxdYtSfEUMG0kuuVcCiR_AHCJ1Q3Q,1116
+entropy_sdk/policy.py,sha256=Bn3BknnhXmv5aoCVb8s1VvN9wrx2ZCKQ8sSW7UUKJ0U,2242
+entropy_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+entropy_sdk/runtime.py,sha256=_lnXUkIM1ME46diElxjyeNmd2oiXV8SVesQvODNIHzY,12182
+entropy_sdk/state.py,sha256=tX_tmg4kCcSyIH2Da2wiRiLJBesSgZelQkkPBXPVnvs,6760
+entropy_sdk/adapters/__init__.py,sha256=0GJwytV8g_S73_H-BJUyxdu1bl9mi5k5SrwDnQP6NNQ,256
+entropy_sdk/adapters/base.py,sha256=bRLemADErSHEf-rN9M7L1rXJDfZsTUvvr-erMzsRNDA,1067
+entropy_sdk/adapters/langchain.py,sha256=DLQdp8oBlYOe_J_HBb5V9JjOYvsh8x1T3UMaXFQ35as,2383
+entropy_sdk/adapters/pydanticai.py,sha256=o3Li0oeZhj8nud5wqEIYhP91i4pXzGssEa3bWM0T7YY,1622
+entropy_sdk/adapters/raw.py,sha256=oFDi7zoUqCJx4oA9Ym95kROO77JhUlyJr9dlWYcg81o,1138
+entropy_sdk-0.1.5.dist-info/licenses/LICENSE,sha256=vWN2USlCU8ER_YfGPw5SdLnANPTMrifsp6BepZI9p_A,1081
+entropy_sdk-0.1.5.dist-info/METADATA,sha256=J8qFtvBEqXI7uBNpzlbd2RMSiiX6BdH767r0i8LYXqw,9002
+entropy_sdk-0.1.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+entropy_sdk-0.1.5.dist-info/top_level.txt,sha256=T23JbLtxHkqL56xH8SatGgs2ppiZBMz8_dahdJHyFko,12
+entropy_sdk-0.1.5.dist-info/RECORD,,

entropy_sdk-0.1.5.dist-info/WHEEL

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

entropy_sdk-0.1.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wang Miaosheng / CYD-PRC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

entropy_sdk-0.1.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+entropy_sdk