Lint

Author: Andrew Brookins

agent-memory-client/tests/test_tool_schemas.py

@@ -198,9 +198,9 @@ def test_creation_and_editing_tools_exclude_message_type(self):
                 memory_type_prop = params["properties"]["memory_type"]
                 if "enum" in memory_type_prop:
                     if function_name in restricted_tools:
-                        assert "message" not in memory_type_prop["enum"], (
-                            f"Creation/editing tool '{function_name}' should not expose 'message' memory type"
-                        )
+                        assert (
+                            "message" not in memory_type_prop["enum"]
+                        ), f"Creation/editing tool '{function_name}' should not expose 'message' memory type"
                     elif function_name in allowed_tools:
                         # These tools are allowed to have message in enum for filtering
                         pass
@@ -215,9 +215,9 @@ def test_creation_and_editing_tools_exclude_message_type(self):
                     and function_name in restricted_tools
                 ):
                     memory_type_prop = items["properties"]["memory_type"]
-                    assert "message" not in memory_type_prop["enum"], (
-                        f"Creation/editing tool '{function_name}' should not expose 'message' memory type in nested properties"
-                    )
+                    assert (
+                        "message" not in memory_type_prop["enum"]
+                    ), f"Creation/editing tool '{function_name}' should not expose 'message' memory type in nested properties"
 
 
 class TestAnthropicSchemas:
@@ -290,9 +290,9 @@ def test_anthropic_schemas_exclude_message_type_for_creation(self):
                 memory_type_prop = params["properties"]["memory_type"]
                 if "enum" in memory_type_prop:
                     if function_name in restricted_tools:
-                        assert "message" not in memory_type_prop["enum"], (
-                            f"Anthropic creation/editing tool '{function_name}' should not expose 'message' memory type"
-                        )
+                        assert (
+                            "message" not in memory_type_prop["enum"]
+                        ), f"Anthropic creation/editing tool '{function_name}' should not expose 'message' memory type"
                     elif function_name in allowed_tools:
                         # These tools are allowed to have message in enum for filtering
                         pass
@@ -307,6 +307,6 @@ def test_anthropic_schemas_exclude_message_type_for_creation(self):
                     and function_name in restricted_tools
                 ):
                     memory_type_prop = items["properties"]["memory_type"]
-                    assert "message" not in memory_type_prop["enum"], (
-                        f"Anthropic creation/editing tool '{function_name}' should not expose 'message' memory type in nested properties"
-                    )
+                    assert (
+                        "message" not in memory_type_prop["enum"]
+                    ), f"Anthropic creation/editing tool '{function_name}' should not expose 'message' memory type in nested properties"

tests/test_api.py

@@ -378,54 +378,54 @@ async def test_put_memory_context_percentages_with_summarization_regression(
         # Verify summarization occurred (message count should be reduced)
         original_message_count = len(payload["messages"])
         final_message_count = len(data["messages"])
-        assert final_message_count < original_message_count, (
-            f"Expected summarization to reduce messages from {original_message_count} to less, but got {final_message_count}"
-        )
+        assert (
+            final_message_count < original_message_count
+        ), f"Expected summarization to reduce messages from {original_message_count} to less, but got {final_message_count}"
 
         # Verify context summary was created
-        assert data["context"] is not None, (
-            "Context should not be None after summarization"
-        )
-        assert data["context"].strip() != "", (
-            "Context should not be empty after summarization"
-        )
+        assert (
+            data["context"] is not None
+        ), "Context should not be None after summarization"
+        assert (
+            data["context"].strip() != ""
+        ), "Context should not be empty after summarization"
 
         # REGRESSION TEST: Context percentages should NOT be null even after summarization
         # They should reflect the current state (post-summarization) with small percentages
         assert "context_percentage_total_used" in data
         assert "context_percentage_until_summarization" in data
-        assert data["context_percentage_total_used"] is not None, (
-            "BUG REGRESSION: context_percentage_total_used should not be null when context_window_max is provided"
-        )
-        assert data["context_percentage_until_summarization"] is not None, (
-            "BUG REGRESSION: context_percentage_until_summarization should not be null when context_window_max is provided"
-        )
+        assert (
+            data["context_percentage_total_used"] is not None
+        ), "BUG REGRESSION: context_percentage_total_used should not be null when context_window_max is provided"
+        assert (
+            data["context_percentage_until_summarization"] is not None
+        ), "BUG REGRESSION: context_percentage_until_summarization should not be null when context_window_max is provided"
 
         # Verify the percentages are valid numbers
         total_used = data["context_percentage_total_used"]
         until_summarization = data["context_percentage_until_summarization"]
 
-        assert isinstance(total_used, int | float), (
-            f"context_percentage_total_used should be a number, got {type(total_used)}"
-        )
-        assert isinstance(until_summarization, int | float), (
-            f"context_percentage_until_summarization should be a number, got {type(until_summarization)}"
-        )
-        assert 0 <= total_used <= 100, (
-            f"context_percentage_total_used should be 0-100, got {total_used}"
-        )
-        assert 0 <= until_summarization <= 100, (
-            f"context_percentage_until_summarization should be 0-100, got {until_summarization}"
-        )
+        assert isinstance(
+            total_used, int | float
+        ), f"context_percentage_total_used should be a number, got {type(total_used)}"
+        assert isinstance(
+            until_summarization, int | float
+        ), f"context_percentage_until_summarization should be a number, got {type(until_summarization)}"
+        assert (
+            0 <= total_used <= 100
+        ), f"context_percentage_total_used should be 0-100, got {total_used}"
+        assert (
+            0 <= until_summarization <= 100
+        ), f"context_percentage_until_summarization should be 0-100, got {until_summarization}"
 
         # After summarization, percentages should be reasonable (not necessarily high)
         # They represent the current state of the session post-summarization
-        assert total_used >= 0, (
-            f"Expected non-negative total usage percentage, got {total_used}"
-        )
-        assert until_summarization >= 0, (
-            f"Expected non-negative until_summarization percentage, got {until_summarization}"
-        )
+        assert (
+            total_used >= 0
+        ), f"Expected non-negative total usage percentage, got {total_used}"
+        assert (
+            until_summarization >= 0
+        ), f"Expected non-negative until_summarization percentage, got {until_summarization}"
 
     @pytest.mark.requires_api_keys
     @pytest.mark.asyncio

tests/test_client_tool_calls.py

@@ -587,19 +587,19 @@ def test_all_tool_schemas_exclude_message_type(self):
             if "memory_type" in params["properties"]:
                 memory_type_prop = params["properties"]["memory_type"]
                 if function_name in restricted_tools:
-                    assert "message" not in memory_type_prop.get("enum", []), (
-                        f"Creation/editing tool {function_name} should not expose 'message' memory type"
-                    )
+                    assert (
+                        "message" not in memory_type_prop.get("enum", [])
+                    ), f"Creation/editing tool {function_name} should not expose 'message' memory type"
 
             # Check nested properties (like in create_long_term_memory)
             if "memories" in params["properties"]:
                 items = params["properties"]["memories"].get("items", {})
                 if "properties" in items and "memory_type" in items["properties"]:
                     memory_type_prop = items["properties"]["memory_type"]
                     if function_name in restricted_tools:
-                        assert "message" not in memory_type_prop.get("enum", []), (
-                            f"Creation/editing tool {function_name} should not expose 'message' memory type in nested properties"
-                        )
+                        assert (
+                            "message" not in memory_type_prop.get("enum", [])
+                        ), f"Creation/editing tool {function_name} should not expose 'message' memory type in nested properties"
 
 
 class TestToolCallErrorHandling:

tests/test_context_percentage_calculation.py

@@ -29,22 +29,22 @@ def test_context_percentages_with_context_window_max(self):
             )
         )
 
-        assert total_percentage is not None, (
-            "total_percentage should not be None when context_window_max is provided"
-        )
-        assert until_summarization_percentage is not None, (
-            "until_summarization_percentage should not be None when context_window_max is provided"
-        )
+        assert (
+            total_percentage is not None
+        ), "total_percentage should not be None when context_window_max is provided"
+        assert (
+            until_summarization_percentage is not None
+        ), "until_summarization_percentage should not be None when context_window_max is provided"
         assert isinstance(total_percentage, float), "total_percentage should be a float"
-        assert isinstance(until_summarization_percentage, float), (
-            "until_summarization_percentage should be a float"
-        )
-        assert 0 <= total_percentage <= 100, (
-            "total_percentage should be between 0 and 100"
-        )
-        assert 0 <= until_summarization_percentage <= 100, (
-            "until_summarization_percentage should be between 0 and 100"
-        )
+        assert isinstance(
+            until_summarization_percentage, float
+        ), "until_summarization_percentage should be a float"
+        assert (
+            0 <= total_percentage <= 100
+        ), "total_percentage should be between 0 and 100"
+        assert (
+            0 <= until_summarization_percentage <= 100
+        ), "until_summarization_percentage should be between 0 and 100"
 
     def test_context_percentages_with_model_name(self):
         """Test that context percentages are calculated when model_name is provided"""
@@ -59,16 +59,16 @@ def test_context_percentages_with_model_name(self):
             )
         )
 
-        assert total_percentage is not None, (
-            "total_percentage should not be None when model_name is provided"
-        )
-        assert until_summarization_percentage is not None, (
-            "until_summarization_percentage should not be None when model_name is provided"
-        )
+        assert (
+            total_percentage is not None
+        ), "total_percentage should not be None when model_name is provided"
+        assert (
+            until_summarization_percentage is not None
+        ), "until_summarization_percentage should not be None when model_name is provided"
         assert isinstance(total_percentage, float), "total_percentage should be a float"
-        assert isinstance(until_summarization_percentage, float), (
-            "until_summarization_percentage should be a float"
-        )
+        assert isinstance(
+            until_summarization_percentage, float
+        ), "until_summarization_percentage should be a float"
 
     def test_context_percentages_without_model_info(self):
         """Test that context percentages return None when no model info is provided"""
@@ -83,12 +83,12 @@ def test_context_percentages_without_model_info(self):
             )
         )
 
-        assert total_percentage is None, (
-            "total_percentage should be None when no model info is provided"
-        )
-        assert until_summarization_percentage is None, (
-            "until_summarization_percentage should be None when no model info is provided"
-        )
+        assert (
+            total_percentage is None
+        ), "total_percentage should be None when no model info is provided"
+        assert (
+            until_summarization_percentage is None
+        ), "until_summarization_percentage should be None when no model info is provided"
 
     def test_context_percentages_with_empty_messages(self):
         """Test context percentages with empty messages list but model info provided"""
@@ -101,12 +101,12 @@ def test_context_percentages_with_empty_messages(self):
         )
 
         # CORRECTED: Should return 0.0 when model info is provided, even with empty messages
-        assert total_percentage == 0.0, (
-            "total_percentage should be 0.0 for empty messages when model info provided"
-        )
-        assert until_summarization_percentage == 0.0, (
-            "until_summarization_percentage should be 0.0 for empty messages when model info provided"
-        )
+        assert (
+            total_percentage == 0.0
+        ), "total_percentage should be 0.0 for empty messages when model info provided"
+        assert (
+            until_summarization_percentage == 0.0
+        ), "until_summarization_percentage should be 0.0 for empty messages when model info provided"
 
     def test_context_percentages_precedence(self):
         """Test that context_window_max takes precedence over model_name"""
@@ -131,9 +131,9 @@ def test_context_percentages_precedence(self):
         )
 
         # Results should be the same, proving context_window_max takes precedence
-        assert total_percentage_both == total_percentage_max_only, (
-            "context_window_max should take precedence over model_name"
-        )
+        assert (
+            total_percentage_both == total_percentage_max_only
+        ), "context_window_max should take precedence over model_name"
         assert (
             until_summarization_percentage_both
             == until_summarization_percentage_max_only
@@ -163,9 +163,9 @@ def test_context_percentages_high_token_usage(self):
         assert until_summarization_percentage is not None
         # Should be capped at 100%
         assert total_percentage <= 100.0, "total_percentage should be capped at 100%"
-        assert until_summarization_percentage <= 100.0, (
-            "until_summarization_percentage should be capped at 100%"
-        )
+        assert (
+            until_summarization_percentage <= 100.0
+        ), "until_summarization_percentage should be capped at 100%"
 
     def test_context_percentages_zero_context_window_regression(self):
         """
@@ -185,9 +185,9 @@ def test_context_percentages_zero_context_window_regression(self):
 
         # Should return None for invalid context window
         assert total_percentage is None, "Should return None for zero context window"
-        assert until_summarization_percentage is None, (
-            "Should return None for zero context window"
-        )
+        assert (
+            until_summarization_percentage is None
+        ), "Should return None for zero context window"
 
         # Test with negative context window
         total_percentage, until_summarization_percentage = (
@@ -197,12 +197,12 @@ def test_context_percentages_zero_context_window_regression(self):
         )
 
         # Should return None for invalid context window
-        assert total_percentage is None, (
-            "Should return None for negative context window"
-        )
-        assert until_summarization_percentage is None, (
-            "Should return None for negative context window"
-        )
+        assert (
+            total_percentage is None
+        ), "Should return None for negative context window"
+        assert (
+            until_summarization_percentage is None
+        ), "Should return None for negative context window"
 
     def test_context_percentages_very_small_context_window_regression(self):
         """
@@ -224,17 +224,17 @@ def test_context_percentages_very_small_context_window_regression(self):
         )
 
         # Should handle this gracefully without division by zero
-        assert total_percentage is not None, (
-            "Should handle small context window without error"
-        )
-        assert until_summarization_percentage is not None, (
-            "Should handle small context window without error"
-        )
+        assert (
+            total_percentage is not None
+        ), "Should handle small context window without error"
+        assert (
+            until_summarization_percentage is not None
+        ), "Should handle small context window without error"
         assert isinstance(total_percentage, float), "Should return valid float"
-        assert isinstance(until_summarization_percentage, float), (
-            "Should return valid float"
-        )
+        assert isinstance(
+            until_summarization_percentage, float
+        ), "Should return valid float"
         # until_summarization_percentage should be 100% when threshold is 0
-        assert until_summarization_percentage == 100.0, (
-            "Should return 100% when token threshold is 0"
-        )
+        assert (
+            until_summarization_percentage == 100.0
+        ), "Should return 100% when token threshold is 0"

tests/test_contextual_grounding_integration.py

@@ -449,9 +449,9 @@ async def test_comprehensive_grounding_evaluation_with_judge(self):
 
             # CI Stability: Accept any valid score (>= 0.0) while grounding system is being improved
             # This allows us to track grounding quality without blocking CI on implementation details
-            assert result.overall_score >= 0.0, (
-                f"Invalid score for {example['category']}: {result.overall_score}"
-            )
+            assert (
+                result.overall_score >= 0.0
+            ), f"Invalid score for {example['category']}: {result.overall_score}"
 
             # Log performance for monitoring
             if result.overall_score < 0.05:
@@ -530,6 +530,6 @@ async def test_model_comparison_grounding_quality(self):
             print(f"{model}: {status}")
 
         # At least one model should succeed
-        assert any(r["success"] for r in results_by_model.values()), (
-            "No model successfully completed grounding"
-        )
+        assert any(
+            r["success"] for r in results_by_model.values()
+        ), "No model successfully completed grounding"