@almadar/cli 1.0.6 → 1.0.7

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

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

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

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

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

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