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

tactus/sandbox/docker_manager.py

@@ -9,7 +9,7 @@ import logging
 import shutil
 import subprocess
 from pathlib import Path
-from typing import Tuple, Optional
+from typing import Optional
 
 logger = logging.getLogger(__name__)
 
@@ -18,7 +18,7 @@ DEFAULT_IMAGE_NAME = "tactus-sandbox"
 DEFAULT_IMAGE_TAG = "local"
 
 
-def resolve_dockerfile_path(tactus_root: Path) -> Tuple[Path, str]:
+def resolve_dockerfile_path(tactus_root: Path) -> tuple[Path, str]:
     """
     Choose the appropriate Dockerfile for the sandbox build.
 
@@ -94,7 +94,7 @@ def calculate_source_hash(tactus_root: Path) -> str:
     return hasher.hexdigest()[:16]
 
 
-def is_docker_available() -> Tuple[bool, str]:
+def is_docker_available() -> tuple[bool, str]:
     """
     Check if Docker is available and running.
 
@@ -134,8 +134,8 @@ def is_docker_available() -> Tuple[bool, str]:
         return False, "Docker daemon not responding (timeout after 10s)"
     except FileNotFoundError:
         return False, "Docker CLI not found"
-    except Exception as e:
-        return False, f"Docker check failed: {e}"
+    except Exception as error:
+        return False, f"Docker check failed: {error}"
 
 
 class DockerManager:
@@ -263,7 +263,7 @@ class DockerManager:
                 return True
 
             if image_hash != current_hash:
-                logger.debug(f"Source hash mismatch: {image_hash} != {current_hash}")
+                logger.debug("Source hash mismatch: %s != %s", image_hash, current_hash)
                 return True
 
         return False
@@ -275,7 +275,7 @@ class DockerManager:
         version: str,
         source_hash: Optional[str] = None,
         verbose: bool = False,
-    ) -> Tuple[bool, str]:
+    ) -> tuple[bool, str]:
         """
         Build the sandbox Docker image.
 
@@ -295,7 +295,7 @@ class DockerManager:
         if not context_path.exists():
             return False, f"Build context not found: {context_path}"
 
-        logger.info(f"Building sandbox image: {self.full_image_name}")
+        logger.info("Building sandbox image: %s", self.full_image_name)
 
         cmd = [
             "docker",
@@ -329,7 +329,7 @@ class DockerManager:
                 for line in iter(process.stdout.readline, ""):
                     if line:
                         output_lines.append(line.rstrip())
-                        logger.info(line.rstrip())
+                        logger.info("%s", line.rstrip())
                 process.wait()
                 returncode = process.returncode
                 output = "\n".join(output_lines)
@@ -344,15 +344,15 @@ class DockerManager:
                 output = result.stderr if result.returncode != 0 else result.stdout
 
             if returncode == 0:
-                logger.info(f"Successfully built: {self.full_image_name}")
+                logger.info("Successfully built: %s", self.full_image_name)
                 return True, f"Successfully built {self.full_image_name}"
             else:
                 return False, f"Build failed: {output}"
 
         except subprocess.TimeoutExpired:
             return False, "Build timed out after 10 minutes"
-        except Exception as e:
-            return False, f"Build failed: {e}"
+        except Exception as error:
+            return False, f"Build failed: {error}"
 
     def ensure_image_exists(
         self,
@@ -360,7 +360,7 @@ class DockerManager:
         context_path: Path,
         version: str,
         force_rebuild: bool = False,
-    ) -> Tuple[bool, str]:
+    ) -> tuple[bool, str]:
         """
         Ensure the sandbox image exists, building if necessary.
 
@@ -378,7 +378,7 @@ class DockerManager:
 
         return True, f"Image {self.full_image_name} is up to date"
 
-    def remove_image(self) -> Tuple[bool, str]:
+    def remove_image(self) -> tuple[bool, str]:
         """
         Remove the sandbox image.
 
@@ -399,10 +399,10 @@ class DockerManager:
                 return True, f"Removed {self.full_image_name}"
             else:
                 return False, f"Failed to remove image: {result.stderr}"
-        except Exception as e:
-            return False, f"Failed to remove image: {e}"
+        except Exception as error:
+            return False, f"Failed to remove image: {error}"
 
-    def cleanup_old_images(self, keep_tags: Optional[list] = None) -> int:
+    def cleanup_old_images(self, keep_tags: Optional[list[str]] = None) -> int:
         """
         Remove old sandbox images, keeping specified tags.
 
@@ -447,10 +447,10 @@ class DockerManager:
                         )
                         if rm_result.returncode == 0:
                             removed += 1
-                            logger.info(f"Removed old image: {line}")
+                            logger.info("Removed old image: %s", line)
 
             return removed
 
-        except Exception as e:
-            logger.warning(f"Failed to cleanup old images: {e}")
+        except Exception as error:
+            logger.warning("Failed to cleanup old images: %s", error)
             return 0

tactus/sandbox/entrypoint.py

@@ -18,7 +18,7 @@ import os
 import sys
 import time
 import traceback
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from tactus.sandbox.protocol import ExecutionResult
 
@@ -32,8 +32,8 @@ _LOG_LEVELS = {
     "critical": logging.CRITICAL,
 }
 
-_log_level_str = os.environ.get("TACTUS_LOG_LEVEL", "info").strip().lower()
-_log_level = _LOG_LEVELS.get(_log_level_str, logging.INFO)
+_log_level_name = os.environ.get("TACTUS_LOG_LEVEL", "info").strip().lower()
+_log_level = _LOG_LEVELS.get(_log_level_name, logging.INFO)
 
 # CloudWatch-friendly, one line per record.
 _log_fmt = "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
@@ -53,21 +53,21 @@ if _log_level > logging.DEBUG:
     logging.getLogger("tactus.stdlib").setLevel(logging.WARNING)
 
 
-def read_request_from_stdin() -> Optional[Dict[str, Any]]:
+def read_request_from_stdin() -> Optional[dict[str, Any]]:
     """Read the execution request from stdin as JSON."""
     import json
 
     try:
         # Read exactly one JSON message (the initial ExecutionRequest).
         # Keep stdin open for broker responses during execution.
-        input_data = sys.stdin.readline()
-        if not input_data.strip():
+        input_line = sys.stdin.readline()
+        if not input_line.strip():
             logger.error("No input received on stdin")
             return None
 
-        return json.loads(input_data)
-    except json.JSONDecodeError as e:
-        logger.error(f"Failed to parse JSON from stdin: {e}")
+        return json.loads(input_line)
+    except json.JSONDecodeError as error:
+        logger.error("Failed to parse JSON from stdin: %s", error)
         return None
 
 
@@ -82,7 +82,7 @@ def write_result_to_stdout(result: ExecutionResult) -> None:
 
 async def execute_procedure(
     source: str,
-    params: Dict[str, Any],
+    params: dict[str, Any],
     source_file_path: Optional[str] = None,
     format: str = "lua",
     run_id: Optional[str] = None,
@@ -118,14 +118,16 @@ async def execute_procedure(
     log_handler = HTTPCallbackLogHandler.from_environment()
     if log_handler:
         logger.info(
-            f"[SANDBOX] Using HTTP callback log handler: {os.environ.get('TACTUS_CALLBACK_URL')}"
+            "[SANDBOX] Using HTTP callback log handler: %s",
+            os.environ.get("TACTUS_CALLBACK_URL"),
         )
     else:
         # Otherwise, try broker socket streaming (works without container networking, e.g. stdio/UDS).
         log_handler = BrokerLogHandler.from_environment()
         if log_handler:
             logger.info(
-                f"[SANDBOX] Using broker log handler: {os.environ.get('TACTUS_BROKER_SOCKET')}"
+                "[SANDBOX] Using broker log handler: %s",
+                os.environ.get("TACTUS_BROKER_SOCKET"),
             )
         else:
             # Provide cost collection + checkpoint event handling even without IDE callbacks.
@@ -196,7 +198,7 @@ async def main_async() -> int:
     try:
         # Parse request
         request = ExecutionRequest(**request_data)
-        logger.info(f"Executing procedure (id={request.execution_id})")
+        logger.info("Executing procedure (id=%s)", request.execution_id)
 
         # Execute procedure
         proc_result = await execute_procedure(
@@ -218,7 +220,7 @@ async def main_async() -> int:
         return 0
 
     except Exception as e:
-        logger.exception(f"Procedure execution failed: {e}")
+        logger.exception("Procedure execution failed: %s", e)
 
         duration = time.time() - start_time
         result = ExecutionResult.failure(

tactus/sandbox/protocol.py

@@ -6,9 +6,9 @@ over stdio between the host process and the sandboxed container.
 """
 
 import json
-from dataclasses import dataclass, field, asdict
-from typing import Any, Dict, List, Optional
+from dataclasses import asdict, dataclass, field
 from enum import Enum
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -46,7 +46,7 @@ class ExecutionRequest:
     working_dir: str = "/workspace"
 
     # Input parameters for the procedure
-    params: Dict[str, Any] = field(default_factory=dict)
+    params: dict[str, Any] = field(default_factory=dict)
 
     # Unique execution ID for tracking
     execution_id: Optional[str] = None
@@ -101,10 +101,10 @@ class ExecutionResult:
     exit_code: int = 0
 
     # Structured logs from execution
-    logs: List[Dict[str, Any]] = field(default_factory=list)
+    logs: list[dict[str, Any]] = field(default_factory=list)
 
     # Metadata about the execution
-    metadata: Dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
 
     def to_json(self) -> str:
         """Serialize to JSON string."""
@@ -126,8 +126,8 @@ class ExecutionResult:
         cls,
         result: Any,
         duration_seconds: float = 0.0,
-        logs: Optional[List[Dict[str, Any]]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        logs: Optional[list[dict[str, Any]]] = None,
+        metadata: Optional[dict[str, Any]] = None,
     ) -> "ExecutionResult":
         """Create a successful result."""
         return cls(
@@ -147,7 +147,7 @@ class ExecutionResult:
         traceback: Optional[str] = None,
         duration_seconds: float = 0.0,
         exit_code: int = 1,
-        logs: Optional[List[Dict[str, Any]]] = None,
+        logs: Optional[list[dict[str, Any]]] = None,
     ) -> "ExecutionResult":
         """Create a failed result."""
         return cls(
@@ -164,7 +164,7 @@ class ExecutionResult:
     def timeout(
         cls,
         duration_seconds: float,
-        logs: Optional[List[Dict[str, Any]]] = None,
+        logs: Optional[list[dict[str, Any]]] = None,
     ) -> "ExecutionResult":
         """Create a timeout result."""
         return cls(
@@ -198,17 +198,17 @@ def extract_result_from_stdout(stdout: str) -> Optional[ExecutionResult]:
 
     Returns None if no valid result is found.
     """
-    start_idx = stdout.find(RESULT_START_MARKER)
-    if start_idx == -1:
+    start_marker_index = stdout.find(RESULT_START_MARKER)
+    if start_marker_index == -1:
         return None
 
-    end_idx = stdout.find(RESULT_END_MARKER, start_idx)
-    if end_idx == -1:
+    end_marker_index = stdout.find(RESULT_END_MARKER, start_marker_index)
+    if end_marker_index == -1:
         return None
 
     # Extract JSON between markers
-    json_start = start_idx + len(RESULT_START_MARKER)
-    json_str = stdout[json_start:end_idx].strip()
+    json_start = start_marker_index + len(RESULT_START_MARKER)
+    json_str = stdout[json_start:end_marker_index].strip()
 
     try:
         return ExecutionResult.from_json(json_str)

tactus/stdlib/classify/llm.py

@@ -221,12 +221,10 @@ Start your response with the classification on its own line."""
 
     def _parse_response(self, response: str) -> Dict[str, Any]:
         """Parse classification response to extract value and explanation."""
-        if not response:
+        if not response or not response.strip():
             return {"value": None, "explanation": None}
 
         lines = response.strip().split("\n")
-        if not lines:
-            return {"value": None, "explanation": None}
 
         # First non-empty line should be the classification
         first_line = lines[0].strip()

tactus/stdlib/core/validation.py

@@ -185,9 +185,6 @@ def _calculate_similarity(s1: str, s2: str) -> float:
     intersection = len(set1 & set2)
     union = len(set1 | set2)
 
-    if union == 0:
-        return 0.0
-
     return intersection / union
 
 

tactus/testing/pydantic_eval_runner.py

@@ -12,7 +12,7 @@ from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
 
 from .eval_models import EvaluationConfig, EvalCase
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from tactus.core.runtime import TactusRuntime
 
 logger = logging.getLogger(__name__)

tactus/utils/asyncio_helpers.py

@@ -0,0 +1,27 @@
+"""
+Asyncio helper utilities.
+
+These helpers protect synchronous codepaths from inheriting a closed event loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+
+def clear_closed_event_loop() -> None:
+    """
+    Ensure the current thread does not hold a closed event loop.
+
+    Pytest-asyncio and other frameworks can leave a closed loop set as the
+    current event loop after async tests complete. Synchronous code that uses
+    asyncio.run() or creates its own event loop should not inherit a closed
+    loop reference. This helper resets the current loop to None when needed.
+    """
+    try:
+        current_loop = asyncio.get_event_loop()
+    except RuntimeError:
+        return
+
+    if getattr(current_loop, "is_closed", lambda: False)():
+        asyncio.set_event_loop(None)

tactus/utils/cost_calculator.py

@@ -4,7 +4,7 @@ Cost calculator for LLM usage.
 Calculates costs based on token usage and model pricing.
 """
 
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Optional
 from .model_pricing import get_model_pricing, normalize_model_name
 
 
@@ -44,20 +44,20 @@ class CostCalculator:
                 - pricing_found: Whether pricing was found (False = using defaults)
         """
         # Normalize model name and get provider
-        normalized_model, detected_provider = normalize_model_name(model_name, provider)
+        normalized_model_name, detected_provider = normalize_model_name(model_name, provider)
 
         # Get pricing
-        pricing = get_model_pricing(model_name, provider)
+        model_pricing = get_model_pricing(model_name, provider)
 
         # Calculate costs (pricing is per million tokens)
-        prompt_cost = (prompt_tokens / 1_000_000) * pricing["input"]
-        completion_cost = (completion_tokens / 1_000_000) * pricing["output"]
+        prompt_cost = (prompt_tokens / 1_000_000) * model_pricing["input"]
+        completion_cost = (completion_tokens / 1_000_000) * model_pricing["output"]
 
         # Calculate cache savings if applicable
         cache_cost = None
         if cache_tokens and cache_tokens > 0:
             # Cached tokens typically cost 10% of input tokens
-            cache_cost = (cache_tokens / 1_000_000) * pricing["input"] * 0.9
+            cache_cost = (cache_tokens / 1_000_000) * model_pricing["input"] * 0.9
 
         total_cost = prompt_cost + completion_cost
 
@@ -66,7 +66,7 @@ class CostCalculator:
             "completion_cost": completion_cost,
             "cache_cost": cache_cost,
             "total_cost": total_cost,
-            "model": normalized_model,
+            "model": normalized_model_name,
             "provider": detected_provider,
             "pricing_found": True,  # Could track if we used DEFAULT_PRICING
         }

tactus/utils/model_pricing.py

@@ -73,17 +73,16 @@ def normalize_model_name(model_name: str, provider: Optional[str] = None) -> tup
     Returns:
         Tuple of (normalized_model_name, provider)
     """
-    # Extract provider from model name if present
-    if ":" in model_name:
-        parts = model_name.split(":", 1)
-        detected_provider = parts[0].lower()
-        model_only = parts[1]
-        return (model_only, detected_provider)
-
     # Check for Bedrock format (anthropic.claude-...)
     if model_name.startswith("anthropic."):
         return (model_name, "bedrock")
 
+    # Extract provider from model name if present
+    if ":" in model_name:
+        provider_prefix, model_without_prefix = model_name.split(":", 1)
+        detected_provider = provider_prefix.lower()
+        return (model_without_prefix, detected_provider)
+
     # Use provided provider or try to infer
     if provider:
         return (model_name, provider.lower())
@@ -111,19 +110,19 @@ def get_model_pricing(model_name: str, provider: Optional[str] = None) -> Dict[s
     Returns:
         Dict with 'input' and 'output' pricing per million tokens
     """
-    normalized_model, detected_provider = normalize_model_name(model_name, provider)
+    normalized_model_name, detected_provider = normalize_model_name(model_name, provider)
 
     # Look up pricing
     provider_pricing = MODEL_PRICING.get(detected_provider, {})
-    pricing = provider_pricing.get(normalized_model)
+    pricing = provider_pricing.get(normalized_model_name)
 
     if pricing:
         return pricing
 
     # Try without version suffix (e.g., "gpt-4o-2024-11-20" -> "gpt-4o")
-    base_model = normalized_model.split("-")[0:2]  # Get first two parts
-    if len(base_model) >= 2:
-        base_name = "-".join(base_model)
+    base_name_parts = normalized_model_name.split("-")[0:2]
+    if len(base_name_parts) >= 2:
+        base_name = "-".join(base_name_parts)
         pricing = provider_pricing.get(base_name)
         if pricing:
             return pricing