tactus 0.36.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

tactus/core/registry.py

@@ -6,7 +6,7 @@ procedure declarations from .tac files.
 """
 
 import logging
-from typing import Any
+from typing import Any, Dict, Optional, Union
 
 from pydantic import BaseModel, Field, ValidationError, ConfigDict
 
@@ -19,7 +19,7 @@ class OutputFieldDeclaration(BaseModel):
     name: str
     field_type: str = Field(alias="type")  # string, number, boolean, array, object
     required: bool = False
-    description: str | None = None
+    description: Optional[str] = None
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -31,7 +31,7 @@ class MessageHistoryConfiguration(BaseModel):
     """
 
     source: str = "own"  # "own", "shared", or another agent's name
-    filter: Any | None = None  # Lua function reference or filter name
+    filter: Optional[Any] = None  # Lua function reference or filter name
 
 
 class AgentOutputSchema(BaseModel):
@@ -44,21 +44,21 @@ class AgentDeclaration(BaseModel):
     """Agent declaration from DSL."""
 
     name: str
-    provider: str | None = None
-    model: str | dict[str, Any] = "gpt-4o"
-    system_prompt: str | Any  # String with {markers} or Lua function
-    initial_message: str | None = None
+    provider: Optional[str] = None
+    model: Union[str, Dict[str, Any]] = "gpt-4o"
+    system_prompt: Union[str, Any]  # String with {markers} or Lua function
+    initial_message: Optional[str] = None
     tools: list[Any] = Field(default_factory=list)  # Tool/toolset references and expressions
     inline_tools: list[dict[str, Any]] = Field(default_factory=list)  # Inline tool definitions
-    output: AgentOutputSchema | None = None  # Aligned with pydantic-ai
-    message_history: MessageHistoryConfiguration | None = None
+    output: Optional[AgentOutputSchema] = None  # Aligned with pydantic-ai
+    message_history: Optional[MessageHistoryConfiguration] = None
     max_turns: int = 50
     disable_streaming: bool = (
         False  # Disable streaming for models that don't support tools in streaming mode
     )
-    temperature: float | None = None
-    max_tokens: int | None = None
-    model_type: str | None = None  # e.g., "chat", "responses" for reasoning models
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    model_type: Optional[str] = None  # e.g., "chat", "responses" for reasoning models
 
     model_config = ConfigDict(extra="allow")
 
@@ -69,9 +69,9 @@ class HITLDeclaration(BaseModel):
     name: str
     hitl_type: str = Field(alias="type")  # approval, input, review
     message: str
-    timeout: int | None = None
+    timeout: Optional[int] = None
     default: Any = None
-    options: list[dict[str, Any]] | None = None
+    options: Optional[list[dict[str, Any]]] = None
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -81,9 +81,9 @@ class ScenarioDeclaration(BaseModel):
 
     name: str
     given: dict[str, Any] = Field(default_factory=dict)
-    when: str | None = None  # defaults to "procedure_completes"
-    then_output: dict[str, Any] | None = None
-    then_state: dict[str, Any] | None = None
+    when: Optional[str] = None  # defaults to "procedure_completes"
+    then_output: Optional[Dict[str, Any]] = None
+    then_state: Optional[Dict[str, Any]] = None
     mocks: dict[str, Any] = Field(default_factory=dict)  # tool_name -> response
 
 
@@ -134,7 +134,7 @@ class ProcedureRegistry(BaseModel):
     model_config = {"arbitrary_types_allowed": True}
 
     # Metadata
-    description: str | None = None
+    description: Optional[str] = None
 
     # Declarations
     input_schema: dict[str, Any] = Field(default_factory=dict)
@@ -154,26 +154,26 @@ class ProcedureRegistry(BaseModel):
     message_history_config: dict[str, Any] = Field(default_factory=dict)
 
     # Gherkin BDD Testing
-    gherkin_specifications: str | None = None  # Raw Gherkin text
+    gherkin_specifications: Optional[str] = None  # Raw Gherkin text
     specs_from_references: list[str] = Field(default_factory=list)  # External spec file paths
     custom_steps: dict[str, Any] = Field(default_factory=dict)  # step_text -> lua_function
     evaluation_config: dict[str, Any] = Field(default_factory=dict)  # runs, parallel, etc.
 
     # Pydantic Evals Integration
-    pydantic_evaluations: dict[str, Any] | None = None  # Pydantic Evals configuration
+    pydantic_evaluations: Optional[Dict[str, Any]] = None  # Pydantic Evals configuration
 
     # Prompts
     prompts: dict[str, str] = Field(default_factory=dict)
-    return_prompt: str | None = None
-    error_prompt: str | None = None
-    status_prompt: str | None = None
+    return_prompt: Optional[str] = None
+    error_prompt: Optional[str] = None
+    status_prompt: Optional[str] = None
 
     # Execution settings
     async_enabled: bool = False
     max_depth: int = 5
     max_turns: int = 50
-    default_provider: str | None = None
-    default_model: str | None = None
+    default_provider: Optional[str] = None
+    default_model: Optional[str] = None
 
     # Named procedures (for in-file sub-procedures)
     named_procedures: dict[str, dict[str, Any]] = Field(default_factory=dict)
@@ -193,8 +193,8 @@ class ValidationMessage(BaseModel):
 
     level: str  # "error" or "warning"
     message: str
-    location: tuple[int, int] | None = None
-    declaration: str | None = None
+    location: Optional[tuple[int, int]] = None
+    declaration: Optional[str] = None
 
 
 class ValidationResult(BaseModel):
@@ -203,7 +203,7 @@ class ValidationResult(BaseModel):
     valid: bool
     errors: list[ValidationMessage] = Field(default_factory=list)
     warnings: list[ValidationMessage] = Field(default_factory=list)
-    registry: ProcedureRegistry | None = None
+    registry: Optional["ProcedureRegistry"] = None
 
 
 class RegistryBuilder:
@@ -229,7 +229,7 @@ class RegistryBuilder:
         self,
         name: str,
         config: dict,
-        output_schema: dict | None = None,
+        output_schema: Optional[dict] = None,
     ) -> None:
         """Register an agent declaration."""
         agent_config = dict(config)

tactus/core/runtime.py

@@ -13,7 +13,7 @@ import io
 import logging
 import time
 import uuid
-from typing import Any
+from typing import Any, Dict, List, Optional
 
 from tactus.core.registry import ProcedureRegistry, RegistryBuilder
 from tactus.core.dsl_stubs import create_dsl_stubs, lua_table_to_dict
@@ -68,19 +68,19 @@ class TactusRuntime:
     def __init__(
         self,
         procedure_id: str,
-        storage_backend: StorageBackend | None = None,
-        hitl_handler: HITLHandler | None = None,
-        chat_recorder: ChatRecorder | None = None,
+        storage_backend: Optional[StorageBackend] = None,
+        hitl_handler: Optional[HITLHandler] = None,
+        chat_recorder: Optional[ChatRecorder] = None,
         mcp_server=None,
-        mcp_servers: dict[str, Any] | None = None,
-        openai_api_key: str | None = None,
+        mcp_servers: Optional[Dict[str, Any]] = None,
+        openai_api_key: Optional[str] = None,
         log_handler=None,
-        tool_primitive: ToolPrimitive | None = None,
+        tool_primitive: Optional[ToolPrimitive] = None,
         recursion_depth: int = 0,
-        tool_paths: list[str] | None = None,
-        external_config: dict[str, Any] | None = None,
-        run_id: str | None = None,
-        source_file_path: str | None = None,
+        tool_paths: Optional[List[str]] = None,
+        external_config: Optional[Dict[str, Any]] = None,
+        run_id: Optional[str] = None,
+        source_file_path: Optional[str] = None,
     ):
         """
         Initialize the Tactus runtime.
@@ -144,31 +144,31 @@ class TactusRuntime:
         self.source_file_path = source_file_path
 
         # Will be initialized during setup
-        self.config: dict[str, Any] | None = None  # Legacy YAML support
-        self.registry: ProcedureRegistry | None = None  # New DSL registry
-        self.lua_sandbox: LuaSandbox | None = None
-        self.output_validator: OutputValidator | None = None
-        self.template_resolver: TemplateResolver | None = None
-        self.message_history_manager: MessageHistoryManager | None = None
+        self.config: Optional[Dict[str, Any]] = None  # Legacy YAML support
+        self.registry: Optional[ProcedureRegistry] = None  # New DSL registry
+        self.lua_sandbox: Optional[LuaSandbox] = None
+        self.output_validator: Optional[OutputValidator] = None
+        self.template_resolver: Optional[TemplateResolver] = None
+        self.message_history_manager: Optional[MessageHistoryManager] = None
 
         # Execution context
-        self.execution_context: BaseExecutionContext | None = None
+        self.execution_context: Optional[BaseExecutionContext] = None
 
         # Primitives (shared across all agents)
-        self.state_primitive: StatePrimitive | None = None
-        self.iterations_primitive: IterationsPrimitive | None = None
-        self.stop_primitive: StopPrimitive | None = None
-        self.tool_primitive: ToolPrimitive | None = None
-        self.human_primitive: HumanPrimitive | None = None
-        self.step_primitive: StepPrimitive | None = None
-        self.checkpoint_primitive: CheckpointPrimitive | None = None
-        self.log_primitive: LogPrimitive | None = None
-        self.json_primitive: JsonPrimitive | None = None
-        self.retry_primitive: RetryPrimitive | None = None
-        self.file_primitive: FilePrimitive | None = None
-        self.procedure_primitive: ProcedurePrimitive | None = None
-        self.system_primitive: SystemPrimitive | None = None
-        self.host_primitive: HostPrimitive | None = None
+        self.state_primitive: Optional[StatePrimitive] = None
+        self.iterations_primitive: Optional[IterationsPrimitive] = None
+        self.stop_primitive: Optional[StopPrimitive] = None
+        self.tool_primitive: Optional[ToolPrimitive] = None
+        self.human_primitive: Optional[HumanPrimitive] = None
+        self.step_primitive: Optional[StepPrimitive] = None
+        self.checkpoint_primitive: Optional[CheckpointPrimitive] = None
+        self.log_primitive: Optional[LogPrimitive] = None
+        self.json_primitive: Optional[JsonPrimitive] = None
+        self.retry_primitive: Optional[RetryPrimitive] = None
+        self.file_primitive: Optional[FilePrimitive] = None
+        self.procedure_primitive: Optional[ProcedurePrimitive] = None
+        self.system_primitive: Optional[SystemPrimitive] = None
+        self.host_primitive: Optional[HostPrimitive] = None
 
         # Agent primitives (one per agent)
         self.agents: dict[str, Any] = {}
@@ -181,17 +181,17 @@ class TactusRuntime:
 
         # User dependencies (HTTP clients, DB connections, etc.)
         self.user_dependencies: dict[str, Any] = {}
-        self.dependency_manager: Any | None = None  # ResourceManager for cleanup
+        self.dependency_manager: Optional[Any] = None  # ResourceManager for cleanup
 
         # Mock manager for testing
-        self.mock_manager: Any | None = None  # MockManager instance
-        self.external_agent_mocks: dict[str, list[dict[str, Any]]] | None = None
+        self.mock_manager: Optional[Any] = None  # MockManager instance
+        self.external_agent_mocks: Optional[Dict[str, List[Dict[str, Any]]]] = None
         self.mock_all_agents: bool = False
 
         logger.info("TactusRuntime initialized for procedure %s", procedure_id)
 
     async def execute(
-        self, source: str, context: dict[str, Any] | None = None, format: str = "yaml"
+        self, source: str, context: Optional[Dict[str, Any]] = None, format: str = "yaml"
     ) -> dict[str, Any]:
         """
         Execute a workflow (Lua DSL or legacy YAML format).
@@ -772,7 +772,7 @@ class TactusRuntime:
                 except Exception as e:
                     logger.warning("Error cleaning up dependencies: %s", e)
 
-    def _resolve_sandbox_base_path(self) -> str | None:
+    def _resolve_sandbox_base_path(self) -> Optional[str]:
         # Compute base_path for sandbox from source file path if available.
         # This ensures require() works correctly even when running from different directories.
         if not self.source_file_path:
@@ -798,7 +798,7 @@ class TactusRuntime:
 
     async def _initialize_primitives(
         self,
-        placeholder_tool: ToolPrimitive | None = None,
+        placeholder_tool: Optional[ToolPrimitive] = None,
     ):
         """Initialize all primitive objects.
 
@@ -836,7 +836,7 @@ class TactusRuntime:
 
         logger.debug("All primitives initialized")
 
-    def resolve_toolset(self, name: str) -> Any | None:
+    def resolve_toolset(self, name: str) -> Optional[Any]:
         """
         Resolve a toolset by name from runtime's registered toolsets.
 
@@ -1047,7 +1047,7 @@ class TactusRuntime:
         for name, toolset in self.toolset_registry.items():
             logger.debug(f"  - {name}: {type(toolset)} -> {toolset}")
 
-    async def _resolve_tool_source(self, tool_name: str, source: str) -> Any | None:
+    async def _resolve_tool_source(self, tool_name: str, source: str) -> Optional[Any]:
         """
         Resolve a tool from an external source.
 
@@ -1442,7 +1442,7 @@ class TactusRuntime:
 
     async def _create_toolset_from_config(
         self, name: str, definition: dict[str, Any]
-    ) -> Any | None:
+    ) -> Optional[Any]:
         """
         Create toolset from YAML config definition.
 
@@ -2194,7 +2194,7 @@ class TactusRuntime:
             if is_required:
                 fields[field_name] = (field_type, ...)  # Required field
             else:
-                fields[field_name] = (field_type | None, None)  # Optional field
+                fields[field_name] = (Optional[field_type], None)  # Optional field
 
         return create_model(model_name, **fields)
 
@@ -2652,7 +2652,7 @@ class TactusRuntime:
         in_body = False
         brace_depth = 0
         function_depth = 0  # Track function...end blocks
-        long_string_eq: str | None = None
+        long_string_eq: Optional[str] = None
 
         decl_start = re.compile(
             r"^\s*(?:"
@@ -2871,7 +2871,7 @@ class TactusRuntime:
         return False
 
     def _parse_declarations(
-        self, source: str, tool_primitive: ToolPrimitive | None = None
+        self, source: str, tool_primitive: Optional[ToolPrimitive] = None
     ) -> ProcedureRegistry:
         """
         Execute .tac to collect declarations.

tactus/dspy/broker_lm.py

@@ -11,7 +11,7 @@ while still supporting streaming via DSPy's `streamify()` mechanism.
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import Any, Dict, List, Optional
 
 import dspy
 import litellm
@@ -42,10 +42,10 @@ class BrokeredLM(dspy.BaseLM):
         model: str,
         *,
         model_type: str = "chat",
-        temperature: float | None = None,
-        max_tokens: int | None = None,
-        cache: bool | None = None,
-        socket_path: str | None = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        cache: Optional[bool] = None,
+        socket_path: Optional[str] = None,
         **kwargs: Any,
     ):
         if model_type != "chat":
@@ -70,12 +70,18 @@ class BrokeredLM(dspy.BaseLM):
         self._client = env_client
 
     def forward(
-        self, prompt: str | None = None, messages: list[dict[str, Any]] | None = None, **kwargs: Any
+        self,
+        prompt: Optional[str] = None,
+        messages: Optional[List[Dict[str, Any]]] = None,
+        **kwargs: Any,
     ):
         return syncify(self.aforward)(prompt=prompt, messages=messages, **kwargs)
 
     async def aforward(
-        self, prompt: str | None = None, messages: list[dict[str, Any]] | None = None, **kwargs: Any
+        self,
+        prompt: Optional[str] = None,
+        messages: Optional[List[Dict[str, Any]]] = None,
+        **kwargs: Any,
     ):
         provider, model_id = _split_provider_model(self.model)
 

tactus/dspy/config.py

@@ -103,10 +103,13 @@ def configure_lm(
 
     logger = logging.getLogger(__name__)
 
-    adapter = ChatAdapter(use_native_function_calling=True)
-    logger.info(
-        f"[ADAPTER] Created ChatAdapter with use_native_function_calling={adapter.use_native_function_calling}"
-    )
+    try:
+        adapter = ChatAdapter(use_native_function_calling=True)
+    except TypeError:
+        adapter = ChatAdapter()
+
+    use_native = getattr(adapter, "use_native_function_calling", None)
+    logger.info(f"[ADAPTER] Created ChatAdapter with use_native_function_calling={use_native}")
 
     # Set as global default with adapter
     dspy.configure(lm=lm, adapter=adapter)

tactus/primitives/model.py

@@ -27,7 +27,7 @@ class ModelPrimitive:
         self,
         model_name: str,
         config: dict,
-        context: ExecutionContext | None = None,
+        context: Optional[ExecutionContext] = None,
         mock_manager: Optional[Any] = None,
     ):
         """

tactus/primitives/procedure.py

@@ -550,7 +550,7 @@ class ProcedurePrimitive:
 
         name_path = Path(name)
 
-        def add_candidates(base: Path | None, rel: Path) -> None:
+        def add_candidates(base: Optional[Path], rel: Path) -> None:
             candidate = (base / rel) if base is not None else rel
             add_path(candidate)
             if candidate.suffix != ".tac":

tactus/primitives/state.py

@@ -10,7 +10,7 @@ Provides:
 """
 
 import logging
-from typing import Any
+from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -23,7 +23,7 @@ class StatePrimitive:
     progress, accumulate results, and coordinate between agents.
     """
 
-    def __init__(self, state_schema: dict[str, Any] | None = None):
+    def __init__(self, state_schema: Optional[Dict[str, Any]] = None):
         """
         Initialize state storage.
 

tactus/sandbox/container_runner.py

@@ -17,7 +17,7 @@ import tempfile
 import time
 import uuid
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from .config import SandboxConfig
 from .docker_manager import (
@@ -523,6 +523,11 @@ class ContainerRunner:
                         llm_backend_config=llm_backend_config,
                     )
                 finally:
+                    try:
+                        await broker_server.aclose()
+                        broker_server = None
+                    except Exception:
+                        logger.debug("[BROKER] Failed to close broker server", exc_info=True)
                     # Cancel broker task when container finishes
                     broker_task.cancel()
                     try:
@@ -589,7 +594,7 @@ class ContainerRunner:
         """
         broker_transport = (self.config.broker_transport or "stdio").lower()
 
-        stdio_request_prefix: str | None = None
+        stdio_request_prefix: Optional[str] = None
         if broker_transport == "stdio":
             from tactus.broker.server import OpenAIChatBackend
             from tactus.broker.server import HostToolRegistry
@@ -950,9 +955,9 @@ class ContainerRunner:
         )
         logger.debug("[SANDBOX] Spawned container process pid=%s", process.pid)
 
-        stdout_task: asyncio.Task[None] | None = None
-        stderr_task: asyncio.Task[None] | None = None
-        wait_task: asyncio.Task[int] | None = None
+        stdout_task: Optional[asyncio.Task[None]] = None
+        stderr_task: Optional[asyncio.Task[None]] = None
+        wait_task: Optional[asyncio.Task[int]] = None
 
         try:
             assert process.stdin is not None
@@ -1159,7 +1164,7 @@ class ContainerRunner:
             return
 
         # Rich/terminal: parse our container log format and re-emit.
-        current: tuple[str, int, list[str]] | None = None  # (logger_name, levelno, lines)
+        current: Optional[Tuple[str, int, List[str]]] = None  # (logger_name, levelno, lines)
 
         def flush_current() -> None:
             nonlocal current

tactus/testing/context.py

@@ -45,18 +45,18 @@ class TactusTestContext:
         self.total_tokens: int = 0  # Track total tokens
         self.cost_breakdown: List[Any] = []  # Track per-call costs
         self._agent_mock_turns: Dict[str, List[Dict[str, Any]]] = {}
-        self._scenario_message: str | None = None
+        self._scenario_message: Optional[str] = None
 
     def set_scenario_message(self, message: str) -> None:
         """Set the scenario's primary injected message (for in-spec mocking coordination)."""
         self._scenario_message = message
 
-    def get_scenario_message(self) -> str | None:
+    def get_scenario_message(self) -> Optional[str]:
         """Get the scenario's primary injected message, if set."""
         return self._scenario_message
 
     def mock_agent_response(
-        self, agent: str, message: str, when_message: str | None = None
+        self, agent: str, message: str, when_message: Optional[str] = None
     ) -> None:
         """Add a mocked agent response for this scenario (temporal; 1 per agent turn).
 
@@ -79,8 +79,8 @@ class TactusTestContext:
         self,
         agent: str,
         tool: str,
-        args: Dict[str, Any] | None = None,
-        when_message: str | None = None,
+        args: Optional[Dict[str, Any]] = None,
+        when_message: Optional[str] = None,
     ) -> None:
         """Add a mocked tool call to an agent's next mocked turn for this scenario."""
         args = args or {}
@@ -114,7 +114,7 @@ class TactusTestContext:
             self.runtime.external_agent_mocks = self._agent_mock_turns
 
     def mock_agent_data(
-        self, agent: str, data: Dict[str, Any], when_message: str | None = None
+        self, agent: str, data: Dict[str, Any], when_message: Optional[str] = None
     ) -> None:
         """Set structured output mock data for an agent's next mocked turn.
 

tactus/testing/evaluation_runner.py

@@ -94,6 +94,9 @@ class TactusEvaluationRunner(TactusTestRunner):
             EvaluationResult with all metrics
         """
         logger.info(f"Evaluating scenario '{scenario_name}' with {runs} runs")
+        run_iteration = self._run_single_iteration
+        if isinstance(run_iteration, staticmethod):
+            run_iteration = run_iteration.__func__
 
         # Run scenario N times
         if parallel:
@@ -102,12 +105,9 @@ class TactusEvaluationRunner(TactusTestRunner):
             ctx = multiprocessing.get_context("spawn")
             with ctx.Pool(processes=workers) as pool:
                 iteration_args = [(scenario_name, str(self.work_dir), i) for i in range(runs)]
-                results = pool.starmap(self._run_single_iteration, iteration_args)
+                results = pool.starmap(run_iteration, iteration_args)
         else:
-            results = [
-                self._run_single_iteration(scenario_name, str(self.work_dir), i)
-                for i in range(runs)
-            ]
+            results = [run_iteration(scenario_name, str(self.work_dir), i) for i in range(runs)]
 
         # Calculate metrics
         return self._calculate_metrics(scenario_name, results)

tactus/testing/steps/builtin.py

@@ -14,7 +14,7 @@ Provides a comprehensive library of steps for testing:
 import logging
 import re
 import ast
-from typing import Any
+from typing import Any, Optional
 
 from .registry import StepRegistry
 
@@ -645,7 +645,7 @@ def step_agent_takes_turn(context: Any, agent: str) -> None:
 
 
 def step_mock_agent_responds_with(
-    context: Any, agent: str, message: str, when_message: str | None = None
+    context: Any, agent: str, message: str, when_message: Optional[str] = None
 ) -> None:
     """Configure a per-scenario mock agent response (temporal)."""
     message, _ = _parse_step_string_literal(message)

tactus/testing/test_runner.py

@@ -128,6 +128,10 @@ class TactusTestRunner:
             if not scenarios:
                 raise ValueError(f"Scenario not found: {scenario_filter}")
 
+        run_scenario = self._run_single_scenario
+        if isinstance(run_scenario, staticmethod):
+            run_scenario = run_scenario.__func__
+
         # Run scenarios
         if parallel and len(scenarios) > 1:
             # Run in parallel using 'spawn' to avoid Behave global state conflicts
@@ -135,13 +139,11 @@ class TactusTestRunner:
             ctx = multiprocessing.get_context("spawn")
             with ctx.Pool(processes=min(len(scenarios), os.cpu_count() or 1)) as pool:
                 scenario_results = pool.starmap(
-                    self._run_single_scenario, [(s.name, str(self.work_dir)) for s in scenarios]
+                    run_scenario, [(s.name, str(self.work_dir)) for s in scenarios]
                 )
         else:
             # Run sequentially
-            scenario_results = [
-                self._run_single_scenario(s.name, str(self.work_dir)) for s in scenarios
-            ]
+            scenario_results = [run_scenario(s.name, str(self.work_dir)) for s in scenarios]
 
         # Build feature result
         feature_result = self._build_feature_result(scenario_results)

tactus/utils/asyncio_helpers.py

@@ -24,4 +24,5 @@ def clear_closed_event_loop() -> None:
         return
 
     if getattr(current_loop, "is_closed", lambda: False)():
-        asyncio.set_event_loop(None)
+        replacement_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(replacement_loop)

{tactus-0.36.0.dist-info → tactus-0.37.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.36.0
+Version: 0.37.0
 Summary: Tactus: Lua-based DSL for agentic workflows
 Project-URL: Homepage, https://github.com/AnthusAI/Tactus
 Project-URL: Documentation, https://github.com/AnthusAI/Tactus/tree/main/docs
@@ -14,15 +14,17 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.11
+Requires-Python: >=3.9
 Requires-Dist: antlr4-python3-runtime==4.13.1
 Requires-Dist: behave>=1.2.6
 Requires-Dist: boto3>=1.28.0
-Requires-Dist: dotyaml>=0.1.0
+Requires-Dist: dotyaml>=0.1.4
 Requires-Dist: dspy>=2.5
 Requires-Dist: flask-cors>=4.0.0
 Requires-Dist: flask>=3.0.0
@@ -48,9 +50,9 @@ Requires-Dist: typer
 Provides-Extra: dev
 Requires-Dist: antlr4-tools>=0.2.1; extra == 'dev'
 Requires-Dist: behave>=1.2.6; extra == 'dev'
-Requires-Dist: black==25.12.0; extra == 'dev'
+Requires-Dist: black==24.10.0; extra == 'dev'
 Requires-Dist: coverage>=7.4; extra == 'dev'
-Requires-Dist: fastmcp>=2.3.5; extra == 'dev'
+Requires-Dist: fastmcp>=2.3.5; (python_version >= '3.10') and extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest-xdist>=3.0; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'