monkeybrain-runtime 1.0.0__py3-none-any.whl

src/plasticity/testing/runner.py

@@ -0,0 +1,209 @@
+"""Test Runner — executes tests and collects results.
+
+Supports:
+- Unit tests
+- Integration tests
+- End-to-end tests
+- Regression tests
+- Performance tests
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Callable
+from uuid import uuid4
+
+
+class TestType(str, Enum):
+    UNIT = "unit"
+    INTEGRATION = "integration"
+    E2E = "e2e"
+    REGRESSION = "regression"
+    PERFORMANCE = "performance"
+    STRESS = "stress"
+
+
+class TestStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    PASSED = "passed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    ERROR = "error"
+
+
+@dataclass
+class TestCase:
+    """A single test case."""
+    
+    test_id: str = field(default_factory=lambda: f"test-{uuid4().hex[:8]}")
+    name: str = ""
+    test_type: TestType = TestType.UNIT
+    description: str = ""
+    function: Any = None
+    input_data: dict[str, Any] = field(default_factory=dict)
+    expected_output: dict[str, Any] = field(default_factory=dict)
+    tags: list[str] = field(default_factory=list)
+    timeout_ms: float = 5000.0
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class TestResult:
+    """Result of a single test."""
+    
+    test_id: str = ""
+    name: str = ""
+    status: TestStatus = TestStatus.PENDING
+    latency_ms: float = 0.0
+    error: str | None = None
+    assertions: list[dict[str, Any]] = field(default_factory=list)
+    output: dict[str, Any] = field(default_factory=dict)
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+@dataclass
+class TestSuiteResult:
+    """Result of a test suite execution."""
+    
+    suite_id: str = field(default_factory=lambda: f"suite-{uuid4().hex[:8]}")
+    name: str = ""
+    results: list[TestResult] = field(default_factory=list)
+    total: int = 0
+    passed: int = 0
+    failed: int = 0
+    skipped: int = 0
+    errors: int = 0
+    total_latency_ms: float = 0.0
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    
+    @property
+    def pass_rate(self) -> float:
+        return self.passed / self.total if self.total else 0.0
+
+
+class TestRunner:
+    """Executes tests and collects results.
+    
+    Supports:
+    - Unit tests
+    - Integration tests
+    - End-to-end tests
+    - Regression tests
+    - Performance tests
+    """
+    
+    def __init__(self):
+        self._test_cases: list[TestCase] = []
+        self._results: list[TestResult] = []
+        self._suites: list[TestSuiteResult] = []
+        self._lemon = None
+    
+    def set_lemon(self, lemon) -> None:
+        self._lemon = lemon
+    
+    def register(
+        self,
+        name: str,
+        function: Callable,
+        test_type: TestType = TestType.UNIT,
+        input_data: dict[str, Any] | None = None,
+        expected_output: dict[str, Any] | None = None,
+        tags: list[str] | None = None,
+    ) -> str:
+        """Register a test case."""
+        test = TestCase(
+            name=name,
+            test_type=test_type,
+            function=function,
+            input_data=input_data or {},
+            expected_output=expected_output or {},
+            tags=tags or [],
+        )
+        self._test_cases.append(test)
+        return test.test_id
+    
+    async def run(self, test: TestCase) -> TestResult:
+        """Run a single test."""
+        result = TestResult(test_id=test.test_id, name=test.name)
+        
+        start = time.monotonic()
+        
+        try:
+            if test.function:
+                if asyncio.iscoroutinefunction(test.function):
+                    output = await test.function(test.input_data)
+                else:
+                    output = test.function(test.input_data)
+                result.output = output if isinstance(output, dict) else {"result": output}
+            
+            result.status = TestStatus.PASSED
+            result.latency_ms = (time.monotonic() - start) * 1000
+            
+            # Validate expected output
+            if test.expected_output:
+                for key, expected in test.expected_output.items():
+                    actual = result.output.get(key)
+                    passed = actual == expected
+                    result.assertions.append({
+                        "field": key,
+                        "expected": expected,
+                        "actual": actual,
+                        "passed": passed,
+                    })
+                    if not passed:
+                        result.status = TestStatus.FAILED
+            
+        except Exception as e:
+            result.status = TestStatus.ERROR
+            result.error = str(e)
+            result.latency_ms = (time.monotonic() - start) * 1000
+        
+        self._results.append(result)
+        
+        if self._lemon:
+            self._lemon.counter("testing.tests_run")
+            self._lemon.counter(f"testing.tests_{result.status.value}")
+        
+        return result
+    
+    async def run_suite(self, name: str, tests: list[TestCase]) -> TestSuiteResult:
+        """Run a suite of tests."""
+        suite = TestSuiteResult(name=name)
+        
+        for test in tests:
+            result = await self.run(test)
+            suite.results.append(result)
+            suite.total += 1
+            if result.status == TestStatus.PASSED:
+                suite.passed += 1
+            elif result.status == TestStatus.FAILED:
+                suite.failed += 1
+            elif result.status == TestStatus.SKIPPED:
+                suite.skipped += 1
+            elif result.status == TestStatus.ERROR:
+                suite.errors += 1
+            suite.total_latency_ms += result.latency_ms
+        
+        self._suites.append(suite)
+        return suite
+    
+    def get_results(self, status: TestStatus | None = None) -> list[TestResult]:
+        if status:
+            return [r for r in self._results if r.status == status]
+        return list(self._results)
+    
+    def summary(self) -> dict:
+        return {
+            "total_tests": len(self._test_cases),
+            "total_results": len(self._results),
+            "suites": len(self._suites),
+            "passed": sum(1 for r in self._results if r.status == TestStatus.PASSED),
+            "failed": sum(1 for r in self._results if r.status == TestStatus.FAILED),
+            "errors": sum(1 for r in self._results if r.status == TestStatus.ERROR),
+        }

src/sync/__init__.py

@@ -0,0 +1,12 @@
+"""Edge-Cloud Sync Layer — synchronizes edge and cloud components."""
+
+from src.sync.sync_manager import SyncManager, SyncMessage
+from src.sync.edge_node import EdgeNode
+from src.sync.cloud_aggregator import CloudAggregator
+
+__all__ = [
+    "SyncManager",
+    "SyncMessage",
+    "EdgeNode",
+    "CloudAggregator",
+]

src/sync/cloud_aggregator.py

@@ -0,0 +1,63 @@
+"""Cloud Aggregator — aggregates data from edge nodes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class AggregatedMetrics:
+    """Aggregated metrics from all edge nodes."""
+    
+    fleet_id: str = ""
+    total_nodes: int = 0
+    total_executions: int = 0
+    avg_success_rate: float = 0.0
+    avg_latency_ms: float = 0.0
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+class CloudAggregator:
+    """Aggregates data from edge nodes."""
+    
+    def __init__(self):
+        self._node_metrics: dict[str, list[dict[str, Any]]] = {}
+        self._fleet_metrics: list[AggregatedMetrics] = []
+    
+    def record_node_metrics(self, node_id: str, metrics: dict[str, Any]) -> None:
+        """Record metrics from an edge node."""
+        if node_id not in self._node_metrics:
+            self._node_metrics[node_id] = []
+        self._node_metrics[node_id].append(metrics)
+    
+    def aggregate_fleet(self, fleet_id: str = "default") -> AggregatedMetrics:
+        """Aggregate metrics across all nodes."""
+        all_metrics = []
+        for node_metrics in self._node_metrics.values():
+            if node_metrics:
+                all_metrics.append(node_metrics[-1])
+        
+        if not all_metrics:
+            return AggregatedMetrics(fleet_id=fleet_id)
+        
+        fleet = AggregatedMetrics(
+            fleet_id=fleet_id,
+            total_nodes=len(all_metrics),
+            total_executions=sum(m.get("executions", 0) for m in all_metrics),
+            avg_success_rate=sum(m.get("success_rate", 0) for m in all_metrics) / len(all_metrics),
+            avg_latency_ms=sum(m.get("latency_ms", 0) for m in all_metrics) / len(all_metrics),
+        )
+        
+        self._fleet_metrics.append(fleet)
+        return fleet
+    
+    def get_fleet_history(self, limit: int = 100) -> list[AggregatedMetrics]:
+        return self._fleet_metrics[-limit:]
+    
+    def summary(self) -> dict:
+        return {
+            "nodes": len(self._node_metrics),
+            "fleet_snapshots": len(self._fleet_metrics),
+        }

src/sync/edge_node.py

@@ -0,0 +1,51 @@
+"""Edge Node — represents a single edge deployment."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class EdgeNode:
+    """An edge node in the fleet."""
+    
+    node_id: str = field(default_factory=lambda: f"node-{uuid4().hex[:8]}")
+    name: str = ""
+    status: str = "online"
+    version: str = "1.0.0"
+    capabilities: list[str] = field(default_factory=list)
+    last_heartbeat: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class EdgeNodeManager:
+    """Manages edge node registration and health."""
+    
+    def __init__(self):
+        self._nodes: dict[str, EdgeNode] = {}
+    
+    def register(self, node: EdgeNode) -> None:
+        self._nodes[node.node_id] = node
+    
+    def heartbeat(self, node_id: str) -> bool:
+        if node_id in self._nodes:
+            self._nodes[node_id].last_heartbeat = datetime.now(timezone.utc).isoformat()
+            return True
+        return False
+    
+    def get_node(self, node_id: str) -> EdgeNode | None:
+        return self._nodes.get(node_id)
+    
+    def get_all_nodes(self) -> list[EdgeNode]:
+        return list(self._nodes.values())
+    
+    def get_online_nodes(self) -> list[EdgeNode]:
+        return [n for n in self._nodes.values() if n.status == "online"]
+    
+    def summary(self) -> dict:
+        return {
+            "total_nodes": len(self._nodes),
+            "online_nodes": len(self.get_online_nodes()),
+        }

src/sync/sync_manager.py

@@ -0,0 +1,74 @@
+"""Sync Manager — orchestrates edge-cloud synchronization."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Callable
+from uuid import uuid4
+
+
+@dataclass
+class SyncMessage:
+    """Message for edge-cloud sync."""
+    
+    message_id: str = field(default_factory=lambda: f"msg-{uuid4().hex[:8]}")
+    source: str = ""
+    destination: str = ""
+    message_type: str = ""  # metrics | events | knowledge | heartbeat
+    payload: dict[str, Any] = field(default_factory=dict)
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+class SyncManager:
+    """Orchestrates edge-cloud synchronization.
+    
+    Uses NATS or Kafka for message transport.
+    Edge nodes sync metrics, events, knowledge to cloud.
+    Cloud provides fleet view and control plane.
+    """
+    
+    def __init__(self, transport: str = "nats", transport_url: str = "nats://localhost:4222"):
+        self._transport = transport
+        self._transport_url = transport_url
+        self._handlers: dict[str, Callable] = {}
+        self._message_buffer: list[SyncMessage] = []
+        self._lemon = None
+    
+    def set_lemon(self, lemon) -> None:
+        self._lemon = lemon
+    
+    def register_handler(self, message_type: str, handler: Callable) -> None:
+        """Register a handler for a message type."""
+        self._handlers[message_type] = handler
+    
+    async def publish(self, message: SyncMessage) -> None:
+        """Publish a sync message."""
+        self._message_buffer.append(message)
+        
+        if self._lemon:
+            self._lemon.counter("sync.messages_published", type=message.message_type)
+        
+        # In production, this would use NATS/Kafka
+        # For now, store in buffer
+        handler = self._handlers.get(message.message_type)
+        if handler:
+            await handler(message)
+    
+    async def subscribe(self, message_type: str, callback: Callable) -> None:
+        """Subscribe to a message type."""
+        self._handlers[message_type] = callback
+    
+    def get_messages(self, message_type: str | None = None, limit: int = 100) -> list[SyncMessage]:
+        """Get recent messages."""
+        messages = self._message_buffer
+        if message_type:
+            messages = [m for m in messages if m.message_type == message_type]
+        return messages[-limit:]
+    
+    def summary(self) -> dict:
+        return {
+            "transport": self._transport,
+            "messages": len(self._message_buffer),
+            "handlers": len(self._handlers),
+        }