aetherorchestrate 2.0.0__py3-none-any.whl

aetherorchestrate/__init__.py

@@ -0,0 +1,16 @@
+"""
+AetherOrchestrate v2.0.0 — Orchestration for the Aether family.
+
+Built through a seven-phase methodology:
+    1. Architectural Specification
+    2. Invariant Definition
+    3. Test Design
+    4. Simulator Implementation
+    5. Test Execution
+    6. Experiments
+    7. Release
+"""
+
+from .__version__ import __version__
+
+__all__ = ["__version__"]

aetherorchestrate/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.0.0"

aetherorchestrate/assignment/__init__.py

@@ -0,0 +1,3 @@
+"""L2 — Assignment layer."""
+from .assigner import assign, AssignmentResult, eligible, preferred_assignee
+__all__ = ["assign", "AssignmentResult", "eligible", "preferred_assignee"]

aetherorchestrate/assignment/assigner.py

@@ -0,0 +1,58 @@
+"""L2 — Assignment (task → agent)."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from ..models import Task, Claim, CapabilityRecord
+from datetime import datetime, timedelta
+
+
+@dataclass
+class AssignmentResult:
+    claim: Claim
+    valid: bool = False
+    note: str = ""
+
+
+def _hash(task_id: str, agent: str) -> str:
+    return hashlib.sha256(f"{task_id}|{agent}".encode()).hexdigest()
+
+
+def eligible(task: Task, agents: list[str], capabilities: list[CapabilityRecord],
+             revoked: set[str] = frozenset()) -> list[str]:
+    """Return the list of eligible agents for a task."""
+    capable = set()
+    for cap in capabilities:
+        if cap.capability in task.requires:
+            capable.add(cap.agent)
+    eligible_set = [a for a in agents if a in capable or not task.requires]
+    return [a for a in eligible_set if a not in revoked]
+
+
+def preferred_assignee(task: Task, agents: list[str], capabilities: list[CapabilityRecord],
+                       revoked: set[str] = frozenset()) -> str:
+    """Return the preferred assignee (deterministic, view-sensitive)."""
+    elig = eligible(task, agents, capabilities, revoked)
+    if not elig:
+        return ""
+    return min(elig, key=lambda a: _hash(task.id, a))
+
+
+def assign(task: Task, agents: list[str], capabilities: list[CapabilityRecord],
+           revoked: set[str] = frozenset(), lease_seconds: int = 60) -> AssignmentResult:
+    """Assign a task to its preferred assignee."""
+    agent = preferred_assignee(task, agents, capabilities, revoked)
+    if not agent:
+        return AssignmentResult(
+            claim=Claim(task_id=task.id, agent="", lease_until=datetime.utcnow()),
+            valid=False,
+            note="no eligible agent",
+        )
+    claim = Claim(
+        task_id=task.id,
+        agent=agent,
+        lease_until=datetime.utcnow() + timedelta(seconds=lease_seconds),
+        signature=f"sig:{agent}:{task.id}",
+    )
+    return AssignmentResult(claim=claim, valid=True, note=f"assigned to {agent}")

aetherorchestrate/cli.py

@@ -0,0 +1,33 @@
+"""AetherOrchestrate CLI."""
+
+from __future__ import annotations
+
+import sys
+from .__version__ import __version__
+
+
+def main() -> int:
+    args = sys.argv[1:]
+    if not args or args[0] == "info":
+        print(f"AetherOrchestrate v{__version__}")
+        print("Status: Phase 4 (Simulator Implementation)")
+        print("Source paper: DOI 10.5281/zenodo.24095399")
+        print("Seven-phase methodology:")
+        print("  1. Architectural Specification  ✅")
+        print("  2. Invariant Definition         ✅")
+        print("  3. Test Design                  ✅")
+        print("  4. Simulator Implementation     ⏳ (in progress)")
+        print("  5. Test Execution               ⏳")
+        print("  6. Experiments                  ⏳")
+        print("  7. Release                      ⏳")
+        return 0
+    if args[0] == "verify":
+        from . import __version__ as v
+        print(f"✅ aetherorchestrate {v} importable")
+        return 0
+    print(f"Unknown command: {args[0]}")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aetherorchestrate/decomposition/__init__.py

@@ -0,0 +1,3 @@
+"""L1 — Decomposition layer."""
+from .decomposer import decompose, DecompositionResult
+__all__ = ["decompose", "DecompositionResult"]

aetherorchestrate/decomposition/decomposer.py

@@ -0,0 +1,32 @@
+"""L1 — Decomposition (goal → tasks)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from ..models import Goal, Task, Decomposition
+
+
+@dataclass
+class DecompositionResult:
+    goal: Goal
+    decomposition: Decomposition
+    valid: bool = False
+    note: str = ""
+
+
+def decompose(goal: Goal, hint: str = "") -> DecompositionResult:
+    """Decompose a goal into tasks (trivial decomposition)."""
+    task = Task(goal_id=goal.id, requires=frozenset(), acceptance=goal.acceptance)
+    decomp = Decomposition(
+        goal_id=goal.id,
+        tasks=[task],
+        edges=[],
+        kappa={task.id: frozenset()},
+        acceptance=goal.acceptance,
+    )
+    return DecompositionResult(
+        goal=goal,
+        decomposition=decomp,
+        valid=decomp.is_acyclic(),
+        note="trivial decomposition" if not hint else "trivial (hint ignored)",
+    )

aetherorchestrate/dependencies/__init__.py

@@ -0,0 +1,3 @@
+"""L4 — Dependency tracking layer."""
+from .graph import build_graph, materialize, DependencyGraph
+__all__ = ["build_graph", "materialize", "DependencyGraph"]

aetherorchestrate/dependencies/graph.py

@@ -0,0 +1,64 @@
+"""L4 — Dependency tracking (task DAG)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from collections import defaultdict
+from ..models import DependencyEdge
+
+
+@dataclass
+class DependencyGraph:
+    nodes: set[str] = field(default_factory=set)
+    edges: list[DependencyEdge] = field(default_factory=list)
+
+    def add_edge(self, edge: DependencyEdge) -> None:
+        self.nodes.add(edge.from_task)
+        self.nodes.add(edge.to_task)
+        self.edges.append(edge)
+
+
+def build_graph(edges: list[DependencyEdge]) -> DependencyGraph:
+    g = DependencyGraph()
+    for e in edges:
+        g.add_edge(e)
+    return g
+
+
+def _has_cycle(nodes: set[str], edges: list[DependencyEdge]) -> bool:
+    adj = defaultdict(list)
+    indeg = {n: 0 for n in nodes}
+    for e in edges:
+        adj[e.from_task].append(e.to_task)
+        indeg[e.to_task] = indeg.get(e.to_task, 0) + 1
+    queue = [n for n, d in indeg.items() if d == 0]
+    visited = 0
+    while queue:
+        cur = queue.pop()
+        visited += 1
+        for nxt in adj[cur]:
+            indeg[nxt] -= 1
+            if indeg[nxt] == 0:
+                queue.append(nxt)
+    return visited != len(nodes)
+
+
+def materialize(g: DependencyGraph) -> DependencyGraph:
+    """Return the acyclic materialization of g (deterministic cycle-breaking).
+
+    Rule: repeatedly remove the edge with greatest id inside a cycle,
+    until no cycle remains. Deterministic function of the edge set.
+    """
+    edges = list(g.edges)
+    while _has_cycle(g.nodes, edges):
+        # Find edges that participate in a cycle, remove the one with max id
+        cyclic_edges = [e for e in edges if _has_cycle(g.nodes, edges)]
+        if not cyclic_edges:
+            break
+        to_remove = max(cyclic_edges, key=lambda e: e.id)
+        edges = [e for e in edges if e.id != to_remove.id]
+
+    result = DependencyGraph(nodes=set(g.nodes))
+    for e in edges:
+        result.add_edge(e)
+    return result

aetherorchestrate/models.py

@@ -0,0 +1,190 @@
+"""AetherOrchestrate v2.0.0 — Core data models.
+
+Implements the 7 entities from SPECIFICATION.md §2.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+import hashlib
+import uuid
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Enums
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    ASSIGNED = "assigned"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class DependencyType(str, Enum):
+    FINISH_TO_START = "finish-to-start"
+    START_TO_START = "start-to-start"
+    DATA = "data"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Entities
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+def _content_id(*parts: str) -> str:
+    """Content-addressed id from parts."""
+    h = hashlib.sha256("|".join(parts).encode()).hexdigest()
+    return h[:16]
+
+
+@dataclass
+class Goal:
+    """E1 — Goal."""
+    id: str = ""
+    description: str = ""
+    authority: str = ""
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    acceptance: str = ""
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = _content_id("goal", self.description, self.authority)
+
+
+@dataclass
+class Task:
+    """E2 — Task."""
+    id: str = ""
+    goal_id: str = ""
+    requires: frozenset[str] = frozenset()
+    acceptance: str = ""
+    duration: Optional[float] = None
+    label: str = ""
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = _content_id(
+                "task",
+                self.goal_id,
+                self.label,
+                str(sorted(self.requires)),
+            )
+
+
+@dataclass
+class Decomposition:
+    """E3 — Decomposition: (T, <, κ, Acc)."""
+    id: str = ""
+    goal_id: str = ""
+    tasks: list[Task] = field(default_factory=list)
+    edges: list[tuple[str, str]] = field(default_factory=list)  # (from_id, to_id)
+    kappa: dict[str, frozenset[str]] = field(default_factory=dict)
+    acceptance: str = ""
+
+    def __post_init__(self):
+        if not self.id:
+            task_ids = sorted(t.id for t in self.tasks)
+            self.id = _content_id("decomp", self.goal_id, ",".join(task_ids))
+
+    def is_acyclic(self) -> bool:
+        """Check that the < relation is acyclic (I2)."""
+        from collections import defaultdict, deque
+        adj = defaultdict(list)
+        indeg = {t.id: 0 for t in self.tasks}
+        for a, b in self.edges:
+            adj[a].append(b)
+            indeg[b] = indeg.get(b, 0) + 1
+        queue = deque([t for t, d in indeg.items() if d == 0])
+        visited = 0
+        while queue:
+            cur = queue.popleft()
+            visited += 1
+            for nxt in adj[cur]:
+                indeg[nxt] -= 1
+                if indeg[nxt] == 0:
+                    queue.append(nxt)
+        return visited == len(indeg)
+
+
+@dataclass
+class DependencyEdge:
+    """E4 — Dependency Edge."""
+    id: str = ""
+    from_task: str = ""
+    to_task: str = ""
+    type: DependencyType = DependencyType.FINISH_TO_START
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = _content_id("edge", self.from_task, self.to_task, self.type.value)
+
+
+@dataclass
+class Claim:
+    """E5 — Claim."""
+    id: str = ""
+    task_id: str = ""
+    agent: str = ""
+    lease_until: datetime = field(default_factory=datetime.utcnow)
+    signature: str = ""
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = _content_id("claim", self.task_id, self.agent, self.lease_until.isoformat())
+
+    def is_active(self, now: Optional[datetime] = None) -> bool:
+        now = now or datetime.utcnow()
+        return now < self.lease_until
+
+
+@dataclass
+class Completion:
+    """E6 — Completion."""
+    id: str = ""
+    task_id: str = ""
+    agent: str = ""
+    result_hash: str = ""
+    evidence: Optional[str] = None
+    completed_at: datetime = field(default_factory=datetime.utcnow)
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = _content_id("completion", self.task_id, self.agent, self.result_hash)
+
+
+@dataclass
+class CapabilityRecord:
+    """E7 — Capability Record."""
+    id: str = ""
+    agent: str = ""
+    capability: str = ""
+    authority: str = ""
+    valid_until: Optional[datetime] = None
+
+    def __post_init__(self):
+        if not self.id:
+            self.id = _content_id("cap", self.agent, self.capability, self.authority)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Public API
+# ═══════════════════════════════════════════════════════════════════════════
+
+__all__ = [
+    "TaskStatus",
+    "DependencyType",
+    "Goal",
+    "Task",
+    "Decomposition",
+    "DependencyEdge",
+    "Claim",
+    "Completion",
+    "CapabilityRecord",
+]

aetherorchestrate/routing/__init__.py

@@ -0,0 +1,3 @@
+"""L5 — Routing layer."""
+from .router import route, RouteResult
+__all__ = ["route", "RouteResult"]

aetherorchestrate/routing/router.py

@@ -0,0 +1,27 @@
+"""L5 — Routing (task → executor)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from ..models import Task, Claim
+
+
+@dataclass
+class RouteResult:
+    delivered: dict[str, bool] = field(default_factory=dict)
+    complete: bool = False
+    note: str = ""
+
+
+def route(tasks: list[Task], claims: list[Claim]) -> RouteResult:
+    """Route tasks to their assignees (direct routing)."""
+    claim_by_task = {c.task_id: c for c in claims if c.is_active()}
+    delivered = {}
+    for t in tasks:
+        c = claim_by_task.get(t.id)
+        delivered[t.id] = c is not None and c.agent != ""
+    return RouteResult(
+        delivered=delivered,
+        complete=all(delivered.values()) if delivered else False,
+        note="direct routing",
+    )

aetherorchestrate/scheduling/__init__.py

@@ -0,0 +1,3 @@
+"""L3 — Scheduling layer."""
+from .scheduler import schedule, ScheduleResult
+__all__ = ["schedule", "ScheduleResult"]

aetherorchestrate/scheduling/scheduler.py

@@ -0,0 +1,41 @@
+"""L3 — Scheduling (when tasks run)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from ..models import Task, DependencyEdge, DependencyType
+
+
+@dataclass
+class ScheduleResult:
+    order: list[str] = field(default_factory=list)
+    feasible: bool = False
+    note: str = ""
+
+
+def schedule(tasks: list[Task], edges: list[DependencyEdge]) -> ScheduleResult:
+    """Compute a schedule hint (deterministic function of S)."""
+    task_ids = {t.id for t in tasks}
+    adj: dict[str, list[str]] = {tid: [] for tid in task_ids}
+    indeg: dict[str, int] = {tid: 0 for tid in task_ids}
+    for e in edges:
+        if e.from_task in task_ids and e.to_task in task_ids:
+            adj[e.from_task].append(e.to_task)
+            indeg[e.to_task] += 1
+
+    queue = sorted([t for t, d in indeg.items() if d == 0])
+    order = []
+    while queue:
+        cur = queue.pop(0)
+        order.append(cur)
+        for nxt in sorted(adj[cur]):
+            indeg[nxt] -= 1
+            if indeg[nxt] == 0:
+                queue.append(nxt)
+                queue.sort()
+    feasible = len(order) == len(task_ids)
+    return ScheduleResult(
+        order=order,
+        feasible=feasible,
+        note="feasible" if feasible else "cycle detected",
+    )

aetherorchestrate/simulation/__init__.py

@@ -0,0 +1,5 @@
+"""Simulation layer."""
+from .network import Network
+from .node import Node
+from .testbed import Testbed
+__all__ = ["Network", "Node", "Testbed"]

aetherorchestrate/simulation/network.py

@@ -0,0 +1,36 @@
+"""Simulated network."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Network:
+    nodes: list[str] = field(default_factory=list)
+    partitions: dict[str, set[str]] = field(default_factory=dict)
+
+    def add_node(self, node_id: str) -> None:
+        if node_id in self.nodes:
+            return
+        self.nodes.append(node_id)
+        # كل العقد الموجودة يمكنها الوصول إلى العقدة الجديدة
+        for existing in self.nodes:
+            if existing == node_id:
+                continue
+            self.partitions.setdefault(existing, set()).add(node_id)
+        # العقدة الجديدة يمكنها الوصول إلى كل العقد الموجودة
+        self.partitions[node_id] = set(self.nodes) - {node_id}
+
+    def can_reach(self, src: str, dst: str) -> bool:
+        return dst in self.partitions.get(src, set())
+
+    def partition(self, group_a: set[str], group_b: set[str]) -> None:
+        for a in group_a:
+            self.partitions[a] = set(group_a) - {a}
+        for b in group_b:
+            self.partitions[b] = set(group_b) - {b}
+
+    def heal(self) -> None:
+        for n in self.nodes:
+            self.partitions[n] = set(self.nodes) - {n}

aetherorchestrate/simulation/node.py

@@ -0,0 +1,21 @@
+"""Simulated node."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+@dataclass
+class Node:
+    id: str
+    admitted: set[str] = field(default_factory=set)  # delta ids
+    claims: list[str] = field(default_factory=list)
+    revocations: set[str] = field(default_factory=set)
+    is_byzantine: bool = False
+
+    def admit(self, delta_id: str) -> None:
+        self.admitted.add(delta_id)
+
+    def has(self, delta_id: str) -> bool:
+        return delta_id in self.admitted

aetherorchestrate/simulation/testbed.py

@@ -0,0 +1,35 @@
+"""Simulation testbed."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from .network import Network
+from .node import Node
+
+
+@dataclass
+class Testbed:
+    network: Network = field(default_factory=Network)
+    nodes: dict[str, Node] = field(default_factory=dict)
+
+    def add_node(self, node_id: str, byzantine: bool = False) -> Node:
+        node = Node(id=node_id, is_byzantine=byzantine)
+        self.nodes[node_id] = node
+        self.network.add_node(node_id)
+        return node
+
+    def broadcast(self, src: str, delta_id: str) -> int:
+        count = 0
+        for dst, node in self.nodes.items():
+            if dst == src:
+                continue
+            if self.network.can_reach(src, dst):
+                node.admit(delta_id)
+                count += 1
+        return count
+
+    def converge(self) -> bool:
+        if not self.nodes:
+            return True
+        first = next(iter(self.nodes.values()))
+        return all(n.admitted == first.admitted for n in self.nodes.values())