@almadar/cli 0.3.1 → 0.3.3

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

@@ -0,0 +1,113 @@
+"""
+Neural Network Builder Tests
+
+Tests for nn/builder.py - S-expr to PyTorch conversion.
+"""
+
+import pytest
+import torch.nn as nn
+from orbital_app.nn.builder import build_network, build_layer
+
+
+class TestBuildNetwork:
+    """Tests for build_network function."""
+
+    def test_build_sequential_network(self):
+        """Test building nn.Sequential from S-expr."""
+        arch = ["nn/sequential", ["nn/linear", 16, 64], ["nn/relu"], ["nn/linear", 64, 4]]
+        network = build_network(arch)
+
+        assert isinstance(network, nn.Sequential)
+        assert len(network) == 3
+
+    def test_build_complex_network(self):
+        """Test building a more complex network."""
+        arch = [
+            "nn/sequential",
+            ["nn/linear", 8, 32],
+            ["nn/relu"],
+            ["nn/dropout", 0.5],
+            ["nn/linear", 32, 16],
+            ["nn/tanh"],
+            ["nn/linear", 16, 4],
+        ]
+        network = build_network(arch)
+
+        assert isinstance(network, nn.Sequential)
+        assert len(network) == 6
+
+    def test_empty_architecture_raises(self):
+        """Test that empty architecture raises ValueError."""
+        with pytest.raises(ValueError, match="Empty architecture"):
+            build_network([])
+
+    def test_unknown_architecture_raises(self):
+        """Test that unknown architecture type raises ValueError."""
+        with pytest.raises(ValueError, match="Unknown architecture type"):
+            build_network(["nn/unknown", ["nn/linear", 4, 4]])
+
+
+class TestBuildLayer:
+    """Tests for build_layer function."""
+
+    def test_build_linear_layer(self):
+        """Test building nn.Linear with correct dimensions."""
+        layer = build_layer(["nn/linear", 16, 64])
+
+        assert isinstance(layer, nn.Linear)
+        assert layer.in_features == 16
+        assert layer.out_features == 64
+
+    def test_build_relu(self):
+        """Test building ReLU activation."""
+        layer = build_layer(["nn/relu"])
+        assert isinstance(layer, nn.ReLU)
+
+    def test_build_tanh(self):
+        """Test building Tanh activation."""
+        layer = build_layer(["nn/tanh"])
+        assert isinstance(layer, nn.Tanh)
+
+    def test_build_sigmoid(self):
+        """Test building Sigmoid activation."""
+        layer = build_layer(["nn/sigmoid"])
+        assert isinstance(layer, nn.Sigmoid)
+
+    def test_build_softmax(self):
+        """Test building Softmax activation."""
+        layer = build_layer(["nn/softmax"])
+        assert isinstance(layer, nn.Softmax)
+
+    def test_build_softmax_with_dim(self):
+        """Test building Softmax with custom dimension."""
+        layer = build_layer(["nn/softmax", 0])
+        assert isinstance(layer, nn.Softmax)
+        assert layer.dim == 0
+
+    def test_build_dropout(self):
+        """Test building Dropout with default rate."""
+        layer = build_layer(["nn/dropout"])
+        assert isinstance(layer, nn.Dropout)
+        assert layer.p == 0.5
+
+    def test_build_dropout_with_rate(self):
+        """Test building Dropout with custom rate."""
+        layer = build_layer(["nn/dropout", 0.3])
+        assert isinstance(layer, nn.Dropout)
+        assert layer.p == 0.3
+
+    def test_build_batchnorm(self):
+        """Test building BatchNorm1d."""
+        layer = build_layer(["nn/batchnorm", 64])
+        assert isinstance(layer, nn.BatchNorm1d)
+        assert layer.num_features == 64
+
+    def test_build_layernorm(self):
+        """Test building LayerNorm."""
+        layer = build_layer(["nn/layernorm", 64])
+        assert isinstance(layer, nn.LayerNorm)
+
+    def test_unknown_layer_raises(self):
+        """Test that unknown layer type raises ValueError."""
+        with pytest.raises(ValueError, match="Unknown layer type"):
+            build_layer(["nn/unknown"])

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

@@ -0,0 +1,187 @@
+"""
+Neural Network Constraints Tests
+
+Tests for nn/constraints.py - Safety constraint enforcement.
+"""
+
+import pytest
+import torch
+import torch.nn as nn
+from orbital_app.nn.constraints import (
+    apply_gradient_clipping,
+    apply_weight_clipping,
+    check_forbidden_regions,
+    compute_constraint_loss,
+)
+from orbital_app.nn.builder import build_network
+
+
+class TestGradientClipping:
+    """Tests for gradient clipping."""
+
+    def test_gradient_clipping(self):
+        """Test that gradients are clipped to max norm."""
+        network = build_network([
+            "nn/sequential",
+            ["nn/linear", 4, 4],
+        ])
+
+        # Create some gradients
+        input_tensor = torch.randn(4)
+        output = network(input_tensor)
+        loss = output.sum()
+        loss.backward()
+
+        # Apply gradient clipping
+        apply_gradient_clipping(network, max_norm=1.0)
+
+        # Check gradient norm
+        total_norm = 0.0
+        for param in network.parameters():
+            if param.grad is not None:
+                total_norm += param.grad.norm().item() ** 2
+        total_norm = total_norm ** 0.5
+
+        assert total_norm <= 1.0 + 1e-6
+
+    def test_gradient_clipping_preserves_direction(self):
+        """Test that gradient clipping preserves gradient direction."""
+        network = nn.Linear(4, 4)
+
+        input_tensor = torch.randn(4)
+        output = network(input_tensor)
+        loss = output.sum()
+        loss.backward()
+
+        # Save original gradient direction
+        original_grad = network.weight.grad.clone()
+        original_direction = original_grad / original_grad.norm()
+
+        # Apply gradient clipping
+        apply_gradient_clipping(network, max_norm=0.1)
+
+        # Check direction is preserved
+        clipped_direction = network.weight.grad / network.weight.grad.norm()
+        assert torch.allclose(original_direction, clipped_direction, atol=1e-5)
+
+
+class TestWeightClipping:
+    """Tests for weight clipping."""
+
+    def test_weight_clipping(self):
+        """Test that weights are clamped to range."""
+        network = build_network([
+            "nn/sequential",
+            ["nn/linear", 4, 4],
+        ])
+
+        # Set some weights outside range
+        with torch.no_grad():
+            for param in network.parameters():
+                param.fill_(2.0)
+
+        # Apply weight clipping
+        apply_weight_clipping(network, max_magnitude=0.5)
+
+        # Check all weights are within bounds
+        for param in network.parameters():
+            assert param.abs().max().item() <= 0.5 + 1e-6
+
+    def test_weight_clipping_symmetric(self):
+        """Test that weight clipping is symmetric around zero."""
+        network = nn.Linear(4, 4)
+
+        with torch.no_grad():
+            network.weight.fill_(-2.0)
+
+        apply_weight_clipping(network, max_magnitude=0.5)
+
+        assert network.weight.min().item() >= -0.5 - 1e-6
+        assert network.weight.max().item() <= 0.5 + 1e-6
+
+
+class TestForbiddenRegions:
+    """Tests for forbidden region checking."""
+
+    def test_check_forbidden_regions_violation(self):
+        """Test detection of forbidden region violation."""
+        output = torch.tensor([0.5, 0.05, 0.8])  # dim 1 is in forbidden region
+        forbidden = [
+            {"dim": 1, "min": 0.0, "max": 0.1, "reason": "dead zone"},
+        ]
+
+        violations = check_forbidden_regions(output, forbidden)
+
+        assert len(violations) == 1
+        assert violations[0]["dim"] == 1
+        assert abs(violations[0]["value"] - 0.05) < 1e-5
+        assert violations[0]["reason"] == "dead zone"
+
+    def test_check_forbidden_regions_no_violation(self):
+        """Test no violation when output is outside forbidden regions."""
+        output = torch.tensor([0.5, 0.5, 0.8])
+        forbidden = [
+            {"dim": 1, "min": 0.0, "max": 0.1, "reason": "dead zone"},
+        ]
+
+        violations = check_forbidden_regions(output, forbidden)
+
+        assert len(violations) == 0
+
+    def test_check_forbidden_regions_multiple(self):
+        """Test checking multiple forbidden regions."""
+        output = torch.tensor([0.05, 0.05, 0.95])
+        forbidden = [
+            {"dim": 0, "min": 0.0, "max": 0.1, "reason": "zone 1"},
+            {"dim": 1, "min": 0.0, "max": 0.1, "reason": "zone 2"},
+            {"dim": 2, "min": 0.9, "max": 1.0, "reason": "zone 3"},
+        ]
+
+        violations = check_forbidden_regions(output, forbidden)
+
+        assert len(violations) == 3
+
+
+class TestConstraintLoss:
+    """Tests for constraint loss computation."""
+
+    def test_compute_constraint_loss_violation(self):
+        """Test penalty loss for forbidden region violation."""
+        output = torch.tensor([0.5, 0.05, 0.8])
+        forbidden = [
+            {"dim": 1, "min": 0.0, "max": 0.1},
+        ]
+
+        loss = compute_constraint_loss(output, forbidden)
+
+        assert loss.item() > 0
+
+    def test_compute_constraint_loss_no_violation(self):
+        """Test zero loss when no violation."""
+        output = torch.tensor([0.5, 0.5, 0.8])
+        forbidden = [
+            {"dim": 1, "min": 0.0, "max": 0.1},
+        ]
+
+        loss = compute_constraint_loss(output, forbidden)
+
+        assert loss.item() == 0.0
+
+    def test_compute_constraint_loss_penalty_scaling(self):
+        """Test that penalty scales the loss."""
+        output = torch.tensor([0.05])
+        forbidden = [{"dim": 0, "min": 0.0, "max": 0.1}]
+
+        loss_default = compute_constraint_loss(output, forbidden, penalty=10.0)
+        loss_scaled = compute_constraint_loss(output, forbidden, penalty=20.0)
+
+        # Scaled loss should be approximately 2x
+        assert abs(loss_scaled.item() / loss_default.item() - 2.0) < 0.1
+
+    def test_compute_constraint_loss_empty_forbidden(self):
+        """Test zero loss when no forbidden regions defined."""
+        output = torch.tensor([0.5, 0.5])
+
+        loss = compute_constraint_loss(output, [])
+
+        assert loss.item() == 0.0

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

@@ -0,0 +1,98 @@
+"""
+Neural Network Forward Pass Tests
+
+Tests for nn/forward.py - Neural network inference.
+"""
+
+import pytest
+import torch
+import torch.nn as nn
+from orbital_app.nn.forward import forward
+from orbital_app.nn.builder import build_network
+
+
+class TestForward:
+    """Tests for forward pass function."""
+
+    @pytest.fixture
+    def simple_network(self):
+        """Create a simple test network."""
+        return build_network([
+            "nn/sequential",
+            ["nn/linear", 4, 8],
+            ["nn/relu"],
+            ["nn/linear", 8, 2],
+        ])
+
+    def test_forward_pass(self, simple_network):
+        """Test basic inference through network."""
+        input_tensor = torch.randn(4)
+        output = forward(simple_network, input_tensor)
+
+        assert isinstance(output, torch.Tensor)
+        assert output.shape == (2,)
+
+    def test_forward_with_tensor_input(self, simple_network):
+        """Test forward pass with torch.Tensor input."""
+        input_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0])
+        output = forward(simple_network, input_tensor)
+
+        assert isinstance(output, torch.Tensor)
+        assert output.shape == (2,)
+
+    def test_forward_with_list_input(self, simple_network):
+        """Test forward pass with Python list input."""
+        input_list = [1.0, 2.0, 3.0, 4.0]
+        output = forward(simple_network, input_list)
+
+        assert isinstance(output, torch.Tensor)
+        assert output.shape == (2,)
+
+    def test_forward_eval_mode(self, simple_network):
+        """Test that network is in eval mode during forward."""
+        # Add dropout to test eval mode
+        network_with_dropout = build_network([
+            "nn/sequential",
+            ["nn/linear", 4, 8],
+            ["nn/dropout", 0.5],
+            ["nn/linear", 8, 2],
+        ])
+
+        input_tensor = torch.randn(4)
+
+        # In eval mode, dropout should be disabled
+        # Running twice should give identical results
+        output1 = forward(network_with_dropout, input_tensor)
+        output2 = forward(network_with_dropout, input_tensor)
+
+        assert torch.allclose(output1, output2)
+
+    def test_forward_no_grad(self, simple_network):
+        """Test that no gradients are tracked during inference."""
+        input_tensor = torch.randn(4, requires_grad=True)
+        output = forward(simple_network, input_tensor)
+
+        # Output should not require grad
+        assert not output.requires_grad
+
+    def test_forward_deterministic(self, simple_network):
+        """Test that forward pass is deterministic."""
+        input_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0])
+
+        output1 = forward(simple_network, input_tensor)
+        output2 = forward(simple_network, input_tensor)
+
+        assert torch.allclose(output1, output2)
+
+    def test_forward_batched_input(self):
+        """Test forward pass with batched input."""
+        network = build_network([
+            "nn/sequential",
+            ["nn/linear", 4, 2],
+        ])
+
+        # Batch of 3 samples
+        batch_input = torch.randn(3, 4)
+        output = forward(network, batch_input)
+
+        assert output.shape == (3, 2)

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

@@ -0,0 +1,130 @@
+"""
+Neural Network Training Tests
+
+Tests for nn/training.py - Training loop with constraints.
+"""
+
+import pytest
+import torch
+import torch.nn as nn
+from orbital_app.nn.training import train_loop
+from orbital_app.nn.builder import build_network
+
+
+class TestTrainLoop:
+    """Tests for training loop function."""
+
+    @pytest.fixture
+    def simple_network(self):
+        """Create a simple test network."""
+        return build_network([
+            "nn/sequential",
+            ["nn/linear", 4, 8],
+            ["nn/relu"],
+            ["nn/linear", 8, 2],
+        ])
+
+    @pytest.fixture
+    def training_data(self):
+        """Create 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]},
+        ]
+
+    def test_train_loop_basic(self, simple_network, training_data):
+        """Test basic training with MSE loss."""
+        config = {"epochs": 10, "learningRate": 0.01}
+
+        trained_model, history = train_loop(simple_network, training_data, config)
+
+        assert isinstance(trained_model, nn.Module)
+        assert "losses" in history
+        assert len(history["losses"]) == 10
+
+    def test_train_loop_loss_decreases(self, simple_network, training_data):
+        """Test that loss generally decreases during training."""
+        config = {"epochs": 50, "learningRate": 0.01}
+
+        _, history = train_loop(simple_network, training_data, config)
+
+        # First loss should be higher than last loss (training should improve)
+        assert history["losses"][0] > history["losses"][-1]
+
+    def test_train_loop_with_gradient_clipping(self, simple_network, training_data):
+        """Test training with maxGradientNorm enforcement."""
+        config = {
+            "epochs": 10,
+            "learningRate": 0.01,
+            "maxGradientNorm": 1.0,
+        }
+
+        trained_model, history = train_loop(simple_network, training_data, config)
+
+        assert isinstance(trained_model, nn.Module)
+        assert len(history["losses"]) == 10
+
+    def test_train_loop_with_weight_clipping(self, simple_network, training_data):
+        """Test training with maxWeightMagnitude enforcement."""
+        config = {
+            "epochs": 10,
+            "learningRate": 0.01,
+            "maxWeightMagnitude": 0.5,
+        }
+
+        trained_model, history = train_loop(simple_network, training_data, config)
+
+        # Check all weights are within bounds
+        for param in trained_model.parameters():
+            assert param.abs().max().item() <= 0.5 + 1e-6  # Small tolerance
+
+    def test_train_loop_with_forbidden_regions(self, simple_network, training_data):
+        """Test training with constraint loss applied."""
+        config = {
+            "epochs": 10,
+            "learningRate": 0.01,
+            "forbiddenOutputRegions": [
+                {"dim": 0, "min": -0.1, "max": 0.1, "reason": "dead zone"},
+            ],
+        }
+
+        trained_model, history = train_loop(simple_network, training_data, config)
+
+        assert "constraint_violations" in history
+        assert len(history["constraint_violations"]) == 10
+
+    def test_train_history(self, simple_network, training_data):
+        """Test that history tracking works correctly."""
+        config = {"epochs": 5, "learningRate": 0.01}
+
+        _, history = train_loop(simple_network, training_data, config)
+
+        assert "losses" in history
+        assert "constraint_violations" in history
+        assert len(history["losses"]) == 5
+        assert len(history["constraint_violations"]) == 5
+
+        # All losses should be positive
+        assert all(loss >= 0 for loss in history["losses"])
+
+    def test_train_loop_default_config(self, simple_network, training_data):
+        """Test training with default configuration."""
+        config = {}
+
+        trained_model, history = train_loop(simple_network, training_data, config)
+
+        # Should use default epochs=100
+        assert len(history["losses"]) == 100
+
+    def test_train_loop_empty_data(self, simple_network):
+        """Test training with empty data."""
+        config = {"epochs": 5}
+
+        trained_model, history = train_loop(simple_network, [], config)
+
+        # Should complete without error
+        assert len(history["losses"]) == 5
+        # All losses should be 0 (no data to compute loss)
+        assert all(loss == 0 for loss in history["losses"])

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

@@ -0,0 +1,151 @@
+"""
+Repository Tests
+
+Tests for core/repository.py - Database abstraction layer.
+"""
+
+import pytest
+from orbital_app.core.repository import InMemoryRepository
+
+
+class TestInMemoryRepository:
+    """Tests for InMemoryRepository."""
+
+    @pytest.fixture
+    def repository(self):
+        """Create a fresh repository for each test."""
+        return InMemoryRepository()
+
+    @pytest.mark.asyncio
+    async def test_create_entity(self, repository):
+        """Test creating an entity."""
+        data = {"name": "Test Task", "status": "pending"}
+        result = await repository.create("Task", data)
+
+        assert "id" in result
+        assert result["name"] == "Test Task"
+        assert result["status"] == "pending"
+
+    @pytest.mark.asyncio
+    async def test_create_with_id(self, repository):
+        """Test creating an entity with provided ID."""
+        data = {"id": "custom-id", "name": "Test Task"}
+        result = await repository.create("Task", data)
+
+        assert result["id"] == "custom-id"
+
+    @pytest.mark.asyncio
+    async def test_get_entity(self, repository):
+        """Test getting an entity by ID."""
+        created = await repository.create("Task", {"name": "Test"})
+        entity_id = created["id"]
+
+        result = await repository.get("Task", entity_id)
+
+        assert result is not None
+        assert result["id"] == entity_id
+        assert result["name"] == "Test"
+
+    @pytest.mark.asyncio
+    async def test_get_not_found(self, repository):
+        """Test getting non-existent entity returns None."""
+        result = await repository.get("Task", "non-existent-id")
+
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_list_entities(self, repository):
+        """Test listing all entities of a type."""
+        await repository.create("Task", {"name": "Task 1"})
+        await repository.create("Task", {"name": "Task 2"})
+        await repository.create("Task", {"name": "Task 3"})
+
+        result = await repository.list("Task")
+
+        assert len(result) == 3
+
+    @pytest.mark.asyncio
+    async def test_list_empty(self, repository):
+        """Test listing when no entities exist."""
+        result = await repository.list("Task")
+
+        assert result == []
+
+    @pytest.mark.asyncio
+    async def test_update_entity(self, repository):
+        """Test updating an entity."""
+        created = await repository.create("Task", {"name": "Original", "status": "pending"})
+        entity_id = created["id"]
+
+        result = await repository.update("Task", entity_id, {"status": "completed"})
+
+        assert result["status"] == "completed"
+        assert result["name"] == "Original"  # Other fields preserved
+
+    @pytest.mark.asyncio
+    async def test_update_not_found(self, repository):
+        """Test updating non-existent entity."""
+        result = await repository.update("Task", "non-existent", {"status": "done"})
+
+        # Returns the update data when entity not found
+        assert result["status"] == "done"
+
+    @pytest.mark.asyncio
+    async def test_delete_entity(self, repository):
+        """Test deleting an entity."""
+        created = await repository.create("Task", {"name": "Test"})
+        entity_id = created["id"]
+
+        result = await repository.delete("Task", entity_id)
+
+        assert result is True
+
+        # Verify it's deleted
+        deleted = await repository.get("Task", entity_id)
+        assert deleted is None
+
+    @pytest.mark.asyncio
+    async def test_delete_not_found(self, repository):
+        """Test deleting non-existent entity."""
+        result = await repository.delete("Task", "non-existent")
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_list_with_filter(self, repository):
+        """Test listing with S-expression filter."""
+        await repository.create("Task", {"name": "Task 1", "status": "pending"})
+        await repository.create("Task", {"name": "Task 2", "status": "completed"})
+        await repository.create("Task", {"name": "Task 3", "status": "pending"})
+
+        # Note: Filter requires non-empty context to be applied
+        filter_expr = ["=", "@entity.status", "pending"]
+        result = await repository.list("Task", filter_expr=filter_expr, context={"dummy": True})
+
+        assert len(result) == 2
+        assert all(t["status"] == "pending" for t in result)
+
+    @pytest.mark.asyncio
+    async def test_seed_data(self, repository):
+        """Test seeding repository with test data."""
+        test_data = [
+            {"id": "1", "name": "Task 1"},
+            {"id": "2", "name": "Task 2"},
+        ]
+        repository.seed("Task", test_data)
+
+        result = await repository.list("Task")
+        assert len(result) == 2
+
+    @pytest.mark.asyncio
+    async def test_multiple_entity_types(self, repository):
+        """Test handling multiple entity types."""
+        await repository.create("Task", {"name": "Task 1"})
+        await repository.create("User", {"name": "User 1"})
+        await repository.create("Task", {"name": "Task 2"})
+
+        tasks = await repository.list("Task")
+        users = await repository.list("User")
+
+        assert len(tasks) == 2
+        assert len(users) == 1