loopentx 0.1.0__py3-none-any.whl

loopentx/__init__.py

@@ -0,0 +1,31 @@
+"""
+Loopentx — Write the loop once. Step back. Loopentx runs it forever.
+
+Four layers:
+  Loop        → scheduled / event-triggered autonomous execution
+  Skill       → durable, checkpointed, retryable functions
+  Orchestrator→ scheduling, concurrency, history, hot-deploy
+  Trust       → policy, shadow mode, trust scoring, escalation
+"""
+
+from loopentx.core.loop import loop
+from loopentx.core.skill import skill
+from loopentx.core.context import LoopContext
+from loopentx.core.orchestrator import Orchestrator
+from loopentx.core.config import configure, get_config
+from loopentx.core.events import event, LoopentxEvent
+from loopentx.trust.policy import policy
+
+__all__ = [
+    "loop",
+    "skill",
+    "policy",
+    "event",
+    "configure",
+    "get_config",
+    "LoopContext",
+    "LoopentxEvent",
+    "Orchestrator",
+]
+
+__version__ = "0.1.0"

loopentx/backends/__init__.py

@@ -0,0 +1,11 @@
+"""Loopentx storage backends."""
+from loopentx.backends.base import BaseBackend
+from loopentx.backends.memory import MemoryBackend
+
+__all__ = ["BaseBackend", "MemoryBackend"]
+
+try:
+    from loopentx.backends.redis_backend import RedisBackend
+    __all__.append("RedisBackend")
+except ImportError:
+    pass

loopentx/backends/base.py

@@ -0,0 +1,115 @@
+"""Abstract base class for Loopentx storage backends."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from loopentx.core.models import (
+    RunRecord, StepRecord, SkillRegistration,
+    TrustRecord, ShadowOutput, LoopMemoryRecord, EscalationRecord,
+)
+from loopentx.core.events import LoopentxEvent
+
+
+class BaseBackend(ABC):
+    """Abstract storage interface. Implement to add a new backend.
+
+    Built-in: MemoryBackend (tests), RedisBackend (production).
+    """
+
+    @abstractmethod
+    async def connect(self) -> None: ...
+
+    @abstractmethod
+    async def disconnect(self) -> None: ...
+
+    # ── Runs ──────────────────────────────────────────────────────────────
+    @abstractmethod
+    async def save_run(self, run: RunRecord) -> None: ...
+
+    @abstractmethod
+    async def get_run(self, run_id: str) -> Optional[RunRecord]: ...
+
+    @abstractmethod
+    async def get_runs(
+        self,
+        skill_name: Optional[str] = None,
+        since:      Optional[float] = None,
+        limit:      int = 100,
+    ) -> list[RunRecord]: ...
+
+    # ── Steps ─────────────────────────────────────────────────────────────
+    @abstractmethod
+    async def save_step(self, step: StepRecord) -> None: ...
+
+    @abstractmethod
+    async def get_step_result(self, step_id: str) -> Optional[Any]: ...
+
+    # ── Skill registration ────────────────────────────────────────────────
+    @abstractmethod
+    async def save_skill_registration(self, reg: SkillRegistration) -> None: ...
+
+    @abstractmethod
+    async def get_skill_registration(self, skill_name: str) -> Optional[SkillRegistration]: ...
+
+    @abstractmethod
+    async def list_skill_registrations(self) -> list[SkillRegistration]: ...
+
+    @abstractmethod
+    async def set_skill_active(self, skill_name: str, active: bool) -> None: ...
+
+    async def approve_skill(self, skill_name: str, approved_by: str = "system") -> None:
+        import time
+        reg = await self.get_skill_registration(skill_name)
+        if reg:
+            reg.is_active               = True
+            reg.is_shadow               = False
+            reg.shadow_cycles_remaining = 0
+            reg.approved_at             = time.time()
+            reg.approved_by             = approved_by
+            await self.save_skill_registration(reg)
+
+    # ── Trust ─────────────────────────────────────────────────────────────
+    @abstractmethod
+    async def save_trust_record(self, trust: TrustRecord) -> None: ...
+
+    @abstractmethod
+    async def get_trust_record(self, skill_name: str) -> Optional[TrustRecord]: ...
+
+    @abstractmethod
+    async def record_trust_outcome(self, skill_name: str, success: bool) -> None: ...
+
+    # ── Shadow outputs ────────────────────────────────────────────────────
+    @abstractmethod
+    async def save_shadow_output(
+        self, run_id: str, step_id: str,
+        output: Optional[Any] = None, error: Optional[str] = None,
+    ) -> None: ...
+
+    @abstractmethod
+    async def get_shadow_outputs(self, skill_name: str) -> list[ShadowOutput]: ...
+
+    # ── Loop memory ───────────────────────────────────────────────────────
+    @abstractmethod
+    async def save_loop_memory(self, record: LoopMemoryRecord) -> None: ...
+
+    @abstractmethod
+    async def get_loop_memory(self, loop_name: str) -> Optional[LoopMemoryRecord]: ...
+
+    # ── Escalations ───────────────────────────────────────────────────────
+    @abstractmethod
+    async def save_escalation(self, esc: EscalationRecord) -> None: ...
+
+    @abstractmethod
+    async def get_escalation(self, esc_id: str) -> Optional[EscalationRecord]: ...
+
+    @abstractmethod
+    async def list_pending_escalations(self) -> list[EscalationRecord]: ...
+
+    # ── Events ────────────────────────────────────────────────────────────
+    @abstractmethod
+    async def publish_event(self, evt: LoopentxEvent) -> None: ...
+
+    @abstractmethod
+    async def poll_events(self) -> list[LoopentxEvent]: ...

loopentx/backends/memory.py

@@ -0,0 +1,146 @@
+"""In-memory backend — for testing and local development."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Optional
+
+from loopentx.backends.base import BaseBackend
+from loopentx.core.models import (
+    RunRecord, StepRecord, SkillRegistration, TrustRecord,
+    ShadowOutput, LoopMemoryRecord, EscalationRecord, StepStatus,
+)
+from loopentx.core.events import LoopentxEvent
+
+
+class MemoryBackend(BaseBackend):
+    """In-memory backend. Data is NOT persisted between restarts.
+
+    Use RedisBackend for production.
+
+    Example:
+        from loopentx import configure
+        from loopentx.backends import MemoryBackend
+        configure(backend=MemoryBackend())
+    """
+
+    def __init__(self) -> None:
+        self._runs:        dict[str, RunRecord]          = {}
+        self._steps:       dict[str, StepRecord]         = {}
+        self._skills:      dict[str, SkillRegistration]  = {}
+        self._trust:       dict[str, TrustRecord]        = {}
+        self._shadows:     dict[str, ShadowOutput]       = {}
+        self._memory:      dict[str, LoopMemoryRecord]   = {}
+        self._escalations: dict[str, EscalationRecord]   = {}
+        self._events:      list[LoopentxEvent]           = []
+
+    async def connect(self) -> None: pass
+    async def disconnect(self) -> None: pass
+
+    # ── Runs ──────────────────────────────────────────────────────────────
+    async def save_run(self, run: RunRecord) -> None:
+        self._runs[run.id] = run
+
+    async def get_run(self, run_id: str) -> Optional[RunRecord]:
+        return self._runs.get(run_id)
+
+    async def get_runs(
+        self,
+        skill_name: Optional[str] = None,
+        since:      Optional[float] = None,
+        limit:      int = 100,
+    ) -> list[RunRecord]:
+        runs = list(self._runs.values())
+        if skill_name:
+            runs = [r for r in runs if r.skill_name == skill_name]
+        if since:
+            runs = [r for r in runs if r.started_at >= since]
+        runs.sort(key=lambda r: r.started_at, reverse=True)
+        return runs[:limit]
+
+    # ── Steps ─────────────────────────────────────────────────────────────
+    async def save_step(self, step: StepRecord) -> None:
+        self._steps[step.id] = step
+
+    async def get_step_result(self, step_id: str) -> Optional[Any]:
+        step = self._steps.get(step_id)
+        return step.output if step and step.status == StepStatus.COMPLETED else None
+
+    # ── Skill registration ────────────────────────────────────────────────
+    async def save_skill_registration(self, reg: SkillRegistration) -> None:
+        self._skills[reg.name] = reg
+
+    async def get_skill_registration(self, name: str) -> Optional[SkillRegistration]:
+        return self._skills.get(name)
+
+    async def list_skill_registrations(self) -> list[SkillRegistration]:
+        return list(self._skills.values())
+
+    async def set_skill_active(self, name: str, active: bool) -> None:
+        if name in self._skills:
+            self._skills[name].is_active = active
+
+    # ── Trust ─────────────────────────────────────────────────────────────
+    async def save_trust_record(self, trust: TrustRecord) -> None:
+        self._trust[trust.skill_name] = trust
+
+    async def get_trust_record(self, name: str) -> Optional[TrustRecord]:
+        return self._trust.get(name)
+
+    async def record_trust_outcome(self, name: str, success: bool) -> None:
+        trust = self._trust.get(name) or TrustRecord(skill_name=name)
+        trust.successful_runs += int(success)
+        trust.failed_runs     += int(not success)
+        trust.total_runs      += 1
+        trust.last_updated_at  = time.time()
+        self._trust[name] = trust
+
+    # ── Shadow outputs ────────────────────────────────────────────────────
+    async def save_shadow_output(
+        self, run_id: str, step_id: str,
+        output: Optional[Any] = None, error: Optional[str] = None,
+    ) -> None:
+        run        = self._runs.get(run_id)
+        skill_name = run.skill_name if run else "unknown"
+        key        = f"{run_id}:{step_id}"
+        self._shadows[key] = ShadowOutput(
+            run_id=run_id, skill_name=skill_name,
+            step_id=step_id, output=output, error=error,
+        )
+
+    async def get_shadow_outputs(self, skill_name: str) -> list[ShadowOutput]:
+        return [o for o in self._shadows.values() if o.skill_name == skill_name]
+
+    # ── Loop memory ───────────────────────────────────────────────────────
+    async def save_loop_memory(self, record: LoopMemoryRecord) -> None:
+        self._memory[record.loop_name] = record
+
+    async def get_loop_memory(self, loop_name: str) -> Optional[LoopMemoryRecord]:
+        return self._memory.get(loop_name)
+
+    # ── Escalations ───────────────────────────────────────────────────────
+    async def save_escalation(self, esc: EscalationRecord) -> None:
+        self._escalations[esc.id] = esc
+
+    async def get_escalation(self, esc_id: str) -> Optional[EscalationRecord]:
+        return self._escalations.get(esc_id)
+
+    async def list_pending_escalations(self) -> list[EscalationRecord]:
+        from loopentx.core.models import EscalationStatus
+        return [e for e in self._escalations.values()
+                if e.status == EscalationStatus.PENDING]
+
+    # ── Events ────────────────────────────────────────────────────────────
+    async def publish_event(self, evt: LoopentxEvent) -> None:
+        self._events.append(evt)
+
+    async def poll_events(self) -> list[LoopentxEvent]:
+        events, self._events = self._events[:], []
+        return events
+
+    # ── Test helpers ──────────────────────────────────────────────────────
+    def reset(self) -> None:
+        """Clear all stored data. Use between tests."""
+        self._runs.clear(); self._steps.clear(); self._skills.clear()
+        self._trust.clear(); self._shadows.clear(); self._memory.clear()
+        self._escalations.clear(); self._events.clear()

loopentx/backends/redis_backend.py

@@ -0,0 +1,196 @@
+"""Redis backend for production use."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Optional
+
+import structlog
+
+from loopentx.backends.base import BaseBackend
+from loopentx.core.models import (
+    RunRecord, StepRecord, SkillRegistration, TrustRecord,
+    ShadowOutput, LoopMemoryRecord, EscalationRecord, StepStatus,
+)
+from loopentx.core.events import LoopentxEvent
+
+log = structlog.get_logger()
+
+TTL_RUN   = 30 * 86400   # 30 days
+TTL_STEP  = 30 * 86400
+TTL_EVENT = 86400
+
+
+class RedisBackend(BaseBackend):
+    """Redis-backed storage for Loopentx.
+
+    Requires: pip install loopentx[redis]
+
+    Example:
+        from loopentx import configure
+        from loopentx.backends import RedisBackend
+        configure(backend=RedisBackend("redis://localhost:6379"))
+    """
+
+    def __init__(self, url: str = "redis://localhost:6379", prefix: str = "ltx") -> None:
+        self.url    = url
+        self.prefix = prefix
+        self._r: Any = None
+
+    def _k(self, *parts: str) -> str:
+        return ":".join([self.prefix] + list(parts))
+
+    async def connect(self) -> None:
+        try:
+            import redis.asyncio as aioredis
+        except ImportError:
+            raise ImportError("pip install loopentx[redis]")
+        self._r = aioredis.from_url(self.url, decode_responses=True)
+        await self._r.ping()
+        log.info("redis_backend.connected", url=self.url)
+
+    async def disconnect(self) -> None:
+        if self._r:
+            await self._r.aclose()
+
+    # ── Runs ──────────────────────────────────────────────────────────────
+    async def save_run(self, run: RunRecord) -> None:
+        await self._r.setex(self._k("run", run.id), TTL_RUN, run.model_dump_json())
+        await self._r.zadd(self._k("runs", "all"),  {run.id: run.started_at})
+        await self._r.zadd(self._k("runs", "by", run.skill_name), {run.id: run.started_at})
+
+    async def get_run(self, run_id: str) -> Optional[RunRecord]:
+        d = await self._r.get(self._k("run", run_id))
+        return RunRecord.model_validate_json(d) if d else None
+
+    async def get_runs(
+        self,
+        skill_name: Optional[str] = None,
+        since:      Optional[float] = None,
+        limit:      int = 100,
+    ) -> list[RunRecord]:
+        idx = self._k("runs", "by", skill_name) if skill_name else self._k("runs", "all")
+        ids = await self._r.zrangebyscore(idx, since or "-inf", "+inf", start=0, num=limit)
+        runs = []
+        for rid in ids:
+            r = await self.get_run(rid)
+            if r:
+                runs.append(r)
+        return sorted(runs, key=lambda r: r.started_at, reverse=True)
+
+    # ── Steps ─────────────────────────────────────────────────────────────
+    async def save_step(self, step: StepRecord) -> None:
+        await self._r.setex(self._k("step", step.id), TTL_STEP, step.model_dump_json())
+
+    async def get_step_result(self, step_id: str) -> Optional[Any]:
+        d = await self._r.get(self._k("step", step_id))
+        if not d:
+            return None
+        step = StepRecord.model_validate_json(d)
+        return step.output if step.status == StepStatus.COMPLETED else None
+
+    # ── Skill registration ────────────────────────────────────────────────
+    async def save_skill_registration(self, reg: SkillRegistration) -> None:
+        await self._r.set(self._k("skill", reg.name), reg.model_dump_json())
+        await self._r.sadd(self._k("skills"), reg.name)
+
+    async def get_skill_registration(self, name: str) -> Optional[SkillRegistration]:
+        d = await self._r.get(self._k("skill", name))
+        return SkillRegistration.model_validate_json(d) if d else None
+
+    async def list_skill_registrations(self) -> list[SkillRegistration]:
+        names = await self._r.smembers(self._k("skills"))
+        result = []
+        for n in names:
+            r = await self.get_skill_registration(n)
+            if r:
+                result.append(r)
+        return result
+
+    async def set_skill_active(self, name: str, active: bool) -> None:
+        reg = await self.get_skill_registration(name)
+        if reg:
+            reg.is_active = active
+            await self.save_skill_registration(reg)
+
+    # ── Trust ─────────────────────────────────────────────────────────────
+    async def save_trust_record(self, trust: TrustRecord) -> None:
+        await self._r.set(self._k("trust", trust.skill_name), trust.model_dump_json())
+
+    async def get_trust_record(self, name: str) -> Optional[TrustRecord]:
+        d = await self._r.get(self._k("trust", name))
+        return TrustRecord.model_validate_json(d) if d else None
+
+    async def record_trust_outcome(self, name: str, success: bool) -> None:
+        trust = await self.get_trust_record(name) or TrustRecord(skill_name=name)
+        trust.successful_runs += int(success)
+        trust.failed_runs     += int(not success)
+        trust.total_runs      += 1
+        trust.last_updated_at  = time.time()
+        await self.save_trust_record(trust)
+
+    # ── Shadow outputs ────────────────────────────────────────────────────
+    async def save_shadow_output(
+        self, run_id: str, step_id: str,
+        output: Optional[Any] = None, error: Optional[str] = None,
+    ) -> None:
+        run        = await self.get_run(run_id)
+        skill_name = run.skill_name if run else "unknown"
+        so         = ShadowOutput(run_id=run_id, skill_name=skill_name,
+                                  step_id=step_id, output=output, error=error)
+        key = self._k("shadow", run_id, step_id)
+        await self._r.setex(key, TTL_RUN, so.model_dump_json())
+        await self._r.sadd(self._k("shadows", skill_name), f"{run_id}:{step_id}")
+
+    async def get_shadow_outputs(self, skill_name: str) -> list[ShadowOutput]:
+        members = await self._r.smembers(self._k("shadows", skill_name))
+        result  = []
+        for m in members:
+            run_id, step_id = m.rsplit(":", 1)
+            d = await self._r.get(self._k("shadow", run_id, step_id))
+            if d:
+                result.append(ShadowOutput.model_validate_json(d))
+        return result
+
+    # ── Loop memory ───────────────────────────────────────────────────────
+    async def save_loop_memory(self, record: LoopMemoryRecord) -> None:
+        await self._r.set(self._k("memory", record.loop_name), record.model_dump_json())
+
+    async def get_loop_memory(self, loop_name: str) -> Optional[LoopMemoryRecord]:
+        d = await self._r.get(self._k("memory", loop_name))
+        return LoopMemoryRecord.model_validate_json(d) if d else None
+
+    # ── Escalations ───────────────────────────────────────────────────────
+    async def save_escalation(self, esc: EscalationRecord) -> None:
+        await self._r.setex(self._k("esc", esc.id), TTL_RUN, esc.model_dump_json())
+        await self._r.sadd(self._k("escalations"), esc.id)
+
+    async def get_escalation(self, esc_id: str) -> Optional[EscalationRecord]:
+        d = await self._r.get(self._k("esc", esc_id))
+        return EscalationRecord.model_validate_json(d) if d else None
+
+    async def list_pending_escalations(self) -> list[EscalationRecord]:
+        from loopentx.core.models import EscalationStatus
+        ids    = await self._r.smembers(self._k("escalations"))
+        result = []
+        for eid in ids:
+            e = await self.get_escalation(eid)
+            if e and e.status == EscalationStatus.PENDING:
+                result.append(e)
+        return result
+
+    # ── Events ────────────────────────────────────────────────────────────
+    async def publish_event(self, evt: LoopentxEvent) -> None:
+        k = self._k("events")
+        await self._r.rpush(k, evt.model_dump_json())
+        await self._r.expire(k, TTL_EVENT)
+
+    async def poll_events(self) -> list[LoopentxEvent]:
+        k = self._k("events")
+        events = []
+        for _ in range(50):
+            d = await self._r.lpop(k)
+            if not d:
+                break
+            events.append(LoopentxEvent.model_validate_json(d))
+        return events