tactus 0.34.1__py3-none-any.whl → 0.35.1__py3-none-any.whl

tactus/core/mocking.py

@@ -8,9 +8,9 @@ Provides comprehensive mocking capabilities including:
 - Mock state tracking and assertions
 """
 
-import logging
-from typing import Any, Dict, List, Optional, Union
 from dataclasses import dataclass, field
+import logging
+from typing import Any, Optional, Union
 
 logger = logging.getLogger(__name__)
 
@@ -20,7 +20,7 @@ class MockCall:
     """Record of a mock tool call."""
 
     tool_name: str
-    args: Dict[str, Any]
+    args: dict[str, Any]
     result: Any
     call_number: int
     timestamp: float
@@ -36,10 +36,10 @@ class MockConfig:
     static_result: Optional[Any] = None
 
     # Temporal mocks - return different values per call
-    temporal_results: List[Any] = field(default_factory=list)
+    temporal_results: list[Any] = field(default_factory=list)
 
     # Conditional mocks - return based on args
-    conditional_mocks: List[Dict[str, Any]] = field(default_factory=list)
+    conditional_mocks: list[dict[str, Any]] = field(default_factory=list)
 
     # Error simulation
     error: Optional[str] = None
@@ -58,12 +58,12 @@ class MockManager:
 
     def __init__(self):
         """Initialize mock manager."""
-        self.mocks: Dict[str, MockConfig] = {}
-        self.call_history: Dict[str, List[MockCall]] = {}
-        self.call_counts: Dict[str, int] = {}
+        self.mocks: dict[str, MockConfig] = {}
+        self.call_history: dict[str, list[MockCall]] = {}
+        self.call_counts: dict[str, int] = {}
         self.enabled = True  # Global mock enable/disable
 
-    def register_mock(self, tool_name: str, config: Union[MockConfig, Dict[str, Any]]) -> None:
+    def register_mock(self, tool_name: str, config: Union[MockConfig, dict[str, Any]]) -> None:
         """
         Register a mock configuration for a tool.
 
@@ -89,9 +89,9 @@ class MockManager:
             mock_config = config
 
         self.mocks[tool_name] = mock_config
-        logger.info(f"Registered mock for tool '{tool_name}'")
+        logger.info("Registered mock for tool '%s'", tool_name)
 
-    def get_mock_response(self, tool_name: str, args: Dict[str, Any]) -> Optional[Any]:
+    def get_mock_response(self, tool_name: str, args: dict[str, Any]) -> Optional[Any]:
         """
         Get mock response for a tool call.
 
@@ -125,14 +125,20 @@ class MockManager:
             if call_number <= len(mock_config.temporal_results):
                 result = mock_config.temporal_results[call_number - 1]
                 logger.debug(
-                    f"Mock '{tool_name}' returning temporal result for call {call_number}: {result}"
+                    "Mock '%s' returning temporal result for call %s: %s",
+                    tool_name,
+                    call_number,
+                    result,
                 )
                 return result
             else:
                 # Fallback to last result if we've exceeded temporal results
                 result = mock_config.temporal_results[-1]
                 logger.debug(
-                    f"Mock '{tool_name}' returning last temporal result (call {call_number}): {result}"
+                    "Mock '%s' returning last temporal result (call %s): %s",
+                    tool_name,
+                    call_number,
+                    result,
                 )
                 return result
 
@@ -141,18 +147,26 @@ class MockManager:
             condition = conditional.get("when", {})
             if self._matches_condition(args, condition):
                 result = conditional.get("return")
-                logger.debug(f"Mock '{tool_name}' matched condition, returning: {result}")
+                logger.debug(
+                    "Mock '%s' matched condition, returning: %s",
+                    tool_name,
+                    result,
+                )
                 return result
 
         # Return static result if configured
         if mock_config.static_result is not None:
-            logger.debug(f"Mock '{tool_name}' returning static result: {mock_config.static_result}")
+            logger.debug(
+                "Mock '%s' returning static result: %s",
+                tool_name,
+                mock_config.static_result,
+            )
             return mock_config.static_result
 
         # No mock response configured
         return None
 
-    def record_call(self, tool_name: str, args: Dict[str, Any], result: Any) -> None:
+    def record_call(self, tool_name: str, args: dict[str, Any], result: Any) -> None:
         """
         Record a tool call for assertions.
 
@@ -180,7 +194,7 @@ class MockManager:
             self.call_history[tool_name] = []
         self.call_history[tool_name].append(call)
 
-        logger.debug(f"Recorded call to '{tool_name}' (call #{call.call_number})")
+        logger.debug("Recorded call to '%s' (call #%s)", tool_name, call.call_number)
 
     def get_call_count(self, tool_name: str) -> int:
         """
@@ -194,7 +208,7 @@ class MockManager:
         """
         return self.call_counts.get(tool_name, 0)
 
-    def get_call_history(self, tool_name: str) -> List[MockCall]:
+    def get_call_history(self, tool_name: str) -> list[MockCall]:
         """
         Get the call history for a tool.
 
@@ -212,7 +226,7 @@ class MockManager:
         self.call_counts.clear()
         logger.debug("Mock manager state reset")
 
-    def _matches_condition(self, args: Dict[str, Any], condition: Dict[str, Any]) -> bool:
+    def _matches_condition(self, args: dict[str, Any], condition: dict[str, Any]) -> bool:
         """
         Check if args match a condition.
 
@@ -227,30 +241,30 @@ class MockManager:
             if key not in args:
                 return False
 
-            arg_value = args[key]
+            argument_value = args[key]
 
             # Handle different pattern types
             if isinstance(pattern, str):
                 # Check for operators
                 if pattern.startswith("contains:"):
                     substring = pattern[9:].strip()
-                    if substring not in str(arg_value):
+                    if substring not in str(argument_value):
                         return False
                 elif pattern.startswith("startswith:"):
                     prefix = pattern[11:].strip()
-                    if not str(arg_value).startswith(prefix):
+                    if not str(argument_value).startswith(prefix):
                         return False
                 elif pattern.startswith("endswith:"):
                     suffix = pattern[9:].strip()
-                    if not str(arg_value).endswith(suffix):
+                    if not str(argument_value).endswith(suffix):
                         return False
                 else:
                     # Exact match
-                    if arg_value != pattern:
+                    if argument_value != pattern:
                         return False
             else:
                 # Direct comparison
-                if arg_value != pattern:
+                if argument_value != pattern:
                     return False
 
         return True
@@ -265,7 +279,7 @@ class MockManager:
         if tool_name:
             if tool_name in self.mocks:
                 self.mocks[tool_name].enabled = True
-                logger.info(f"Enabled mock for tool '{tool_name}'")
+                logger.info("Enabled mock for tool '%s'", tool_name)
         else:
             self.enabled = True
             logger.info("Enabled all mocks")
@@ -280,7 +294,7 @@ class MockManager:
         if tool_name:
             if tool_name in self.mocks:
                 self.mocks[tool_name].enabled = False
-                logger.info(f"Disabled mock for tool '{tool_name}'")
+                logger.info("Disabled mock for tool '%s'", tool_name)
         else:
             self.enabled = False
             logger.info("Disabled all mocks")

tactus/core/output_validator.py

@@ -6,7 +6,7 @@ Enables type safety and composability for sub-agent workflows.
 """
 
 import logging
-from typing import Any, Optional, List
+from typing import Any, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -74,7 +74,22 @@ class OutputValidator:
                 field_count = len(self.schema)
             except TypeError:
                 field_count = 0
-            logger.debug(f"OutputValidator initialized with {field_count} output fields")
+            logger.debug("OutputValidator initialized with %s output fields", field_count)
+
+    @staticmethod
+    def _unwrap_result(output: Any) -> tuple[Any, Any | None]:
+        from tactus.protocols.result import TactusResult
+
+        wrapped_result = output if isinstance(output, TactusResult) else None
+        return (wrapped_result.output if wrapped_result is not None else output, wrapped_result)
+
+    @staticmethod
+    def _normalize_unstructured_output(output: Any) -> Any:
+        if isinstance(output, dict):
+            return output
+        if hasattr(output, "items"):
+            return dict(output.items())
+        return output
 
     def validate(self, output: Any) -> Any:
         """
@@ -91,22 +106,12 @@ class OutputValidator:
         """
         # If a procedure returns a Result wrapper, validate its `.output` payload
         # while preserving the wrapper (so callers can still access usage/cost/etc.).
-        from tactus.protocols.result import TactusResult
-
-        wrapped_result: TactusResult | None = output if isinstance(output, TactusResult) else None
-        if wrapped_result is not None:
-            output = wrapped_result.output
+        output, wrapped_result = self._unwrap_result(output)
 
         # If no schema defined, accept any output
         if not self.schema:
             logger.debug("No output schema defined, skipping validation")
-            if isinstance(output, dict):
-                validated_payload = output
-            elif hasattr(output, "items"):
-                # Lua table - convert to dict
-                validated_payload = dict(output.items())
-            else:
-                validated_payload = output
+            validated_payload = self._normalize_unstructured_output(output)
 
             if wrapped_result is not None:
                 return wrapped_result.model_copy(update={"output": validated_payload})
@@ -151,13 +156,13 @@ class OutputValidator:
                 f"Output must be an object/table, got {type(output).__name__}"
             )
 
-        errors = []
-        validated_output = {}
+        validation_errors: list[str] = []
+        validated_output: dict[str, Any] = {}
 
         # Check required fields and validate types
         for field_name, field_def in self.schema.items():
             if not isinstance(field_def, dict) or "type" not in field_def:
-                errors.append(
+                validation_errors.append(
                     f"Field '{field_name}' uses old type syntax. "
                     f"Use field.{field_def.get('type', 'string')}{{}} instead."
                 )
@@ -165,7 +170,7 @@ class OutputValidator:
             is_required = bool(field_def.get("required", False))
 
             if is_required and field_name not in output:
-                errors.append(f"Required field '{field_name}' is missing")
+                validation_errors.append(f"Required field '{field_name}' is missing")
                 continue
 
             # Skip validation if field not present and not required
@@ -179,7 +184,7 @@ class OutputValidator:
             if expected_type:
                 if not self._check_type(value, expected_type):
                     actual_type = type(value).__name__
-                    errors.append(
+                    validation_errors.append(
                         f"Field '{field_name}' should be {expected_type}, got {actual_type}"
                     )
 
@@ -187,7 +192,7 @@ class OutputValidator:
             if "enum" in field_def and field_def["enum"]:
                 allowed_values = field_def["enum"]
                 if value not in allowed_values:
-                    errors.append(
+                    validation_errors.append(
                         f"Field '{field_name}' has invalid value '{value}'. "
                         f"Allowed values: {allowed_values}"
                     )
@@ -198,13 +203,13 @@ class OutputValidator:
         # Filter undeclared fields (only return declared fields)
         for field_name in output:
             if field_name not in self.schema:
-                logger.debug(f"Filtering undeclared field '{field_name}' from output")
+                logger.debug("Filtering undeclared field '%s' from output", field_name)
 
-        if errors:
-            error_msg = "Output validation failed:\n  " + "\n  ".join(errors)
-            raise OutputValidationError(error_msg)
+        if validation_errors:
+            error_message = "Output validation failed:\n  " + "\n  ".join(validation_errors)
+            raise OutputValidationError(error_message)
 
-        logger.info(f"Output validation passed for {len(validated_output)} fields")
+        logger.info("Output validation passed for %s fields", len(validated_output))
         if wrapped_result is not None:
             return wrapped_result.model_copy(update={"output": validated_output})
         return validated_output
@@ -226,7 +231,7 @@ class OutputValidator:
 
         python_type = self.TYPE_MAP.get(expected_type)
         if not python_type:
-            logger.warning(f"Unknown type '{expected_type}', skipping validation")
+            logger.warning("Unknown type '%s', skipping validation", expected_type)
             return True
 
         # Handle Lua tables as dicts/arrays
@@ -248,44 +253,44 @@ class OutputValidator:
         """
         # Handle Lua tables (have .items() method)
         if hasattr(obj, "items") and not isinstance(obj, dict):
-            return {k: self._convert_lua_tables(v) for k, v in obj.items()}
+            return {key: self._convert_lua_tables(value) for key, value in obj.items()}
 
         # Handle lists
-        elif isinstance(obj, (list, tuple)):
+        if isinstance(obj, (list, tuple)):
             return [self._convert_lua_tables(item) for item in obj]
 
         # Handle dicts
-        elif isinstance(obj, dict):
-            return {k: self._convert_lua_tables(v) for k, v in obj.items()}
+        if isinstance(obj, dict):
+            return {key: self._convert_lua_tables(value) for key, value in obj.items()}
 
         # Return as-is for primitives
-        else:
-            return obj
+        return obj
 
     def get_field_description(self, field_name: str) -> Optional[str]:
         """Get description for an output field."""
-        if field_name in self.schema:
-            field_def = self.schema[field_name]
-            if isinstance(field_def, dict):
-                return field_def.get("description")
+        field_definition = self.schema.get(field_name)
+        if isinstance(field_definition, dict):
+            return field_definition.get("description")
         return None
 
-    def get_required_fields(self) -> List[str]:
+    def get_required_fields(self) -> list[str]:
         """Get list of required output fields."""
         from tactus.core.dsl_stubs import FieldDefinition
 
         return [
-            name
-            for name, def_ in self.schema.items()
-            if isinstance(def_, FieldDefinition) and def_.get("required", False)
+            field_name
+            for field_name, field_definition in self.schema.items()
+            if isinstance(field_definition, FieldDefinition)
+            and field_definition.get("required", False)
         ]
 
-    def get_optional_fields(self) -> List[str]:
+    def get_optional_fields(self) -> list[str]:
         """Get list of optional output fields."""
         from tactus.core.dsl_stubs import FieldDefinition
 
         return [
-            name
-            for name, def_ in self.schema.items()
-            if isinstance(def_, FieldDefinition) and not def_.get("required", False)
+            field_name
+            for field_name, field_definition in self.schema.items()
+            if isinstance(field_definition, FieldDefinition)
+            and not field_definition.get("required", False)
         ]