@almadar/cli 0.3.1 → 0.3.3

package/shells/python-shell/src/orbital_app/tensor/ops.py

@@ -0,0 +1,196 @@
+"""
+Tensor Operations - tensor/* S-expression implementations.
+
+All 28 tensor operators from orbital-shared/std/modules/tensor.ts.
+"""
+import torch
+from typing import List, Dict, Any
+
+
+# =============================================================================
+# Creation
+# =============================================================================
+
+
+def tensor_from(data: List[float]) -> torch.Tensor:
+    """Create tensor from array."""
+    return torch.tensor(data, dtype=torch.float32)
+
+
+def tensor_zeros(shape: List[int]) -> torch.Tensor:
+    """Create tensor of zeros."""
+    return torch.zeros(shape, dtype=torch.float32)
+
+
+def tensor_ones(shape: List[int]) -> torch.Tensor:
+    """Create tensor of ones."""
+    return torch.ones(shape, dtype=torch.float32)
+
+
+def tensor_rand(shape: List[int]) -> torch.Tensor:
+    """Create tensor with random values [0, 1)."""
+    return torch.rand(shape)
+
+
+def tensor_randn(shape: List[int]) -> torch.Tensor:
+    """Create tensor with random normal values."""
+    return torch.randn(shape)
+
+
+# =============================================================================
+# Shape/Indexing
+# =============================================================================
+
+
+def tensor_shape(tensor: torch.Tensor) -> List[int]:
+    """Get tensor shape."""
+    return list(tensor.shape)
+
+
+def tensor_get(tensor: torch.Tensor, index: int) -> float:
+    """Get element at index."""
+    return tensor[index].item()
+
+
+def tensor_slice(tensor: torch.Tensor, start: int, end: int) -> torch.Tensor:
+    """Get slice of tensor."""
+    return tensor[start:end]
+
+
+def tensor_reshape(tensor: torch.Tensor, shape: List[int]) -> torch.Tensor:
+    """Reshape tensor."""
+    return tensor.reshape(shape)
+
+
+def tensor_flatten(tensor: torch.Tensor) -> torch.Tensor:
+    """Flatten tensor to 1D."""
+    return tensor.flatten()
+
+
+# =============================================================================
+# Math
+# =============================================================================
+
+
+def tensor_add(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """Element-wise addition."""
+    return a + b
+
+
+def tensor_sub(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """Element-wise subtraction."""
+    return a - b
+
+
+def tensor_mul(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """Element-wise multiplication."""
+    return a * b
+
+
+def tensor_div(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """Element-wise division."""
+    return a / b
+
+
+def tensor_matmul(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """Matrix multiplication."""
+    return torch.matmul(a, b)
+
+
+def tensor_dot(a: torch.Tensor, b: torch.Tensor) -> float:
+    """Dot product."""
+    return torch.dot(a.flatten(), b.flatten()).item()
+
+
+# =============================================================================
+# Reductions
+# =============================================================================
+
+
+def tensor_sum(tensor: torch.Tensor) -> float:
+    """Sum all elements."""
+    return tensor.sum().item()
+
+
+def tensor_mean(tensor: torch.Tensor) -> float:
+    """Mean of all elements."""
+    return tensor.mean().item()
+
+
+def tensor_max(tensor: torch.Tensor) -> float:
+    """Max element."""
+    return tensor.max().item()
+
+
+def tensor_min(tensor: torch.Tensor) -> float:
+    """Min element."""
+    return tensor.min().item()
+
+
+def tensor_argmax(tensor: torch.Tensor) -> int:
+    """Index of max element."""
+    return tensor.argmax().item()
+
+
+def tensor_norm(tensor: torch.Tensor) -> float:
+    """L2 norm."""
+    return tensor.norm().item()
+
+
+# =============================================================================
+# Range Validation
+# =============================================================================
+
+
+def tensor_all_in_range(tensor: torch.Tensor, range_: List[float]) -> bool:
+    """Check all elements in range [min, max]."""
+    min_val, max_val = range_
+    return bool((tensor >= min_val).all() and (tensor <= max_val).all())
+
+
+def tensor_clamp(tensor: torch.Tensor, min_val: float, max_val: float) -> torch.Tensor:
+    """Clamp all elements to [min, max]."""
+    return tensor.clamp(min_val, max_val)
+
+
+def tensor_clamp_per_dim(
+    tensor: torch.Tensor,
+    ranges: Dict[str, Dict[str, float]],
+) -> torch.Tensor:
+    """Clamp each dimension to its specified range."""
+    result = tensor.clone()
+    for dim_str, bounds in ranges.items():
+        dim = int(dim_str)
+        result[dim] = result[dim].clamp(bounds["min"], bounds["max"])
+    return result
+
+
+def tensor_out_of_range_dims(
+    tensor: torch.Tensor,
+    ranges: Dict[str, Dict[str, float]],
+) -> List[Dict[str, Any]]:
+    """Get dimensions that exceed ranges."""
+    violations = []
+    for dim_str, bounds in ranges.items():
+        dim = int(dim_str)
+        value = tensor[dim].item()
+        if value < bounds["min"] or value > bounds["max"]:
+            violations.append(
+                {
+                    "dim": dim,
+                    "value": value,
+                    "min": bounds["min"],
+                    "max": bounds["max"],
+                }
+            )
+    return violations
+
+
+# =============================================================================
+# Conversion
+# =============================================================================
+
+
+def tensor_to_list(tensor: torch.Tensor) -> List[float]:
+    """Convert tensor to Python list."""
+    return tensor.tolist()

package/shells/python-shell/tests/conftest.py

@@ -0,0 +1,63 @@
+"""
+Pytest Configuration and Fixtures
+
+Common fixtures for shell framework tests.
+"""
+
+import pytest
+import torch
+from fastapi.testclient import TestClient
+
+# Configure pytest-asyncio
+pytest_plugins = ('pytest_asyncio',)
+
+
+@pytest.fixture
+def test_client():
+    """Create a FastAPI test client for HTTP and WebSocket testing."""
+    from orbital_app.main import app
+    return TestClient(app)
+
+
+@pytest.fixture
+def in_memory_repository():
+    """Create an in-memory repository for testing."""
+    from orbital_app.core.repository import InMemoryRepository
+    return InMemoryRepository()
+
+
+@pytest.fixture
+def effect_executor(in_memory_repository):
+    """Create an effect executor for testing."""
+    from orbital_app.core.effect_executor import EffectExecutor
+    return EffectExecutor(in_memory_repository)
+
+
+@pytest.fixture
+def event_bus():
+    """Create an event bus for testing."""
+    from orbital_app.core.event_bus import EventBus
+    return EventBus()
+
+
+@pytest.fixture
+def simple_network():
+    """Create a simple test network."""
+    from orbital_app.nn.builder import build_network
+    return build_network([
+        "nn/sequential",
+        ["nn/linear", 4, 8],
+        ["nn/relu"],
+        ["nn/linear", 8, 2],
+    ])
+
+
+@pytest.fixture
+def training_data():
+    """Simple training data."""
+    return [
+        {"observation": [1.0, 0.0, 0.0, 0.0], "target": [1.0, 0.0]},
+        {"observation": [0.0, 1.0, 0.0, 0.0], "target": [0.0, 1.0]},
+        {"observation": [0.0, 0.0, 1.0, 0.0], "target": [1.0, 0.0]},
+        {"observation": [0.0, 0.0, 0.0, 1.0], "target": [0.0, 1.0]},
+    ]

package/shells/python-shell/tests/test_effect_executor.py

@@ -0,0 +1,197 @@
+"""
+Effect Executor Tests
+
+Tests for core/effect_executor.py - Server-side effect execution.
+"""
+
+import pytest
+from orbital_app.core.effect_executor import EffectExecutor
+from orbital_app.core.repository import InMemoryRepository
+
+
+class TestEffectExecutor:
+    """Tests for EffectExecutor."""
+
+    @pytest.fixture
+    def repository(self):
+        """Create a fresh repository."""
+        return InMemoryRepository()
+
+    @pytest.fixture
+    def executor(self, repository):
+        """Create an executor with the repository."""
+        return EffectExecutor(repository)
+
+    @pytest.mark.asyncio
+    async def test_execute_fetch_single(self, executor, repository):
+        """Test fetching a single entity by ID."""
+        # Seed data
+        await repository.create("Task", {"id": "task-1", "name": "Test Task"})
+
+        effect = ["fetch", "Task", {"id": "task-1"}]
+        context = {}
+
+        result = await executor.execute(effect, context)
+
+        assert result is not None
+        assert result["id"] == "task-1"
+        assert result["name"] == "Test Task"
+        assert "Task" in executor.data
+
+    @pytest.mark.asyncio
+    async def test_execute_fetch_collection(self, executor, repository):
+        """Test fetching all entities of a type."""
+        await repository.create("Task", {"name": "Task 1"})
+        await repository.create("Task", {"name": "Task 2"})
+
+        effect = ["fetch", "Task"]
+        context = {}
+
+        result = await executor.execute(effect, context)
+
+        assert isinstance(result, list)
+        assert len(result) == 2
+
+    @pytest.mark.asyncio
+    async def test_execute_fetch_with_filter(self, executor, repository):
+        """Test fetching with S-expression filter."""
+        await repository.create("Task", {"name": "Task 1", "status": "pending"})
+        await repository.create("Task", {"name": "Task 2", "status": "completed"})
+
+        # Filter requires non-empty context to be applied by repository
+        effect = ["fetch", "Task", {"filter": ["=", "@entity.status", "pending"]}]
+        context = {"dummy": True}
+
+        result = await executor.execute(effect, context)
+
+        assert len(result) == 1
+        assert result[0]["status"] == "pending"
+
+    @pytest.mark.asyncio
+    async def test_execute_persist_create(self, executor, repository):
+        """Test persist create effect."""
+        effect = ["persist", "create", "Task", {"name": "New Task", "status": "pending"}]
+        context = {}
+
+        result = await executor.execute(effect, context)
+
+        assert result is not None
+        assert "id" in result
+        assert result["name"] == "New Task"
+        assert len(executor.effect_results) == 1
+        assert executor.effect_results[0]["action"] == "create"
+        assert executor.effect_results[0]["success"] is True
+
+    @pytest.mark.asyncio
+    async def test_execute_persist_update(self, executor, repository):
+        """Test persist update effect."""
+        created = await repository.create("Task", {"name": "Original", "status": "pending"})
+        entity_id = created["id"]
+
+        effect = ["persist", "update", "Task", {"status": "completed"}]
+        context = {"entityId": entity_id}
+
+        result = await executor.execute(effect, context)
+
+        assert result["status"] == "completed"
+        assert executor.effect_results[0]["action"] == "update"
+
+    @pytest.mark.asyncio
+    async def test_execute_persist_delete(self, executor, repository):
+        """Test persist delete effect."""
+        created = await repository.create("Task", {"name": "To Delete"})
+        entity_id = created["id"]
+
+        effect = ["persist", "delete", "Task"]
+        context = {"entityId": entity_id}
+
+        result = await executor.execute(effect, context)
+
+        assert result["deleted"] is True
+        assert executor.effect_results[0]["action"] == "delete"
+
+        # Verify deleted
+        deleted = await repository.get("Task", entity_id)
+        assert deleted is None
+
+    @pytest.mark.asyncio
+    async def test_execute_client_effects_collected(self, executor):
+        """Test that client effects are collected."""
+        context = {}
+
+        # Execute various client effects
+        await executor.execute(["render_ui", "main", {"type": "table"}], context)
+        await executor.execute(["navigate", "/tasks"], context)
+        await executor.execute(["notify", {"type": "success", "message": "Done"}], context)
+
+        assert len(executor.client_effects) == 3
+        assert executor.client_effects[0][0] == "render_ui"
+        assert executor.client_effects[1][0] == "navigate"
+        assert executor.client_effects[2][0] == "notify"
+
+    @pytest.mark.asyncio
+    async def test_execute_render_ui_variations(self, executor):
+        """Test render_ui and render-ui both work."""
+        context = {}
+
+        await executor.execute(["render_ui", "slot1", {}], context)
+        await executor.execute(["render-ui", "slot2", {}], context)
+
+        assert len(executor.client_effects) == 2
+
+    @pytest.mark.asyncio
+    async def test_execute_emit_as_client_effect(self, executor):
+        """Test emit is collected as client effect."""
+        effect = ["emit", "TASK_CREATED", {"taskId": "123"}]
+        context = {}
+
+        await executor.execute(effect, context)
+
+        assert len(executor.client_effects) == 1
+        assert executor.client_effects[0][0] == "emit"
+
+    @pytest.mark.asyncio
+    async def test_execute_set_effect(self, executor):
+        """Test set effect updates entity field."""
+        context = {"entity": {"name": "Original", "status": "pending"}}
+
+        effect = ["set", "@entity.status", "completed"]
+        await executor.execute(effect, context)
+
+        assert context["entity"]["status"] == "completed"
+        assert len(executor.effect_results) == 1
+        assert executor.effect_results[0]["effect"] == "set"
+
+    @pytest.mark.asyncio
+    async def test_execute_empty_effect(self, executor):
+        """Test empty effect returns None."""
+        result = await executor.execute([], {})
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_execute_unknown_effect(self, executor):
+        """Test unknown effect returns None."""
+        result = await executor.execute(["unknown_effect", "arg"], {})
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_resolve_bindings_in_context(self, executor, repository):
+        """Test that @payload bindings are resolved."""
+        effect = ["persist", "create", "Task", "@payload"]
+        context = {"payload": {"name": "From Payload", "status": "new"}}
+
+        result = await executor.execute(effect, context)
+
+        assert result["name"] == "From Payload"
+        assert result["status"] == "new"
+
+    @pytest.mark.asyncio
+    async def test_call_service_not_implemented(self, executor):
+        """Test call_service returns not_implemented."""
+        effect = ["call_service", "email", "send", {"to": "test@test.com"}]
+        context = {}
+
+        result = await executor.execute(effect, context)
+
+        assert result["status"] == "not_implemented"
+        assert executor.effect_results[0]["success"] is False

package/shells/python-shell/tests/test_event_bus.py

@@ -0,0 +1,194 @@
+"""
+Event Bus Tests
+
+Tests for core/event_bus.py - Event publishing and subscription.
+"""
+
+import pytest
+from orbital_app.core.event_bus import EventBus, get_event_bus
+
+
+class TestEventBus:
+    """Tests for EventBus."""
+
+    @pytest.fixture
+    def event_bus(self):
+        """Create a fresh event bus for each test."""
+        return EventBus()
+
+    @pytest.mark.asyncio
+    async def test_subscribe_and_emit(self, event_bus):
+        """Test subscribing to event and receiving it."""
+        received = []
+
+        def handler(payload):
+            received.append(payload)
+
+        event_bus.subscribe("TEST_EVENT", handler)
+        await event_bus.emit("TEST_EVENT", {"data": "test"})
+
+        assert len(received) == 1
+        assert received[0]["data"] == "test"
+
+    @pytest.mark.asyncio
+    async def test_emit_with_payload(self, event_bus):
+        """Test emitting event with data payload."""
+        received_payload = None
+
+        def handler(payload):
+            nonlocal received_payload
+            received_payload = payload
+
+        event_bus.subscribe("DATA_EVENT", handler)
+        await event_bus.emit("DATA_EVENT", {"id": "123", "name": "Test"})
+
+        assert received_payload == {"id": "123", "name": "Test"}
+
+    @pytest.mark.asyncio
+    async def test_emit_without_payload(self, event_bus):
+        """Test emitting event without payload."""
+        received_payload = None
+
+        def handler(payload):
+            nonlocal received_payload
+            received_payload = payload
+
+        event_bus.subscribe("SIMPLE_EVENT", handler)
+        await event_bus.emit("SIMPLE_EVENT")
+
+        assert received_payload == {}
+
+    @pytest.mark.asyncio
+    async def test_multiple_subscribers(self, event_bus):
+        """Test multiple handlers receive event."""
+        received_by_1 = []
+        received_by_2 = []
+
+        def handler1(payload):
+            received_by_1.append(payload)
+
+        def handler2(payload):
+            received_by_2.append(payload)
+
+        event_bus.subscribe("MULTI_EVENT", handler1)
+        event_bus.subscribe("MULTI_EVENT", handler2)
+        await event_bus.emit("MULTI_EVENT", {"value": 42})
+
+        assert len(received_by_1) == 1
+        assert len(received_by_2) == 1
+        assert received_by_1[0]["value"] == 42
+        assert received_by_2[0]["value"] == 42
+
+    @pytest.mark.asyncio
+    async def test_unsubscribe(self, event_bus):
+        """Test unsubscribing stops receiving events."""
+        received = []
+
+        def handler(payload):
+            received.append(payload)
+
+        unsubscribe = event_bus.subscribe("UNSUB_EVENT", handler)
+
+        await event_bus.emit("UNSUB_EVENT", {"first": True})
+        unsubscribe()
+        await event_bus.emit("UNSUB_EVENT", {"second": True})
+
+        assert len(received) == 1
+        assert received[0]["first"] is True
+
+    @pytest.mark.asyncio
+    async def test_once_subscription(self, event_bus):
+        """Test once=True subscription only fires once."""
+        received = []
+
+        def handler(payload):
+            received.append(payload)
+
+        event_bus.subscribe("ONCE_EVENT", handler, once=True)
+
+        await event_bus.emit("ONCE_EVENT", {"call": 1})
+        await event_bus.emit("ONCE_EVENT", {"call": 2})
+        await event_bus.emit("ONCE_EVENT", {"call": 3})
+
+        assert len(received) == 1
+        assert received[0]["call"] == 1
+
+    @pytest.mark.asyncio
+    async def test_async_handler(self, event_bus):
+        """Test async handler is awaited properly."""
+        received = []
+
+        async def async_handler(payload):
+            received.append(payload)
+
+        event_bus.subscribe("ASYNC_EVENT", async_handler)
+        await event_bus.emit("ASYNC_EVENT", {"async": True})
+
+        assert len(received) == 1
+        assert received[0]["async"] is True
+
+    @pytest.mark.asyncio
+    async def test_emit_to_nonexistent_event(self, event_bus):
+        """Test emitting to event with no subscribers."""
+        # Should not raise
+        await event_bus.emit("NOBODY_LISTENING", {"data": "ignored"})
+
+    @pytest.mark.asyncio
+    async def test_clear_specific_event(self, event_bus):
+        """Test clearing subscriptions for specific event."""
+        received_a = []
+        received_b = []
+
+        event_bus.subscribe("EVENT_A", lambda p: received_a.append(p))
+        event_bus.subscribe("EVENT_B", lambda p: received_b.append(p))
+
+        event_bus.clear("EVENT_A")
+
+        await event_bus.emit("EVENT_A", {"cleared": True})
+        await event_bus.emit("EVENT_B", {"not_cleared": True})
+
+        assert len(received_a) == 0
+        assert len(received_b) == 1
+
+    @pytest.mark.asyncio
+    async def test_clear_all_events(self, event_bus):
+        """Test clearing all subscriptions."""
+        received_a = []
+        received_b = []
+
+        event_bus.subscribe("EVENT_A", lambda p: received_a.append(p))
+        event_bus.subscribe("EVENT_B", lambda p: received_b.append(p))
+
+        event_bus.clear()
+
+        await event_bus.emit("EVENT_A", {})
+        await event_bus.emit("EVENT_B", {})
+
+        assert len(received_a) == 0
+        assert len(received_b) == 0
+
+    @pytest.mark.asyncio
+    async def test_handler_error_doesnt_break_others(self, event_bus):
+        """Test that error in one handler doesn't stop others."""
+        received = []
+
+        def bad_handler(payload):
+            raise ValueError("Handler error")
+
+        def good_handler(payload):
+            received.append(payload)
+
+        event_bus.subscribe("ERROR_EVENT", bad_handler)
+        event_bus.subscribe("ERROR_EVENT", good_handler)
+
+        # Should not raise, good_handler should still receive
+        await event_bus.emit("ERROR_EVENT", {"data": "test"})
+
+        assert len(received) == 1
+
+    def test_get_event_bus_singleton(self):
+        """Test get_event_bus returns same instance."""
+        bus1 = get_event_bus()
+        bus2 = get_event_bus()
+
+        assert bus1 is bus2