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

tactus/primitives/procedure.py

@@ -9,7 +9,7 @@ import logging
 import uuid
 import asyncio
 import threading
-from typing import Any, Optional, Dict, List, Callable
+from typing import Any, Optional, Callable
 from dataclasses import dataclass, field
 from datetime import datetime
 
@@ -29,7 +29,7 @@ class ProcedureHandle:
     completed_at: Optional[datetime] = None
     thread: Optional[threading.Thread] = None
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for Lua access."""
         return {
             "procedure_id": self.procedure_id,
@@ -74,7 +74,7 @@ class ProcedurePrimitive:
     def __init__(
         self,
         execution_context: Any,
-        runtime_factory: Callable[[str, Dict[str, Any]], Any],
+        runtime_factory: Callable[[str, dict[str, Any]], Any],
         lua_sandbox: Any = None,
         max_depth: int = 5,
         current_depth: int = 0,
@@ -94,10 +94,14 @@ class ProcedurePrimitive:
         self.lua_sandbox = lua_sandbox
         self.max_depth = max_depth
         self.current_depth = current_depth
-        self.handles: Dict[str, ProcedureHandle] = {}
+        self.handles: dict[str, ProcedureHandle] = {}
         self._lock = threading.Lock()
 
-        logger.info(f"ProcedurePrimitive initialized (depth {current_depth}/{max_depth})")
+        logger.info(
+            "ProcedurePrimitive initialized (depth %s/%s)",
+            current_depth,
+            max_depth,
+        )
 
     def __call__(self, name: str) -> Any:
         """
@@ -112,16 +116,16 @@ class ProcedurePrimitive:
             raise ProcedureExecutionError("Procedure lookup is not available (lua_sandbox missing)")
 
         try:
-            proc = self.lua_sandbox.lua.globals()[name]
+            procedure_callable = self.lua_sandbox.lua.globals()[name]
         except Exception:
-            proc = None
+            procedure_callable = None
 
-        if proc is None:
+        if procedure_callable is None:
             raise ProcedureExecutionError(f"Named procedure '{name}' not found")
 
-        return proc
+        return procedure_callable
 
-    def run(self, name: str, params: Optional[Dict[str, Any]] = None) -> Any:
+    def run(self, name: str, params: Optional[dict[str, Any]] = None) -> Any:
         """
         Synchronous procedure invocation with auto-checkpointing.
 
@@ -143,16 +147,20 @@ class ProcedurePrimitive:
         if self.current_depth >= self.max_depth:
             raise ProcedureRecursionError(f"Maximum recursion depth ({self.max_depth}) exceeded")
 
-        logger.info(f"Running procedure '{name}' synchronously (depth {self.current_depth})")
+        logger.info(
+            "Running procedure '%s' synchronously (depth %s)",
+            name,
+            self.current_depth,
+        )
 
         # Normalize params
-        params = params or {}
-        if hasattr(params, "items"):
+        procedure_params = params or {}
+        if hasattr(procedure_params, "items"):
             from tactus.core.dsl_stubs import lua_table_to_dict
 
-            params = lua_table_to_dict(params)
-            if isinstance(params, list) and len(params) == 0:
-                params = {}
+            procedure_params = lua_table_to_dict(procedure_params)
+            if isinstance(procedure_params, list) and len(procedure_params) == 0:
+                procedure_params = {}
 
         # Wrap execution in checkpoint for durability
         def execute_procedure():
@@ -161,14 +169,13 @@ class ProcedurePrimitive:
                 source = self._load_procedure_source(name)
 
                 # Create runtime for sub-procedure
-                runtime = self.runtime_factory(name, params)
+                runtime = self.runtime_factory(name, procedure_params)
 
                 # Execute synchronously (runtime.execute is async, so we need to run it)
-                import asyncio
-                import threading
-
                 async def run_subprocedure():
-                    return await runtime.execute(source=source, context=params, format="lua")
+                    return await runtime.execute(
+                        source=source, context=procedure_params, format="lua"
+                    )
 
                 try:
                     asyncio.get_running_loop()
@@ -177,18 +184,18 @@ class ProcedurePrimitive:
                     has_running_loop = False
 
                 if has_running_loop:
-                    result_holder = {}
-                    error_holder = {}
+                    result_holder: dict[str, Any] = {}
+                    error_holder: dict[str, Exception] = {}
 
                     def run_in_thread():
                         try:
                             result_holder["result"] = asyncio.run(run_subprocedure())
-                        except Exception as e:
-                            error_holder["error"] = e
+                        except Exception as error:
+                            error_holder["error"] = error
 
-                    t = threading.Thread(target=run_in_thread, daemon=True)
-                    t.start()
-                    t.join()
+                    worker_thread = threading.Thread(target=run_in_thread, daemon=True)
+                    worker_thread.start()
+                    worker_thread.join()
 
                     if "error" in error_holder:
                         raise error_holder["error"]
@@ -199,20 +206,20 @@ class ProcedurePrimitive:
 
                 # Extract result from execution response
                 if result.get("success"):
-                    logger.info(f"Procedure '{name}' completed successfully")
+                    logger.info("Procedure '%s' completed successfully", name)
                     return result.get("result")
                 else:
                     error_msg = result.get("error", "Unknown error")
-                    logger.error(f"Procedure '{name}' failed: {error_msg}")
+                    logger.error("Procedure '%s' failed: %s", name, error_msg)
                     raise ProcedureExecutionError(f"Procedure '{name}' failed: {error_msg}")
 
             except ProcedureExecutionError:
                 raise
             except ProcedureRecursionError:
                 raise
-            except Exception as e:
-                logger.error(f"Error executing procedure '{name}': {e}")
-                raise ProcedureExecutionError(f"Failed to execute procedure '{name}': {e}")
+            except Exception as error:
+                logger.error("Error executing procedure '%s': %s", name, error)
+                raise ProcedureExecutionError(f"Failed to execute procedure '{name}': {error}")
 
         # Auto-checkpoint sub-procedure call
         # Try to capture Lua source location if available
@@ -228,9 +235,9 @@ class ProcedurePrimitive:
                     try:
                         info = lua_globals.debug.getinfo(level, "Sl")
                         if info:
-                            lua_dict = dict(info.items()) if hasattr(info, "items") else {}
-                            source = lua_dict.get("source", "")
-                            line = lua_dict.get("currentline", -1)
+                            lua_debug_info = dict(info.items()) if hasattr(info, "items") else {}
+                            source = lua_debug_info.get("source", "")
+                            line = lua_debug_info.get("currentline", -1)
                             # Look for a valid source location (not -1, not C function, not internal)
                             if (
                                 line > 0
@@ -238,7 +245,7 @@ class ProcedurePrimitive:
                                 and not source.startswith("=[C]")
                                 and not source.startswith("[string")
                             ):
-                                debug_info = lua_dict
+                                debug_info = lua_debug_info
                                 break
                     except Exception:
                         continue
@@ -257,9 +264,9 @@ class ProcedurePrimitive:
         if not source_info:
             import inspect
 
-            frame = inspect.currentframe()
-            if frame and frame.f_back:
-                caller_frame = frame.f_back
+            current_frame = inspect.currentframe()
+            if current_frame and current_frame.f_back:
+                caller_frame = current_frame.f_back
                 # Use .tac file if available, otherwise use Python file
                 source_info = {
                     "file": self.execution_context.current_tac_file
@@ -272,7 +279,7 @@ class ProcedurePrimitive:
             execute_procedure, "procedure_call", source_info=source_info
         )
 
-    def spawn(self, name: str, params: Optional[Dict[str, Any]] = None) -> ProcedureHandle:
+    def spawn(self, name: str, params: Optional[dict[str, Any]] = None) -> ProcedureHandle:
         """
         Async procedure invocation.
 
@@ -298,19 +305,23 @@ class ProcedurePrimitive:
         with self._lock:
             self.handles[procedure_id] = handle
 
-        logger.info(f"Spawning procedure '{name}' asynchronously (id: {procedure_id})")
+        logger.info(
+            "Spawning procedure '%s' asynchronously (id: %s)",
+            name,
+            procedure_id,
+        )
 
         # Start async execution in thread
-        params = params or {}
+        procedure_params = params or {}
         thread = threading.Thread(
-            target=self._execute_async, args=(handle, name, params), daemon=True
+            target=self._execute_async, args=(handle, name, procedure_params), daemon=True
         )
         handle.thread = thread
         thread.start()
 
         return handle
 
-    def _execute_async(self, handle: ProcedureHandle, name: str, params: Dict[str, Any]):
+    def _execute_async(self, handle: ProcedureHandle, name: str, params: dict[str, Any]):
         """Execute procedure asynchronously in background thread."""
         try:
             # Load procedure source
@@ -320,36 +331,44 @@ class ProcedurePrimitive:
             runtime = self.runtime_factory(name, params)
 
             # Execute in new event loop (thread-safe)
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            event_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(event_loop)
 
-            result = loop.run_until_complete(
+            result = event_loop.run_until_complete(
                 runtime.execute(source=source, context=params, format="lua")
             )
 
-            loop.close()
+            event_loop.close()
 
             # Update handle
             with self._lock:
                 if result.get("success"):
                     handle.status = "completed"
                     handle.result = result.get("result")
-                    logger.info(f"Async procedure '{name}' completed (id: {handle.procedure_id})")
+                    logger.info(
+                        "Async procedure '%s' completed (id: %s)",
+                        name,
+                        handle.procedure_id,
+                    )
                 else:
                     handle.status = "failed"
                     handle.error = result.get("error", "Unknown error")
-                    logger.error(f"Async procedure '{name}' failed: {handle.error}")
+                    logger.error(
+                        "Async procedure '%s' failed: %s",
+                        name,
+                        handle.error,
+                    )
 
                 handle.completed_at = datetime.now()
 
-        except Exception as e:
-            logger.error(f"Error in async procedure '{name}': {e}")
+        except Exception as error:
+            logger.error("Error in async procedure '%s': %s", name, error)
             with self._lock:
                 handle.status = "failed"
-                handle.error = str(e)
+                handle.error = str(error)
                 handle.completed_at = datetime.now()
 
-    def status(self, handle: ProcedureHandle) -> Dict[str, Any]:
+    def status(self, handle: ProcedureHandle) -> dict[str, Any]:
         """
         Get procedure status.
 
@@ -377,7 +396,7 @@ class ProcedurePrimitive:
             ProcedureExecutionError: If procedure failed
             TimeoutError: If timeout exceeded
         """
-        logger.debug(f"Waiting for procedure {handle.procedure_id}")
+        logger.debug("Waiting for procedure %s", handle.procedure_id)
 
         # Wait for thread to complete
         if handle.thread:
@@ -409,7 +428,10 @@ class ProcedurePrimitive:
         Note: This is a placeholder - full implementation requires
         communication channel with running procedure.
         """
-        logger.warning(f"Procedure.inject() not fully implemented - message ignored: {message}")
+        logger.warning(
+            "Procedure.inject() not fully implemented - message ignored: %s",
+            message,
+        )
         # TODO: Implement message injection mechanism
 
     def cancel(self, handle: ProcedureHandle):
@@ -422,7 +444,7 @@ class ProcedurePrimitive:
         Note: Python threads cannot be forcefully cancelled,
         so this just marks the status.
         """
-        logger.info(f"Cancelling procedure {handle.procedure_id}")
+        logger.info("Cancelling procedure %s", handle.procedure_id)
 
         with self._lock:
             handle.status = "cancelled"
@@ -430,7 +452,7 @@ class ProcedurePrimitive:
 
         # Note: Thread will continue running but result will be ignored
 
-    def wait_any(self, handles: List[ProcedureHandle]) -> ProcedureHandle:
+    def wait_any(self, handles: list[ProcedureHandle]) -> ProcedureHandle:
         """
         Wait for first completion.
 
@@ -440,7 +462,7 @@ class ProcedurePrimitive:
         Returns:
             First completed handle
         """
-        logger.debug(f"Waiting for any of {len(handles)} procedures")
+        logger.debug("Waiting for any of %s procedures", len(handles))
 
         while True:
             # Check if any completed
@@ -454,7 +476,7 @@ class ProcedurePrimitive:
 
             time.sleep(0.1)
 
-    def wait_all(self, handles: List[ProcedureHandle]) -> List[Any]:
+    def wait_all(self, handles: list[ProcedureHandle]) -> list[Any]:
         """
         Wait for all completions.
 
@@ -464,7 +486,7 @@ class ProcedurePrimitive:
         Returns:
             List of results
         """
-        logger.debug(f"Waiting for all {len(handles)} procedures")
+        logger.debug("Waiting for all %s procedures", len(handles))
 
         results = []
         for handle in handles:
@@ -486,7 +508,7 @@ class ProcedurePrimitive:
         with self._lock:
             return handle.status in ("completed", "failed", "cancelled")
 
-    def all_complete(self, handles: List[ProcedureHandle]) -> bool:
+    def all_complete(self, handles: list[ProcedureHandle]) -> bool:
         """
         Check if all procedures are complete.
 
@@ -555,7 +577,7 @@ class ProcedurePrimitive:
         for path in search_paths:
             try:
                 if path.exists() and path.is_file():
-                    logger.debug(f"Loading procedure from: {path}")
+                    logger.debug("Loading procedure from: %s", path)
                     return path.read_text()
             except Exception:
                 continue

tactus/primitives/procedure_callable.py

@@ -5,7 +5,7 @@ This module provides the ProcedureCallable class that enables direct function
 call syntax for named procedures with automatic checkpointing and replay support.
 """
 
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 
 class ProcedureCallable:
@@ -31,9 +31,9 @@ class ProcedureCallable:
         self,
         name: str,
         procedure_function: Any,  # Lua function reference
-        input_schema: Dict[str, Any],
-        output_schema: Dict[str, Any],
-        state_schema: Dict[str, Any],
+        input_schema: dict[str, Any],
+        output_schema: dict[str, Any],
+        state_schema: dict[str, Any],
         execution_context,  # ExecutionContext instance
         lua_sandbox,  # LuaSandbox instance
         is_main: bool = False,  # Whether this is the main entry procedure
@@ -60,7 +60,7 @@ class ProcedureCallable:
         self.lua_sandbox = lua_sandbox
         self.is_main = is_main
 
-    def __call__(self, params: Optional[Dict[str, Any]] = None) -> Any:
+    def __call__(self, params: Optional[dict[str, Any]] = None) -> Any:
         """
         Execute the sub-procedure when called from Lua.
 
@@ -75,57 +75,57 @@ class ProcedureCallable:
         Raises:
             ValueError: If input validation fails or output is missing required fields
         """
-        params = params or {}
+        input_params = params or {}
 
         # Convert Lua table to dict if needed
-        if hasattr(params, "items"):
+        if hasattr(input_params, "items"):
             from tactus.core.dsl_stubs import lua_table_to_dict
 
-            params = lua_table_to_dict(params)
+            input_params = lua_table_to_dict(input_params)
 
         # Handle empty list case (lua_table_to_dict converts empty {} to [])
-        if isinstance(params, list) and len(params) == 0:
-            params = {}
+        if isinstance(input_params, list) and len(input_params) == 0:
+            input_params = {}
 
         # Validate input against schema
-        self._validate_input(params)
+        self._validate_input(input_params)
 
         # Wrap execution in checkpoint for automatic replay
         def execute_procedure():
             # Convert Python lists/dicts to Lua tables before setting as input
-            def convert_to_lua(value):
+            def convert_python_value_to_lua(value):
                 """Recursively convert Python lists and dicts to Lua tables."""
                 if isinstance(value, list):
                     # Convert Python list to Lua table (1-indexed)
                     lua_table = self.lua_sandbox.lua.table()
                     for i, item in enumerate(value, 1):
-                        lua_table[i] = convert_to_lua(item)
+                        lua_table[i] = convert_python_value_to_lua(item)
                     return lua_table
                 elif isinstance(value, dict):
                     # Convert Python dict to Lua table
                     lua_table = self.lua_sandbox.lua.table()
                     for k, v in value.items():
-                        lua_table[k] = convert_to_lua(v)
+                        lua_table[k] = convert_python_value_to_lua(v)
                     return lua_table
                 else:
                     return value
 
             # Convert params to Lua-compatible format
-            lua_params = self.lua_sandbox.lua.table()
-            for key, value in params.items():
-                lua_params[key] = convert_to_lua(value)
+            lua_input_table = self.lua_sandbox.lua.table()
+            for key, value in input_params.items():
+                lua_input_table[key] = convert_python_value_to_lua(value)
 
             # Initialize state defaults WITHOUT replacing the state table
             # (preserving the metatable setup)
-            state_defaults = self._initialize_state()
-            if state_defaults:
+            state_default_values = self._initialize_state()
+            if state_default_values:
                 # Access state via globals and assign - this will trigger the metatable
                 state_table = self.lua_sandbox.lua.globals()["state"]
-                for key, value in state_defaults.items():
-                    state_table[key] = convert_to_lua(value)
+                for key, value in state_default_values.items():
+                    state_table[key] = convert_python_value_to_lua(value)
 
             # Execute the procedure function with input as explicit parameter
-            result = self.procedure_function(lua_params)
+            result = self.procedure_function(lua_input_table)
 
             # Convert Lua table result to Python dict
             # Check for lupa table (not Python dict/list)
@@ -157,29 +157,33 @@ class ProcedureCallable:
                 if hasattr(lua_globals, "debug") and hasattr(lua_globals.debug, "getinfo"):
                     # Try different stack levels to find the Lua caller
                     debug_info = None
-                    with open("/tmp/tactus-debug.log", "a") as f:
-                        f.write(f"DEBUG: Trying debug.getinfo for {self.name}\n")
-                    for level in [1, 2, 3, 4, 5, 6, 7, 8]:
+                    self._write_debug_line(f"DEBUG: Trying debug.getinfo for {self.name}")
+                    for stack_level in [1, 2, 3, 4, 5, 6, 7, 8]:
                         try:
-                            info = lua_globals.debug.getinfo(level, "Sl")
+                            info = lua_globals.debug.getinfo(stack_level, "Sl")
                             if info:
-                                lua_dict = dict(info.items()) if hasattr(info, "items") else {}
-                                source = lua_dict.get("source", "")
-                                line = lua_dict.get("currentline", -1)
-                                with open("/tmp/tactus-debug.log", "a") as f:
-                                    f.write(f"DEBUG: Level {level}: source={source}, line={line}\n")
+                                lua_debug_info = (
+                                    dict(info.items()) if hasattr(info, "items") else {}
+                                )
+                                source = lua_debug_info.get("source", "")
+                                line = lua_debug_info.get("currentline", -1)
+                                self._write_debug_line(
+                                    f"DEBUG: Level {stack_level}: source={source}, line={line}"
+                                )
                                 # Look for a valid source location (not -1, not C function)
                                 # Accept [string "<python>"] sources since that's our Lua code
                                 if line > 0 and source:
                                     if source.startswith("=[C]"):
                                         continue  # Skip C functions
-                                    debug_info = lua_dict
-                                    with open("/tmp/tactus-debug.log", "a") as f:
-                                        f.write(f"DEBUG: Found valid source at level {level}\n")
+                                    debug_info = lua_debug_info
+                                    self._write_debug_line(
+                                        f"DEBUG: Found valid source at level {stack_level}"
+                                    )
                                     break
-                        except Exception as inner_e:
-                            with open("/tmp/tactus-debug.log", "a") as f:
-                                f.write(f"DEBUG: Level {level} error: {inner_e}\n")
+                        except Exception as debug_error:
+                            self._write_debug_line(
+                                f"DEBUG: Level {stack_level} error: {debug_error}"
+                            )
                             continue
 
                     if debug_info:
@@ -189,26 +193,24 @@ class ProcedureCallable:
                             "line": debug_info.get("currentline", 0),
                             "function": debug_info.get("name", self.name),
                         }
-                        with open("/tmp/tactus-debug.log", "a") as f:
-                            f.write(f"DEBUG: Final source_info: {source_info}\n")
-            except Exception as e:
-                with open("/tmp/tactus-debug.log", "a") as f:
-                    f.write(f"DEBUG: Exception getting Lua debug info: {e}\n")
+                        self._write_debug_line(f"DEBUG: Final source_info: {source_info}")
+            except Exception as error:
+                self._write_debug_line(f"DEBUG: Exception getting Lua debug info: {error}")
 
             # If we still don't have source_info, use fallback
             if not source_info:
                 import inspect
 
-                frame = inspect.currentframe()
-                if frame and frame.f_back:
-                    caller_frame = frame.f_back
+                current_frame = inspect.currentframe()
+                if current_frame and current_frame.f_back:
+                    caller_frame = current_frame.f_back
                     # Use .tac file if available, otherwise use Python file
                     tac_file = self.execution_context.current_tac_file
                     python_file = caller_frame.f_code.co_filename
-                    with open("/tmp/tactus-debug.log", "a") as f:
-                        f.write(
-                            f"DEBUG: Fallback - current_tac_file={tac_file}, python_file={python_file}\n"
-                        )
+                    self._write_debug_line(
+                        "DEBUG: Fallback - current_tac_file=%s, python_file=%s"
+                        % (tac_file, python_file)
+                    )
                     source_info = {
                         "file": tac_file or python_file,
                         "line": 0,  # Line number unknown without Lua debug
@@ -219,7 +221,7 @@ class ProcedureCallable:
                 execute_procedure, checkpoint_type="procedure_call", source_info=source_info
             )
 
-    def _validate_input(self, params: Dict[str, Any]) -> None:
+    def _validate_input(self, params: dict[str, Any]) -> None:
         """
         Validate input parameters against input schema.
 
@@ -304,7 +306,7 @@ class ProcedureCallable:
                         f"Procedure '{self.name}' missing required output: {field_name}"
                     )
 
-    def _initialize_state(self) -> Dict[str, Any]:
+    def _initialize_state(self) -> dict[str, Any]:
         """
         Initialize state with default values from state schema.
 
@@ -316,3 +318,8 @@ class ProcedureCallable:
             if isinstance(field_def, dict) and "default" in field_def:
                 state[field_name] = field_def["default"]
         return state
+
+    def _write_debug_line(self, message: str) -> None:
+        """Write a debug line to the temporary debug log."""
+        with open("/tmp/tactus-debug.log", "a") as debug_file:
+            debug_file.write(f"{message}\n")