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

tactus/adapters/channels/ipc.py

@@ -10,7 +10,7 @@ import logging
 import os
 import uuid
 from datetime import datetime
-from typing import Dict, Optional
+from typing import Optional
 
 from tactus.broker.protocol import read_message, write_message
 from tactus.protocols.control import (
@@ -45,9 +45,9 @@ class IPCControlChannel:
         self.channel_id = "ipc"
 
         self._server: Optional[asyncio.Server] = None
-        self._clients: Dict[str, asyncio.StreamWriter] = {}  # client_id -> writer
+        self._clients: dict[str, asyncio.StreamWriter] = {}  # client_id -> writer
         self._response_queue: asyncio.Queue[ControlResponse] = asyncio.Queue()
-        self._pending_requests: Dict[str, ControlRequest] = {}  # request_id -> request
+        self._pending_requests: dict[str, ControlRequest] = {}  # request_id -> request
         self._initialized = False
 
     @property
@@ -67,7 +67,7 @@ class IPCControlChannel:
         if self._initialized:
             return
 
-        logger.info(f"{self.channel_id}: initializing...")
+        logger.info("%s: initializing...", self.channel_id)
 
         # Remove old socket file if it exists
         if os.path.exists(self.socket_path):
@@ -84,7 +84,11 @@ class IPCControlChannel:
         os.chmod(self.socket_path, 0o600)
 
         self._initialized = True
-        logger.info(f"{self.channel_id}: ready (listening on {self.socket_path})")
+        logger.info(
+            "%s: ready (listening on %s)",
+            self.channel_id,
+            self.socket_path,
+        )
 
     async def send(self, request: ControlRequest) -> DeliveryResult:
         """
@@ -96,10 +100,14 @@ class IPCControlChannel:
         Returns:
             DeliveryResult with success/failure info
         """
-        logger.info(f"{self.channel_id}: sending notification for {request.request_id}")
+        logger.info(
+            "%s: sending notification for %s",
+            self.channel_id,
+            request.request_id,
+        )
 
         # Create control request message from ControlRequest object
-        request_data = {
+        request_payload = {
             "type": "control.request",
             "request_id": request.request_id,
             "procedure_id": request.procedure_id,
@@ -120,7 +128,7 @@ class IPCControlChannel:
         }
 
         # Store pending request
-        self._pending_requests[request.request_id] = request_data
+        self._pending_requests[request.request_id] = request_payload
 
         # Send to all connected clients
         successful = 0
@@ -128,16 +136,21 @@ class IPCControlChannel:
 
         for client_id, writer in list(self._clients.items()):
             try:
-                await write_message(writer, request_data)
+                await write_message(writer, request_payload)
                 successful += 1
-            except Exception as e:
-                logger.error(f"{self.channel_id}: failed to send to client {client_id}: {e}")
+            except Exception as error:
+                logger.error(
+                    "%s: failed to send to client %s: %s",
+                    self.channel_id,
+                    client_id,
+                    error,
+                )
                 failed += 1
                 # Remove dead client
                 self._clients.pop(client_id, None)
 
         if successful == 0 and len(self._clients) == 0:
-            logger.warning(f"{self.channel_id}: no clients connected")
+            logger.warning("%s: no clients connected", self.channel_id)
 
         # Return DeliveryResult
         return DeliveryResult(
@@ -157,7 +170,11 @@ class IPCControlChannel:
         """
         while True:
             response = await self._response_queue.get()
-            logger.info(f"{self.channel_id}: received response for {response.request_id}")
+            logger.info(
+                "%s: received response for %s",
+                self.channel_id,
+                response.request_id,
+            )
             yield response
 
     async def cancel(self, request_id: str, reason: str) -> None:
@@ -168,7 +185,12 @@ class IPCControlChannel:
             request_id: Request to cancel
             reason: Cancellation reason
         """
-        logger.debug(f"{self.channel_id}: cancelling {request_id} ({reason})")
+        logger.debug(
+            "%s: cancelling %s (%s)",
+            self.channel_id,
+            request_id,
+            reason,
+        )
 
         # Remove from pending
         self._pending_requests.pop(request_id, None)
@@ -179,20 +201,30 @@ class IPCControlChannel:
         for client_id, writer in list(self._clients.items()):
             try:
                 await write_message(writer, cancel_message)
-            except Exception as e:
-                logger.error(f"{self.channel_id}: failed to send cancellation to {client_id}: {e}")
+            except Exception as error:
+                logger.error(
+                    "%s: failed to send cancellation to %s: %s",
+                    self.channel_id,
+                    client_id,
+                    error,
+                )
 
     async def shutdown(self) -> None:
         """Clean up and close server."""
-        logger.info(f"{self.channel_id}: shutting down")
+        logger.info("%s: shutting down", self.channel_id)
 
         # Close all client connections
         for client_id, writer in list(self._clients.items()):
             try:
                 writer.close()
                 await writer.wait_closed()
-            except Exception as e:
-                logger.error(f"{self.channel_id}: error closing client {client_id}: {e}")
+            except Exception as error:
+                logger.error(
+                    "%s: error closing client %s: %s",
+                    self.channel_id,
+                    client_id,
+                    error,
+                )
 
         self._clients.clear()
 
@@ -205,8 +237,12 @@ class IPCControlChannel:
         if os.path.exists(self.socket_path):
             try:
                 os.unlink(self.socket_path)
-            except Exception as e:
-                logger.error(f"{self.channel_id}: failed to remove socket file: {e}")
+            except Exception as error:
+                logger.error(
+                    "%s: failed to remove socket file: %s",
+                    self.channel_id,
+                    error,
+                )
 
         self._initialized = False
 
@@ -222,7 +258,7 @@ class IPCControlChannel:
         """
         client_id = str(uuid.uuid4())[:8]
 
-        logger.info(f"{self.channel_id}: client connected ({client_id})")
+        logger.info("%s: client connected (%s)", self.channel_id, client_id)
 
         # Register client
         self._clients[client_id] = writer
@@ -232,19 +268,22 @@ class IPCControlChannel:
             for request_id, request_data in self._pending_requests.items():
                 try:
                     await write_message(writer, request_data)
-                except Exception as e:
+                except Exception as error:
                     logger.error(
-                        f"{self.channel_id}: failed to send pending request to {client_id}: {e}"
+                        "%s: failed to send pending request to %s: %s",
+                        self.channel_id,
+                        client_id,
+                        error,
                     )
 
             # Read messages from client
             while True:
                 try:
                     message = await read_message(reader)
-                except EOFError:
-                    break
                 except asyncio.IncompleteReadError:
                     break
+                except EOFError:
+                    break
 
                 # Handle message
                 msg_type = message.get("type")
@@ -264,7 +303,11 @@ class IPCControlChannel:
                         channel_id=self.channel_id,
                     )
                     await self._response_queue.put(response)
-                    logger.info(f"{self.channel_id}: received response for {response.request_id}")
+                    logger.info(
+                        "%s: received response for %s",
+                        self.channel_id,
+                        response.request_id,
+                    )
 
                     # Remove from pending
                     self._pending_requests.pop(response.request_id, None)
@@ -279,16 +322,24 @@ class IPCControlChannel:
 
                 else:
                     logger.warning(
-                        f"{self.channel_id}: unknown message type from {client_id}: {msg_type}"
+                        "%s: unknown message type from %s: %s",
+                        self.channel_id,
+                        client_id,
+                        msg_type,
                     )
 
-        except Exception as e:
-            logger.error(f"{self.channel_id}: error handling client {client_id}: {e}")
+        except Exception as error:
+            logger.error(
+                "%s: error handling client %s: %s",
+                self.channel_id,
+                client_id,
+                error,
+            )
 
         finally:
             # Clean up
             self._clients.pop(client_id, None)
-            logger.info(f"{self.channel_id}: client disconnected ({client_id})")
+            logger.info("%s: client disconnected (%s)", self.channel_id, client_id)
 
             try:
                 writer.close()

tactus/adapters/channels/sse.py

@@ -8,7 +8,7 @@ and receives responses via HTTP POST callbacks.
 import asyncio
 import logging
 import queue
-from typing import Optional, Any
+from typing import Any, Optional
 from datetime import datetime, timezone
 
 from tactus.adapters.channels.base import InProcessChannel
@@ -46,7 +46,7 @@ class SSEControlChannel(InProcessChannel):
         super().__init__()
         self._event_emitter = event_emitter
         # Use thread-safe queue.Queue for sync access from Flask SSE stream
-        self._event_queue: queue.Queue[dict] = queue.Queue()
+        self._event_queue: queue.Queue[dict[str, Any]] = queue.Queue()
 
     @property
     def channel_id(self) -> str:
@@ -68,9 +68,9 @@ class SSEControlChannel(InProcessChannel):
 
     async def initialize(self) -> None:
         """Initialize SSE channel (no-op, Flask SSE already running)."""
-        logger.info(f"{self.channel_id}: initializing...")
+        logger.info("%s: initializing...", self.channel_id)
         # No auth or connection needed - Flask SSE already set up
-        logger.info(f"{self.channel_id}: ready")
+        logger.info("%s: ready", self.channel_id)
 
     async def send(self, request: ControlRequest) -> DeliveryResult:
         """
@@ -78,18 +78,22 @@ class SSEControlChannel(InProcessChannel):
 
         Creates a hitl.request event with rich context and pushes to SSE stream.
         """
-        logger.info(f"{self.channel_id}: sending notification for {request.request_id}")
+        logger.info(
+            "%s: sending notification for %s",
+            self.channel_id,
+            request.request_id,
+        )
 
         try:
             # Build SSE event payload
-            event = self._build_hitl_event(request)
+            event_payload = self._build_hitl_event(request)
 
             # Emit event to SSE stream
             if self._event_emitter:
-                await self._event_emitter(event)
+                await self._event_emitter(event_payload)
             else:
                 # Queue for external consumption if no emitter (thread-safe)
-                self._event_queue.put(event)
+                self._event_queue.put(event_payload)
 
             return DeliveryResult(
                 channel_id=self.channel_id,
@@ -98,14 +102,18 @@ class SSEControlChannel(InProcessChannel):
                 success=True,
             )
 
-        except Exception as e:
-            logger.error(f"{self.channel_id}: failed to send notification: {e}")
+        except Exception as error:
+            logger.error(
+                "%s: failed to send notification: %s",
+                self.channel_id,
+                error,
+            )
             return DeliveryResult(
                 channel_id=self.channel_id,
                 external_message_id=request.request_id,
                 delivered_at=datetime.now(timezone.utc),
                 success=False,
-                error_message=str(e),
+                error_message=str(error),
             )
 
     def _build_hitl_event(self, request: ControlRequest) -> dict:
@@ -114,7 +122,7 @@ class SSEControlChannel(InProcessChannel):
 
         Returns dict that will be serialized to JSON and sent as SSE event.
         """
-        event = {
+        event_payload = {
             "event_type": "hitl.request",  # Frontend expects event_type, not type
             "request_id": request.request_id,
             # Identity
@@ -195,7 +203,7 @@ class SSEControlChannel(InProcessChannel):
             "metadata": request.metadata,
         }
 
-        return event
+        return event_payload
 
     def _serialize_runtime_context(self, runtime_context) -> Optional[dict]:
         """Serialize RuntimeContext to dict for SSE payload."""
@@ -238,7 +246,7 @@ class SSEControlChannel(InProcessChannel):
             request_id: The request being responded to
             value: The response value from the IDE
         """
-        logger.info(f"{self.channel_id}: received response for {request_id}")
+        logger.info("%s: received response for %s", self.channel_id, request_id)
 
         response = ControlResponse(
             request_id=request_id,
@@ -251,15 +259,20 @@ class SSEControlChannel(InProcessChannel):
         # Push to queue from sync context (Flask thread)
         # Get the running event loop and schedule the put operation
         try:
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
+            event_loop = asyncio.get_event_loop()
+            if event_loop.is_running():
                 # Schedule the coroutine in the running loop
-                asyncio.run_coroutine_threadsafe(self._response_queue.put(response), loop)
+                asyncio.run_coroutine_threadsafe(self._response_queue.put(response), event_loop)
             else:
                 # If no loop is running, use put_nowait (shouldn't happen)
                 self._response_queue.put_nowait(response)
-        except Exception as e:
-            logger.error(f"{self.channel_id}: failed to queue response for {request_id}: {e}")
+        except Exception as error:
+            logger.error(
+                "%s: failed to queue response for %s: %s",
+                self.channel_id,
+                request_id,
+                error,
+            )
 
     def get_next_event(self, timeout: float = 0.001) -> Optional[dict]:
         """
@@ -275,8 +288,8 @@ class SSEControlChannel(InProcessChannel):
             Event dict or None if queue is empty
         """
         try:
-            event = self._event_queue.get(timeout=timeout)
-            return event
+            event_payload = self._event_queue.get(timeout=timeout)
+            return event_payload
         except queue.Empty:
             return None
 
@@ -286,7 +299,12 @@ class SSEControlChannel(InProcessChannel):
 
         Sends a hitl.cancel event to dismiss the prompt.
         """
-        logger.debug(f"{self.channel_id}: cancelling {external_message_id}: {reason}")
+        logger.debug(
+            "%s: cancelling %s: %s",
+            self.channel_id,
+            external_message_id,
+            reason,
+        )
 
         cancel_event = {
             "event_type": "hitl.cancel",  # Frontend expects event_type, not type
@@ -301,5 +319,5 @@ class SSEControlChannel(InProcessChannel):
 
     async def shutdown(self) -> None:
         """Shutdown SSE channel."""
-        logger.info(f"{self.channel_id}: shutting down")
+        logger.info("%s: shutting down", self.channel_id)
         self._shutdown_event.set()

tactus/adapters/cli_hitl.py

@@ -55,7 +55,7 @@ class CLIHITLHandler:
         Returns:
             HITLResponse with user's response
         """
-        logger.debug(f"HITL request: {request.request_type} - {request.message}")
+        logger.debug("HITL request: %s - %s", request.request_type, request.message)
 
         # Display the request in a panel
         self.console.print()
@@ -101,10 +101,10 @@ class CLIHITLHandler:
         if request.options:
             # Display options
             self.console.print("\n[bold]Options:[/bold]")
-            for i, option in enumerate(request.options, 1):
-                label = option.get("label", f"Option {i}")
+            for index, option in enumerate(request.options, 1):
+                label = option.get("label", f"Option {index}")
                 description = option.get("description", "")
-                self.console.print(f"  {i}. [cyan]{label}[/cyan]")
+                self.console.print(f"  {index}. [cyan]{label}[/cyan]")
                 if description:
                     self.console.print(f"     [dim]{description}[/dim]")
 
@@ -195,19 +195,19 @@ class CLIHITLHandler:
 
         # Display summary
         self.console.print(f"\n[bold cyan]Collecting {len(items)} inputs:[/bold cyan]")
-        for idx, item in enumerate(items, 1):
-            label = item.get("label", f"Item {idx}")
+        for index, item in enumerate(items, 1):
+            label = item.get("label", f"Item {index}")
             required = item.get("required", True)
             req_marker = "*" if required else ""
-            self.console.print(f"  {idx}. [cyan]{label}[/cyan]{req_marker}")
+            self.console.print(f"  {index}. [cyan]{label}[/cyan]{req_marker}")
         self.console.print()
 
         # Collect responses for each item
         responses = {}
 
-        for idx, item in enumerate(items, 1):
+        for index, item in enumerate(items, 1):
             item_id = item.get("item_id")
-            label = item.get("label", f"Item {idx}")
+            label = item.get("label", f"Item {index}")
             request_type = item.get("request_type", "input")
             message = item.get("message", "")
             required = item.get("required", True)
@@ -219,7 +219,7 @@ class CLIHITLHandler:
             self.console.print(
                 Panel(
                     message,
-                    title=f"[bold]{idx}/{len(items)}: {label}[/bold]",
+                    title=f"[bold]{index}/{len(items)}: {label}[/bold]",
                     style="cyan" if required else "blue",
                 )
             )
@@ -237,13 +237,13 @@ class CLIHITLHandler:
                     self.console.print(
                         "\n[bold]Select multiple options (comma-separated numbers):[/bold]"
                     )
-                    for i, option in enumerate(options, 1):
+                    for index, option in enumerate(options, 1):
                         label_text = (
-                            option.get("label", f"Option {i}")
+                            option.get("label", f"Option {index}")
                             if isinstance(option, dict)
                             else option
                         )
-                        self.console.print(f"  {i}. [cyan]{label_text}[/cyan]")
+                        self.console.print(f"  {index}. [cyan]{label_text}[/cyan]")
 
                     min_selections = metadata.get("min", 0)
                     max_selections = metadata.get("max", len(options))
@@ -288,15 +288,15 @@ class CLIHITLHandler:
                 else:
                     # Single selection
                     self.console.print("\n[bold]Options:[/bold]")
-                    for i, option in enumerate(options, 1):
+                    for index, option in enumerate(options, 1):
                         if isinstance(option, dict):
-                            label_text = option.get("label", f"Option {i}")
+                            label_text = option.get("label", f"Option {index}")
                             description = option.get("description", "")
-                            self.console.print(f"  {i}. [cyan]{label_text}[/cyan]")
+                            self.console.print(f"  {index}. [cyan]{label_text}[/cyan]")
                             if description:
                                 self.console.print(f"     [dim]{description}[/dim]")
                         else:
-                            self.console.print(f"  {i}. [cyan]{option}[/cyan]")
+                            self.console.print(f"  {index}. [cyan]{option}[/cyan]")
 
                     while True:
                         choice_str = Prompt.ask("Select option (number)", console=self.console)
@@ -394,7 +394,7 @@ class CLIHITLHandler:
             value=responses, responded_at=datetime.now(timezone.utc), timed_out=False
         )
 
-    def check_pending_response(self, procedure_id: str, message_id: str) -> Optional[HITLResponse]:
+    def check_pending_response(self, procedure_id: str, request_id: str) -> Optional[HITLResponse]:
         """
         Check for pending response (not used in CLI mode).
 
@@ -402,7 +402,7 @@ class CLIHITLHandler:
         """
         return None
 
-    def cancel_pending_request(self, procedure_id: str, message_id: str) -> None:
+    def cancel_pending_request(self, procedure_id: str, request_id: str) -> None:
         """
         Cancel pending request (not used in CLI mode).
 

tactus/adapters/cli_log.py

@@ -126,12 +126,12 @@ class CLILogHandler:
         # Format result if available
         result_str = ""
         if event.tool_result is not None:
-            result_value = str(event.tool_result)
-            if len(result_value) < 60:
-                result_str = f"\n  Result: {result_value}"
+            result_text = str(event.tool_result)
+            if len(result_text) < 60:
+                result_str = f"\n  Result: {result_text}"
             else:
                 # Truncate long results
-                result_str = f"\n  Result: {result_value[:57]}..."
+                result_str = f"\n  Result: {result_text[:57]}..."
 
         duration_str = f" ({event.duration_ms:.0f}ms)" if event.duration_ms else ""