@almadar/cli 1.0.6 → 1.0.7

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

@@ -1,196 +0,0 @@
-"""
-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

@@ -1,63 +0,0 @@
-"""
-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

@@ -1,197 +0,0 @@
-"""
-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

@@ -1,194 +0,0 @@
-"""
-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