ci: fix formating in test

tests/test_architectural_constraints.py

@@ -25,15 +25,15 @@ class TestArchitecturalConstraints:
         fields = BeliefUpdate.__dataclass_fields__
 
         # Should only contain comparison_result
-        assert len(fields) == 1, (
-            f"BeliefUpdate should have exactly 1 field, got {len(fields)}: {list(fields.keys())}"
-        )
-        assert "comparison_result" in fields, (
-            "BeliefUpdate must contain comparison_result field"
-        )
-        assert "dice_roll" not in fields, (
-            "BeliefUpdate MUST NOT contain dice_roll field"
-        )
+        assert (
+            len(fields) == 1
+        ), f"BeliefUpdate should have exactly 1 field, got {len(fields)}: {list(fields.keys())}"
+        assert (
+            "comparison_result" in fields
+        ), "BeliefUpdate must contain comparison_result field"
+        assert (
+            "dice_roll" not in fields
+        ), "BeliefUpdate MUST NOT contain dice_roll field"
 
     def test_environment_evidence_dataclass_structure(self):
         """Test that EnvironmentEvidence contains both dice_roll and comparison_result."""
@@ -41,13 +41,13 @@ class TestArchitecturalConstraints:
         fields = EnvironmentEvidence.__dataclass_fields__
 
         # Should contain both fields
-        assert len(fields) == 2, (
-            f"EnvironmentEvidence should have exactly 2 fields, got {len(fields)}: {list(fields.keys())}"
-        )
+        assert (
+            len(fields) == 2
+        ), f"EnvironmentEvidence should have exactly 2 fields, got {len(fields)}: {list(fields.keys())}"
         assert "dice_roll" in fields, "EnvironmentEvidence must contain dice_roll field"
-        assert "comparison_result" in fields, (
-            "EnvironmentEvidence must contain comparison_result field"
-        )
+        assert (
+            "comparison_result" in fields
+        ), "EnvironmentEvidence must contain comparison_result field"
 
     def test_belief_state_methods_no_dice_roll_parameters(self):
         """Test that BayesianBeliefState methods don't accept dice_roll parameters."""
@@ -61,9 +61,9 @@ class TestArchitecturalConstraints:
             signature = inspect.signature(method)
             param_names = list(signature.parameters.keys())
 
-            assert "dice_roll" not in param_names, (
-                f"Method {method_name} MUST NOT have dice_roll parameter"
-            )
+            assert (
+                "dice_roll" not in param_names
+            ), f"Method {method_name} MUST NOT have dice_roll parameter"
 
     def test_belief_update_creation_without_dice_roll(self):
         """Test that BeliefUpdate can be created without dice_roll."""
@@ -98,12 +98,12 @@ class TestArchitecturalConstraints:
 
         # Verify that evidence history in belief domain contains only comparison results
         for evidence in game.belief_state.evidence_history:
-            assert hasattr(evidence, "comparison_result"), (
-                "Belief evidence must have comparison_result"
-            )
-            assert not hasattr(evidence, "dice_roll"), (
-                "Belief evidence MUST NOT have dice_roll"
-            )
+            assert hasattr(
+                evidence, "comparison_result"
+            ), "Belief evidence must have comparison_result"
+            assert not hasattr(
+                evidence, "dice_roll"
+            ), "Belief evidence MUST NOT have dice_roll"
 
     def test_domain_import_isolation(self):
         """Test that belief domain doesn't import environment domain."""
@@ -113,12 +113,12 @@ class TestArchitecturalConstraints:
         belief_source = inspect.getsource(belief_module)
 
         # Should not import environment domain
-        assert "from domains.environment" not in belief_source, (
-            "Belief domain MUST NOT import environment domain"
-        )
-        assert "import domains.environment" not in belief_source, (
-            "Belief domain MUST NOT import environment domain"
-        )
+        assert (
+            "from domains.environment" not in belief_source
+        ), "Belief domain MUST NOT import environment domain"
+        assert (
+            "import domains.environment" not in belief_source
+        ), "Belief domain MUST NOT import environment domain"
 
     def test_proper_bayesian_calculation_structure(self):
         """Test that belief updates use probabilistic calculations."""
@@ -135,9 +135,9 @@ class TestArchitecturalConstraints:
         prob_6 = belief_state.get_belief_for_target(6)
 
         assert prob_1 > prob_6, "Higher evidence should favor lower targets"
-        assert abs(prob_6 - 0.0) < 1e-10, (
-            "Target 6 should have zero probability after 'higher' evidence"
-        )
+        assert (
+            abs(prob_6 - 0.0) < 1e-10
+        ), "Target 6 should have zero probability after 'higher' evidence"
 
     def test_coordination_layer_responsibility(self):
         """Test that coordination layer properly orchestrates without leaking information."""
@@ -148,21 +148,21 @@ class TestArchitecturalConstraints:
         state = game.play_round()
 
         # Game state should have full information (for display)
-        assert hasattr(state.evidence_history[0], "dice_roll"), (
-            "Game state should maintain full evidence for display"
-        )
-        assert hasattr(state.evidence_history[0], "comparison_result"), (
-            "Game state should maintain comparison results"
-        )
+        assert hasattr(
+            state.evidence_history[0], "dice_roll"
+        ), "Game state should maintain full evidence for display"
+        assert hasattr(
+            state.evidence_history[0], "comparison_result"
+        ), "Game state should maintain comparison results"
 
         # But belief state should only have comparison results
         belief_evidence = game.belief_state.evidence_history[0]
-        assert hasattr(belief_evidence, "comparison_result"), (
-            "Belief evidence must have comparison_result"
-        )
-        assert not hasattr(belief_evidence, "dice_roll"), (
-            "Belief evidence MUST NOT have dice_roll"
-        )
+        assert hasattr(
+            belief_evidence, "comparison_result"
+        ), "Belief evidence must have comparison_result"
+        assert not hasattr(
+            belief_evidence, "dice_roll"
+        ), "Belief evidence MUST NOT have dice_roll"
 
     def test_no_hard_coded_probabilities(self):
         """Test that belief calculations are dynamic, not hard-coded."""
@@ -181,10 +181,10 @@ class TestArchitecturalConstraints:
 
             # Target 1 should have highest probability for "higher" evidence
 
-            assert prob_1 > prob_last, (
-                f"Target 1 should be more likely than target {dice_sides}"
-            )
-            assert abs(prob_last - 0.0) < 1e-10, (
-                f"Target {dice_sides} should have zero probability"
-            )
+            assert (
+                prob_1 > prob_last
+            ), f"Target 1 should be more likely than target {dice_sides}"
+            assert (
+                abs(prob_last - 0.0) < 1e-10
+            ), f"Target {dice_sides} should have zero probability"
             assert prob_1 > 0, "Target 1 should have non-zero probability"