Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

new linter rules and fixes

Alishahryar1b05d0d2703f7
diff --git a/api/__init__.py b/api/__init__.py
index 13fdc3d6..0a8e06d6 100644
--- a/api/__init__.py
+++ b/api/__init__.py
@@ -1,20 +1,20 @@
"""API layer for Claude Code Proxy."""
-from .app import create_app, app
+from .app import app, create_app
+from .dependencies import get_provider
from .models import (
MessagesRequest,
MessagesResponse,
TokenCountRequest,
TokenCountResponse,
)
-from .dependencies import get_provider
__all__ = [
- "create_app",
- "app",
"MessagesRequest",
"MessagesResponse",
"TokenCountRequest",
"TokenCountResponse",
+ "app",
+ "create_app",
"get_provider",
]
diff --git a/api/app.py b/api/app.py
index 3ee8e02b..5b220c79 100644
--- a/api/app.py
+++ b/api/app.py
@@ -8,12 +8,13 @@ from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from loguru import logger
-from config.settings import get_settings
from config.logging_config import configure_logging
-from .routes import router
-from .dependencies import cleanup_provider
+from config.settings import get_settings
from providers.exceptions import ProviderError
+from .dependencies import cleanup_provider
+from .routes import router
+
# Opt-in to future behavior for python-telegram-bot
os.environ["PTB_TIMEDELTA"] = "1"
@@ -31,7 +32,7 @@ async def _best_effort(
"""Run a shutdown step with timeout; never raise to callers."""
try:
await asyncio.wait_for(awaitable, timeout=timeout_s)
- except asyncio.TimeoutError:
+ except TimeoutError:
logger.warning(f"Shutdown step timed out: {name} ({timeout_s}s)")
except Exception as e:
logger.warning(f"Shutdown step failed: {name}: {type(e).__name__}: {e}")
@@ -61,9 +62,9 @@ async def lifespan(app: FastAPI):
)
if messaging_platform:
+ from cli.manager import CLISessionManager
from messaging.handler import ClaudeMessageHandler
from messaging.session import SessionStore
- from cli.manager import CLISessionManager
# Setup workspace - CLI runs in allowed_dir if set (e.g. project root)
workspace = (
@@ -202,7 +203,7 @@ def create_app() -> FastAPI:
@app.exception_handler(Exception)
async def general_error_handler(request: Request, exc: Exception):
"""Handle general errors and return Anthropic format."""
- logger.error(f"General Error: {str(exc)}")
+ logger.error(f"General Error: {exc!s}")
import traceback
logger.error(traceback.format_exc())
diff --git a/api/dependencies.py b/api/dependencies.py
index 1a1fb594..be52a0c3 100644
--- a/api/dependencies.py
+++ b/api/dependencies.py
@@ -1,16 +1,14 @@
"""Dependency injection for FastAPI."""
-from typing import Optional
-
from fastapi import HTTPException
from loguru import logger
-from config.settings import Settings, get_settings as _get_settings, NVIDIA_NIM_BASE_URL
+from config.settings import NVIDIA_NIM_BASE_URL, Settings
+from config.settings import get_settings as _get_settings
from providers.base import BaseProvider, ProviderConfig
-
# Global provider instance (singleton)
-_provider: Optional[BaseProvider] = None
+_provider: BaseProvider | None = None
def get_settings() -> Settings:
diff --git a/api/detection.py b/api/detection.py
index 8b2c0f60..8c929374 100644
--- a/api/detection.py
+++ b/api/detection.py
@@ -4,8 +4,6 @@ Detects quota checks, title generation, prefix detection, suggestion mode,
and filepath extraction requests to enable fast-path responses.
"""
-from typing import Tuple
-
from utils.text import extract_text_from_content
from .models.anthropic import MessagesRequest
@@ -41,7 +39,7 @@ def is_title_generation_request(request_data: MessagesRequest) -> bool:
return False
-def is_prefix_detection_request(request_data: MessagesRequest) -> Tuple[bool, str]:
+def is_prefix_detection_request(request_data: MessagesRequest) -> tuple[bool, str]:
"""Check if this is a fast prefix detection request.
Prefix detection requests contain a policy_spec block and
@@ -81,7 +79,7 @@ def is_suggestion_mode_request(request_data: MessagesRequest) -> bool:
def is_filepath_extraction_request(
request_data: MessagesRequest,
-) -> Tuple[bool, str, str]:
+) -> tuple[bool, str, str]:
"""Check if this is a filepath extraction request.
Filepath extraction requests have a single user message with
diff --git a/api/models/__init__.py b/api/models/__init__.py
index f2ed53a4..08428a97 100644
--- a/api/models/__init__.py
+++ b/api/models/__init__.py
@@ -1,35 +1,35 @@
"""API models exports."""
from .anthropic import (
- Role,
- ContentBlockText,
ContentBlockImage,
- ContentBlockToolUse,
- ContentBlockToolResult,
+ ContentBlockText,
ContentBlockThinking,
- SystemContent,
+ ContentBlockToolResult,
+ ContentBlockToolUse,
Message,
- Tool,
- ThinkingConfig,
MessagesRequest,
+ Role,
+ SystemContent,
+ ThinkingConfig,
TokenCountRequest,
+ Tool,
)
-from .responses import TokenCountResponse, Usage, MessagesResponse
+from .responses import MessagesResponse, TokenCountResponse, Usage
__all__ = [
- "Role",
- "ContentBlockText",
"ContentBlockImage",
- "ContentBlockToolUse",
- "ContentBlockToolResult",
+ "ContentBlockText",
"ContentBlockThinking",
- "SystemContent",
+ "ContentBlockToolResult",
+ "ContentBlockToolUse",
"Message",
- "Tool",
- "ThinkingConfig",
"MessagesRequest",
+ "MessagesResponse",
+ "Role",
+ "SystemContent",
+ "ThinkingConfig",
"TokenCountRequest",
"TokenCountResponse",
+ "Tool",
"Usage",
- "MessagesResponse",
]
diff --git a/api/models/anthropic.py b/api/models/anthropic.py
index dbc0bb9a..6c5ebaa6 100644
--- a/api/models/anthropic.py
+++ b/api/models/anthropic.py
@@ -1,21 +1,20 @@
"""Pydantic models for Anthropic-compatible requests."""
-from enum import Enum
-from typing import List, Dict, Any, Optional, Union, Literal
+from enum import StrEnum
+from typing import Any, Literal
+from loguru import logger
from pydantic import BaseModel, field_validator, model_validator
from config.settings import get_settings
from providers.model_utils import normalize_model_name
-from loguru import logger
-
# =============================================================================
# Content Block Types
# =============================================================================
-class Role(str, Enum):
+class Role(StrEnum):
user = "user"
assistant = "assistant"
system = "system"
@@ -28,20 +27,20 @@ class ContentBlockText(BaseModel):
class ContentBlockImage(BaseModel):
type: Literal["image"]
- source: Dict[str, Any]
+ source: dict[str, Any]
class ContentBlockToolUse(BaseModel):
type: Literal["tool_use"]
id: str
name: str
- input: Dict[str, Any]
+ input: dict[str, Any]
class ContentBlockToolResult(BaseModel):
type: Literal["tool_result"]
tool_use_id: str
- content: Union[str, List[Dict[str, Any]], Dict[str, Any], List[Any], Any]
+ content: str | list[dict[str, Any]] | dict[str, Any] | list[Any] | Any
class ContentBlockThinking(BaseModel):
@@ -61,25 +60,23 @@ class SystemContent(BaseModel):
class Message(BaseModel):
role: Literal["user", "assistant"]
- content: Union[
- str,
- List[
- Union[
- ContentBlockText,
- ContentBlockImage,
- ContentBlockToolUse,
- ContentBlockToolResult,
- ContentBlockThinking,
- ]
- ],
- ]
- reasoning_content: Optional[str] = None
+ content: (
+ str
+ | list[
+ ContentBlockText
+ | ContentBlockImage
+ | ContentBlockToolUse
+ | ContentBlockToolResult
+ | ContentBlockThinking
+ ]
+ )
+ reasoning_content: str | None = None
class Tool(BaseModel):
name: str
- description: Optional[str] = None
- input_schema: Dict[str, Any]
+ description: str | None = None
+ input_schema: dict[str, Any]
class ThinkingConfig(BaseModel):
@@ -93,23 +90,23 @@ class ThinkingConfig(BaseModel):
class MessagesRequest(BaseModel):
model: str
- max_tokens: Optional[int] = None
- messages: List[Message]
- system: Optional[Union[str, List[SystemContent]]] = None
- stop_sequences: Optional[List[str]] = None
- stream: Optional[bool] = True
- temperature: Optional[float] = None
- top_p: Optional[float] = None
- top_k: Optional[int] = None
- metadata: Optional[Dict[str, Any]] = None
- tools: Optional[List[Tool]] = None
- tool_choice: Optional[Dict[str, Any]] = None
- thinking: Optional[ThinkingConfig] = None
- extra_body: Optional[Dict[str, Any]] = None
- original_model: Optional[str] = None
+ max_tokens: int | None = None
+ messages: list[Message]
+ system: str | list[SystemContent] | None = None
+ stop_sequences: list[str] | None = None
+ stream: bool | None = True
+ temperature: float | None = None
+ top_p: float | None = None
+ top_k: int | None = None
+ metadata: dict[str, Any] | None = None
+ tools: list[Tool] | None = None
+ tool_choice: dict[str, Any] | None = None
+ thinking: ThinkingConfig | None = None
+ extra_body: dict[str, Any] | None = None
+ original_model: str | None = None
@model_validator(mode="after")
- def map_model(self) -> "MessagesRequest":
+ def map_model(self) -> MessagesRequest:
"""Map any Claude model name to the configured model."""
settings = get_settings()
if self.original_model is None:
@@ -128,11 +125,11 @@ class MessagesRequest(BaseModel):
class TokenCountRequest(BaseModel):
model: str
- messages: List[Message]
- system: Optional[Union[str, List[SystemContent]]] = None
- tools: Optional[List[Tool]] = None
- thinking: Optional[ThinkingConfig] = None
- tool_choice: Optional[Dict[str, Any]] = None
+ messages: list[Message]
+ system: str | list[SystemContent] | None = None
+ tools: list[Tool] | None = None
+ thinking: ThinkingConfig | None = None
+ tool_choice: dict[str, Any] | None = None
@field_validator("model")
@classmethod
diff --git a/api/models/responses.py b/api/models/responses.py
index 67e3efa2..40a7d7b7 100644
--- a/api/models/responses.py
+++ b/api/models/responses.py
@@ -1,10 +1,10 @@
"""Pydantic models for API responses."""
-from typing import List, Dict, Any, Optional, Union, Literal
+from typing import Any, Literal
from pydantic import BaseModel
-from .anthropic import ContentBlockText, ContentBlockToolUse, ContentBlockThinking
+from .anthropic import ContentBlockText, ContentBlockThinking, ContentBlockToolUse
class TokenCountResponse(BaseModel):
@@ -22,14 +22,12 @@ class MessagesResponse(BaseModel):
id: str
model: str
role: Literal["assistant"] = "assistant"
- content: List[
- Union[
- ContentBlockText, ContentBlockToolUse, ContentBlockThinking, Dict[str, Any]
- ]
+ content: list[
+ ContentBlockText | ContentBlockToolUse | ContentBlockThinking | dict[str, Any]
]
type: Literal["message"] = "message"
- stop_reason: Optional[
- Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"]
- ] = None
- stop_sequence: Optional[str] = None
+ stop_reason: (
+ Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None
+ ) = None
+ stop_sequence: str | None = None
usage: Usage
diff --git a/api/optimization_handlers.py b/api/optimization_handlers.py
index 0bc1b9ea..164c5352 100644
--- a/api/optimization_handlers.py
+++ b/api/optimization_handlers.py
@@ -5,25 +5,26 @@ optimization is enabled, otherwise None.
"""
import uuid
-from typing import Optional
-from .models.anthropic import MessagesRequest
-from .models.responses import MessagesResponse, Usage
+from loguru import logger
+
+from config.settings import Settings
+
+from .command_utils import extract_command_prefix, extract_filepaths_from_command
from .detection import (
- is_quota_check_request,
- is_title_generation_request,
+ is_filepath_extraction_request,
is_prefix_detection_request,
+ is_quota_check_request,
is_suggestion_mode_request,
- is_filepath_extraction_request,
+ is_title_generation_request,
)
-from .command_utils import extract_command_prefix, extract_filepaths_from_command
-from config.settings import Settings
-from loguru import logger
+from .models.anthropic import MessagesRequest
+from .models.responses import MessagesResponse, Usage
def try_prefix_detection(
request_data: MessagesRequest, settings: Settings
-) -> Optional[MessagesResponse]:
+) -> MessagesResponse | None:
"""Fast prefix detection - return command prefix without API call."""
if not settings.fast_prefix_detection:
return None
@@ -43,7 +44,7 @@ def try_prefix_detection(
def try_quota_mock(
request_data: MessagesRequest, settings: Settings
-) -> Optional[MessagesResponse]:
+) -> MessagesResponse | None:
"""Mock quota probe requests."""
if not settings.enable_network_probe_mock:
return None
@@ -63,7 +64,7 @@ def try_quota_mock(
def try_title_skip(
request_data: MessagesRequest, settings: Settings
-) -> Optional[MessagesResponse]:
+) -> MessagesResponse | None:
"""Skip title generation requests."""
if not settings.enable_title_generation_skip:
return None
@@ -83,7 +84,7 @@ def try_title_skip(
def try_suggestion_skip(
request_data: MessagesRequest, settings: Settings
-) -> Optional[MessagesResponse]:
+) -> MessagesResponse | None:
"""Skip suggestion mode requests."""
if not settings.enable_suggestion_mode_skip:
return None
@@ -103,7 +104,7 @@ def try_suggestion_skip(
def try_filepath_mock(
request_data: MessagesRequest, settings: Settings
-) -> Optional[MessagesResponse]:
+) -> MessagesResponse | None:
"""Mock filepath extraction requests."""
if not settings.enable_filepath_extraction_mock:
return None
@@ -136,7 +137,7 @@ OPTIMIZATION_HANDLERS = [
def try_optimizations(
request_data: MessagesRequest, settings: Settings
-) -> Optional[MessagesResponse]:
+) -> MessagesResponse | None:
"""Run optimization handlers in order. Returns first match or None."""
for handler in OPTIMIZATION_HANDLERS:
result = handler(request_data, settings)
diff --git a/api/request_utils.py b/api/request_utils.py
index 8eee54dc..c571eb55 100644
--- a/api/request_utils.py
+++ b/api/request_utils.py
@@ -4,7 +4,7 @@ Contains token counting for API requests.
"""
import json
-from typing import Any, List, Optional, Union
+from typing import Any
import tiktoken
from loguru import logger
@@ -22,9 +22,9 @@ def _get_block_attr(block: Any, key: str, default: Any = "") -> Any:
def get_token_count(
- messages: List,
- system: Optional[Union[str, List]] = None,
- tools: Optional[List] = None,
+ messages: list,
+ system: str | list | None = None,
+ tools: list | None = None,
) -> int:
"""Estimate token count for a request.
diff --git a/api/routes.py b/api/routes.py
index fcf7d4c3..0945314d 100644
--- a/api/routes.py
+++ b/api/routes.py
@@ -3,20 +3,20 @@
import json
import uuid
-from fastapi import APIRouter, Request, Depends, HTTPException
-from loguru import logger
+from fastapi import APIRouter, Depends, HTTPException, Request
from fastapi.responses import StreamingResponse
+from loguru import logger
-from .models.anthropic import MessagesRequest, TokenCountRequest
-from .models.responses import TokenCountResponse
-from .dependencies import get_provider, get_settings
-from .request_utils import get_token_count
-from .optimization_handlers import try_optimizations
from config.settings import Settings
from providers.base import BaseProvider
from providers.exceptions import ProviderError
from providers.logging_utils import build_request_summary, log_request_compact
+from .dependencies import get_provider, get_settings
+from .models.anthropic import MessagesRequest, TokenCountRequest
+from .models.responses import TokenCountResponse
+from .optimization_handlers import try_optimizations
+from .request_utils import get_token_count
router = APIRouter()
@@ -65,8 +65,10 @@ async def create_message(
except Exception as e:
import traceback
- logger.error(f"Error: {str(e)}\n{traceback.format_exc()}")
- raise HTTPException(status_code=getattr(e, "status_code", 500), detail=str(e))
+ logger.error(f"Error: {e!s}\n{traceback.format_exc()}")
+ raise HTTPException(
+ status_code=getattr(e, "status_code", 500), detail=str(e)
+ ) from e
@router.post("/v1/messages/count_tokens")
@@ -92,7 +94,7 @@ async def count_tokens(request_data: TokenCountRequest):
str(e),
traceback.format_exc(),
)
- raise HTTPException(status_code=500, detail=str(e))
+ raise HTTPException(status_code=500, detail=str(e)) from e
@router.get("/")
diff --git a/cli/__init__.py b/cli/__init__.py
index adb78f53..2df9787d 100644
--- a/cli/__init__.py
+++ b/cli/__init__.py
@@ -1,6 +1,6 @@
"""CLI integration for Claude Code."""
-from .session import CLISession
from .manager import CLISessionManager
+from .session import CLISession
__all__ = ["CLISession", "CLISessionManager"]
diff --git a/cli/manager.py b/cli/manager.py
index 92b88c86..6d43acdf 100644
--- a/cli/manager.py
+++ b/cli/manager.py
@@ -8,11 +8,11 @@ simultaneously in separate CLI processes.
import asyncio
import uuid
-from typing import Dict, Optional, Tuple, List
-from .session import CLISession
from loguru import logger
+from .session import CLISession
+
class CLISessionManager:
"""
@@ -26,9 +26,9 @@ class CLISessionManager:
self,
workspace_path: str,
api_url: str,
- allowed_dirs: Optional[List[str]] = None,
+ allowed_dirs: list[str] | None = None,
max_sessions: int = 10,
- plans_directory: Optional[str] = None,
+ plans_directory: str | None = None,
):
"""
Initialize the session manager.
@@ -46,16 +46,16 @@ class CLISessionManager:
self.plans_directory = plans_directory
self.max_sessions = max_sessions
- self._sessions: Dict[str, CLISession] = {}
- self._pending_sessions: Dict[str, CLISession] = {}
- self._temp_to_real: Dict[str, str] = {}
+ self._sessions: dict[str, CLISession] = {}
+ self._pending_sessions: dict[str, CLISession] = {}
+ self._temp_to_real: dict[str, str] = {}
self._lock = asyncio.Lock()
logger.info(f"CLISessionManager initialized (max_sessions={max_sessions})")
async def get_or_create_session(
- self, session_id: Optional[str] = None
- ) -> Tuple[CLISession, str, bool]:
+ self, session_id: str | None = None
+ ) -> tuple[CLISession, str, bool]:
"""
Get an existing session or create a new one.
@@ -109,7 +109,7 @@ class CLISessionManager:
logger.info(f"Registered session: {temp_id} -> {real_session_id}")
return True
- async def get_real_session_id(self, temp_id: str) -> Optional[str]:
+ async def get_real_session_id(self, temp_id: str) -> str | None:
"""Get the real session ID for a temporary ID."""
async with self._lock:
return self._temp_to_real.get(temp_id)
@@ -158,7 +158,7 @@ class CLISessionManager:
self._temp_to_real.clear()
logger.info("All sessions stopped")
- def get_stats(self) -> Dict:
+ def get_stats(self) -> dict:
"""Get session statistics."""
return {
"active_sessions": len(self._sessions),
diff --git a/cli/process_registry.py b/cli/process_registry.py
index cc3510ad..1dadda0f 100644
--- a/cli/process_registry.py
+++ b/cli/process_registry.py
@@ -11,12 +11,11 @@ import atexit
import os
import subprocess
import threading
-from typing import Set
-from loguru import logger
+from loguru import logger
_lock = threading.Lock()
-_pids: Set[int] = set()
+_pids: set[int] = set()
_atexit_registered = False
diff --git a/cli/session.py b/cli/session.py
index d8cc32e8..88474141 100644
--- a/cli/session.py
+++ b/cli/session.py
@@ -1,13 +1,15 @@
"""Claude Code CLI session management."""
import asyncio
-import os
import json
-from typing import AsyncGenerator, Optional, List, Any
+import os
+from collections.abc import AsyncGenerator
+from typing import Any
-from .process_registry import register_pid, unregister_pid
from loguru import logger
+from .process_registry import register_pid, unregister_pid
+
class CLISession:
"""Manages a single persistent Claude Code CLI subprocess."""
@@ -16,15 +18,15 @@ class CLISession:
self,
workspace_path: str,
api_url: str,
- allowed_dirs: Optional[List[str]] = None,
- plans_directory: Optional[str] = None,
+ allowed_dirs: list[str] | None = None,
+ plans_directory: str | None = None,
):
self.workspace = os.path.normpath(os.path.abspath(workspace_path))
self.api_url = api_url
self.allowed_dirs = [os.path.normpath(d) for d in (allowed_dirs or [])]
self.plans_directory = plans_directory
- self.process: Optional[asyncio.subprocess.Process] = None
- self.current_session_id: Optional[str] = None
+ self.process: asyncio.subprocess.Process | None = None
+ self.current_session_id: str | None = None
self._is_busy = False
self._cli_lock = asyncio.Lock()
@@ -34,8 +36,8 @@ class CLISession:
return self._is_busy
async def start_task(
- self, prompt: str, session_id: Optional[str] = None, fork_session: bool = False
- ) -> AsyncGenerator[dict, None]:
+ self, prompt: str, session_id: str | None = None, fork_session: bool = False
+ ) -> AsyncGenerator[dict]:
"""
Start a new task or continue an existing session.
@@ -194,7 +196,7 @@ class CLISession:
async def _handle_line_gen(
self, line_str: str, session_id_extracted: bool
- ) -> AsyncGenerator[dict, None]:
+ ) -> AsyncGenerator[dict]:
"""Process a single line and yield events."""
try:
event = json.loads(line_str)
@@ -210,7 +212,7 @@ class CLISession:
logger.debug(f"Non-JSON output: {line_str}")
yield {"type": "raw", "content": line_str}
- def _extract_session_id(self, event: Any) -> Optional[str]:
+ def _extract_session_id(self, event: Any) -> str | None:
"""Extract session ID from CLI event."""
if not isinstance(event, dict):
return None
@@ -243,7 +245,7 @@ class CLISession:
self.process.terminate()
try:
await asyncio.wait_for(self.process.wait(), timeout=5.0)
- except asyncio.TimeoutError:
+ except TimeoutError:
self.process.kill()
await self.process.wait()
if self.process and self.process.pid:
diff --git a/config/logging_config.py b/config/logging_config.py
index b5c1abfc..a4b0c1fe 100644
--- a/config/logging_config.py
+++ b/config/logging_config.py
@@ -8,8 +8,8 @@ included at top level for easy grep/filter.
import json
import logging
-from loguru import logger
+from loguru import logger
_configured = False
diff --git a/config/nim.py b/config/nim.py
index 83dd3cd2..29e3681d 100644
--- a/config/nim.py
+++ b/config/nim.py
@@ -1,6 +1,6 @@
"""NVIDIA NIM settings (fixed values, no env config)."""
-from typing import Literal, Optional
+from typing import Literal
from pydantic import BaseModel, ConfigDict, Field, field_validator
@@ -18,8 +18,8 @@ class NimSettings(BaseModel):
min_p: float = Field(0.0, ge=0.0, le=1.0)
repetition_penalty: float = Field(1.0, ge=0.0)
- seed: Optional[int] = None
- stop: Optional[str] = None
+ seed: int | None = None
+ stop: str | None = None
parallel_tool_calls: bool = True
return_tokens_as_token_ids: bool = False
@@ -27,8 +27,8 @@ class NimSettings(BaseModel):
ignore_eos: bool = False
min_tokens: int = Field(0, ge=0)
- chat_template: Optional[str] = None
- request_id: Optional[str] = None
+ chat_template: str | None = None
+ request_id: str | None = None
reasoning_effort: Literal["low", "medium", "high"] = "high"
include_reasoning: bool = True
diff --git a/config/settings.py b/config/settings.py
index 413438e0..93e130b2 100644
--- a/config/settings.py
+++ b/config/settings.py
@@ -1,11 +1,10 @@
"""Centralized configuration using Pydantic Settings."""
from functools import lru_cache
-from typing import Optional
-from pydantic import field_validator, Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
from dotenv import load_dotenv
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
from .nim import NimSettings
@@ -85,12 +84,12 @@ class Settings(BaseSettings):
whisper_device: str = Field(default="cpu", validation_alias="WHISPER_DEVICE")
# ==================== Bot Wrapper Config ====================
- telegram_bot_token: Optional[str] = None
- allowed_telegram_user_id: Optional[str] = None
- discord_bot_token: Optional[str] = Field(
+ telegram_bot_token: str | None = None
+ allowed_telegram_user_id: str | None = None
+ discord_bot_token: str | None = Field(
default=None, validation_alias="DISCORD_BOT_TOKEN"
)
- allowed_discord_channels: Optional[str] = Field(
+ allowed_discord_channels: str | None = Field(
default=None, validation_alias="ALLOWED_DISCORD_CHANNELS"
)
claude_workspace: str = "./agent_workspace"
@@ -123,7 +122,7 @@ class Settings(BaseSettings):
)
-@lru_cache()
+@lru_cache
def get_settings() -> Settings:
"""Get cached settings instance."""
return Settings()
diff --git a/messaging/__init__.py b/messaging/__init__.py
index f50ec252..514e60e9 100644
--- a/messaging/__init__.py
+++ b/messaging/__init__.py
@@ -1,23 +1,23 @@
"""Platform-agnostic messaging layer."""
-from .base import MessagingPlatform, SessionManagerInterface, CLISession
-from .models import IncomingMessage
+from .base import CLISession, MessagingPlatform, SessionManagerInterface
+from .event_parser import parse_cli_event
from .handler import ClaudeMessageHandler
+from .models import IncomingMessage
from .session import SessionStore
-from .tree_data import MessageTree, MessageNode, MessageState
+from .tree_data import MessageNode, MessageState, MessageTree
from .tree_queue import TreeQueueManager
-from .event_parser import parse_cli_event
__all__ = [
- "MessagingPlatform",
- "SessionManagerInterface",
"CLISession",
- "IncomingMessage",
"ClaudeMessageHandler",
- "SessionStore",
- "TreeQueueManager",
- "MessageTree",
+ "IncomingMessage",
"MessageNode",
"MessageState",
+ "MessageTree",
+ "MessagingPlatform",
+ "SessionManagerInterface",
+ "SessionStore",
+ "TreeQueueManager",
"parse_cli_event",
]
diff --git a/messaging/base.py b/messaging/base.py
index 8310465b..dea35416 100644
--- a/messaging/base.py
+++ b/messaging/base.py
@@ -1,9 +1,9 @@
"""Backward-compatible re-export. Use messaging.platforms.base for new code."""
from .platforms.base import (
+ CLISession,
MessagingPlatform,
SessionManagerInterface,
- CLISession,
)
-__all__ = ["MessagingPlatform", "SessionManagerInterface", "CLISession"]
+__all__ = ["CLISession", "MessagingPlatform", "SessionManagerInterface"]
diff --git a/messaging/discord.py b/messaging/discord.py
index 84b43e8c..c646548d 100644
--- a/messaging/discord.py
+++ b/messaging/discord.py
@@ -1,17 +1,17 @@
"""Backward-compatible re-export. Use messaging.platforms.discord for new code."""
from .platforms.discord import (
- DiscordPlatform,
DISCORD_AVAILABLE,
DISCORD_MESSAGE_LIMIT,
- _parse_allowed_channels,
+ DiscordPlatform,
_get_discord,
+ _parse_allowed_channels,
)
__all__ = [
- "DiscordPlatform",
"DISCORD_AVAILABLE",
"DISCORD_MESSAGE_LIMIT",
- "_parse_allowed_channels",
+ "DiscordPlatform",
"_get_discord",
+ "_parse_allowed_channels",
]
diff --git a/messaging/discord_markdown.py b/messaging/discord_markdown.py
index 25d3fe97..96371268 100644
--- a/messaging/discord_markdown.py
+++ b/messaging/discord_markdown.py
@@ -1,25 +1,25 @@
"""Backward-compatible re-export. Use messaging.rendering.discord_markdown for new code."""
from .rendering.discord_markdown import (
- escape_discord,
- escape_discord_code,
+ _is_gfm_table_header_line,
+ _normalize_gfm_tables,
discord_bold,
discord_code_inline,
+ escape_discord,
+ escape_discord_code,
format_status,
format_status_discord,
render_markdown_to_discord,
- _is_gfm_table_header_line,
- _normalize_gfm_tables,
)
__all__ = [
- "escape_discord",
- "escape_discord_code",
+ "_is_gfm_table_header_line",
+ "_normalize_gfm_tables",
"discord_bold",
"discord_code_inline",
+ "escape_discord",
+ "escape_discord_code",
"format_status",
"format_status_discord",
"render_markdown_to_discord",
- "_is_gfm_table_header_line",
- "_normalize_gfm_tables",
]
diff --git a/messaging/event_parser.py b/messaging/event_parser.py
index c82f96e7..24992484 100644
--- a/messaging/event_parser.py
+++ b/messaging/event_parser.py
@@ -4,11 +4,12 @@ This parser emits an ordered stream of low-level events suitable for building a
Claude Code-like transcript in messaging UIs.
"""
-from typing import Dict, List, Any
+from typing import Any
+
from loguru import logger
-def parse_cli_event(event: Any) -> List[Dict]:
+def parse_cli_event(event: Any) -> list[dict]:
"""
Parse a CLI event and return a structured result.
@@ -22,7 +23,7 @@ def parse_cli_event(event: Any) -> List[Dict]:
return []
etype = event.get("type")
- results: List[Dict[str, Any]] = []
+ results: list[dict[str, Any]] = []
# Some CLI/proxy layers emit "system" events that are not user-visible and
# carry no transcript content. Ignore them explicitly to avoid noisy logs.
@@ -31,9 +32,7 @@ def parse_cli_event(event: Any) -> List[Dict]:
# 1. Handle full messages (assistant/user or result)
msg_obj = None
- if etype == "assistant":
- msg_obj = event.get("message")
- elif etype == "user":
+ if etype == "assistant" or etype == "user":
msg_obj = event.get("message")
elif etype == "result":
res = event.get("result")
diff --git a/messaging/handler.py b/messaging/handler.py
index fd3456ec..c883a85d 100644
--- a/messaging/handler.py
+++ b/messaging/handler.py
@@ -6,40 +6,43 @@ Handles the core workflow of processing user messages via Claude CLI.
Uses tree-based queuing for message ordering.
"""
-import time
import asyncio
import os
-from typing import List, Optional, Tuple
+import time
-from .platforms.base import MessagingPlatform, SessionManagerInterface
+from loguru import logger
+
+from .event_parser import parse_cli_event
from .models import IncomingMessage
-from .session import SessionStore
-from .trees.queue_manager import (
- TreeQueueManager,
- MessageNode,
- MessageState,
- MessageTree,
+from .platforms.base import MessagingPlatform, SessionManagerInterface
+from .rendering.discord_markdown import (
+ discord_bold,
+ discord_code_inline,
+ escape_discord,
+ escape_discord_code,
+ render_markdown_to_discord,
+)
+from .rendering.discord_markdown import (
+ format_status as format_status_discord, # (emoji, label, suffix)
)
-from .event_parser import parse_cli_event
-from .transcript import TranscriptBuffer, RenderCtx
from .rendering.telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
mdv2_bold,
mdv2_code_inline,
- format_status as format_status_telegram,
render_markdown_to_mdv2,
)
-from .rendering.discord_markdown import (
- escape_discord,
- escape_discord_code,
- discord_bold,
- discord_code_inline,
- format_status as format_status_discord, # (emoji, label, suffix)
- render_markdown_to_discord,
+from .rendering.telegram_markdown import (
+ format_status as format_status_telegram,
+)
+from .session import SessionStore
+from .transcript import RenderCtx, TranscriptBuffer
+from .trees.queue_manager import (
+ MessageNode,
+ MessageState,
+ MessageTree,
+ TreeQueueManager,
)
-from loguru import logger
-
# Status message prefixes used to filter our own messages (ignore echo)
STATUS_MESSAGE_PREFIXES = ("⏳", "💭", "🔧", "✅", "❌", "🚀", "🤖", "📋", "📊", "🔄")
@@ -77,7 +80,7 @@ _EVENT_STATUS_MAP = {
}
-def _get_status_for_event(ptype: str, parsed: dict, format_status_fn) -> Optional[str]:
+def _get_status_for_event(ptype: str, parsed: dict, format_status_fn) -> str | None:
"""Return status string for event type, or None if no status update needed."""
entry = _EVENT_STATUS_MAP.get(ptype)
if entry is not None:
@@ -115,15 +118,13 @@ class ClaudeMessageHandler:
node_started_callback=self._mark_node_processing,
)
- def _format_status(
- self, emoji: str, label: str, suffix: Optional[str] = None
- ) -> str:
+ def _format_status(self, emoji: str, label: str, suffix: str | None = None) -> str:
"""Platform-specific status formatting."""
if self.platform.name == "discord":
return format_status_discord(emoji, label, suffix)
return format_status_telegram(emoji, label, suffix)
- def _parse_mode(self) -> Optional[str]:
+ def _parse_mode(self) -> str | None:
"""Platform-specific parse mode (MarkdownV2 for Telegram, None for Discord)."""
if self.platform.name == "discord":
return None
@@ -262,7 +263,7 @@ class ClaudeMessageHandler:
# Create or extend tree
if parent_node_id and tree and status_msg_id:
# Reply to existing node - add as child
- tree, node = await self.tree_queue.add_to_tree(
+ tree, _node = await self.tree_queue.add_to_tree(
parent_node_id=parent_node_id,
node_id=node_id,
incoming=incoming,
@@ -350,7 +351,7 @@ class ClaudeMessageHandler:
def _create_transcript_and_render_ctx(
self,
- ) -> Tuple[TranscriptBuffer, RenderCtx]:
+ ) -> tuple[TranscriptBuffer, RenderCtx]:
"""Create transcript buffer and render context for node processing."""
transcript = TranscriptBuffer(show_tool_results=False)
return transcript, self._get_render_ctx()
@@ -358,11 +359,11 @@ class ClaudeMessageHandler:
async def _handle_session_info_event(
self,
event_data: dict,
- tree: Optional[MessageTree],
+ tree: MessageTree | None,
node_id: str,
- captured_session_id: Optional[str],
- temp_session_id: Optional[str],
- ) -> Tuple[Optional[str], Optional[str]]:
+ captured_session_id: str | None,
+ temp_session_id: str | None,
+ ) -> tuple[str | None, str | None]:
"""Handle session_info event; return updated (captured_session_id, temp_session_id)."""
if event_data.get("type") != "session_info":
return captured_session_id, temp_session_id
@@ -389,12 +390,12 @@ class ClaudeMessageHandler:
parsed: dict,
transcript: TranscriptBuffer,
update_ui,
- last_status: Optional[str],
+ last_status: str | None,
had_transcript_events: bool,
- tree: Optional[MessageTree],
+ tree: MessageTree | None,
node_id: str,
- captured_session_id: Optional[str],
- ) -> Tuple[Optional[str], bool]:
+ captured_session_id: str | None,
+ ) -> tuple[str | None, bool]:
"""Process a single parsed CLI event. Returns (last_status, had_transcript_events)."""
ptype = parsed.get("type") or ""
@@ -466,7 +467,7 @@ class ClaudeMessageHandler:
had_transcript_events = False
captured_session_id = None
temp_session_id = None
- last_status: Optional[str] = None
+ last_status: str | None = None
parent_session_id = None
if tree and node.parent_id:
@@ -474,7 +475,7 @@ class ClaudeMessageHandler:
if parent_session_id:
logger.info(f"Will fork from parent session: {parent_session_id}")
- async def update_ui(status: Optional[str] = None, force: bool = False) -> None:
+ async def update_ui(status: str | None = None, force: bool = False) -> None:
nonlocal last_ui_update, last_displayed_text, last_status
now = time.time()
if not force and now - last_ui_update < 1.0:
@@ -652,8 +653,8 @@ class ClaudeMessageHandler:
def _get_initial_status(
self,
- tree: Optional[object],
- parent_node_id: Optional[str],
+ tree: object | None,
+ parent_node_id: str | None,
) -> str:
"""Get initial status message text."""
if tree and parent_node_id:
@@ -719,7 +720,7 @@ class ClaudeMessageHandler:
self,
platform: str,
chat_id: str,
- msg_id: Optional[str],
+ msg_id: str | None,
kind: str,
) -> None:
"""Record outgoing message ID for /clear. Best-effort, never raises."""
@@ -732,7 +733,7 @@ class ClaudeMessageHandler:
except Exception as e:
logger.debug(f"Failed to record message_id: {e}")
- def _update_cancelled_nodes_ui(self, nodes: List[MessageNode]) -> None:
+ def _update_cancelled_nodes_ui(self, nodes: list[MessageNode]) -> None:
"""Update status messages and persist tree state for cancelled nodes."""
trees_to_save: dict[str, MessageTree] = {}
for node in nodes:
diff --git a/messaging/limiter.py b/messaging/limiter.py
index 4057ceba..6367e9e0 100644
--- a/messaging/limiter.py
+++ b/messaging/limiter.py
@@ -7,9 +7,11 @@ using a strict sliding window algorithm and a task queue.
import asyncio
import os
-from collections import deque
import time
-from typing import Awaitable, Callable, Any, Optional, Dict
+from collections import deque
+from collections.abc import Awaitable, Callable
+from typing import Any
+
from loguru import logger
@@ -57,7 +59,7 @@ class SlidingWindowLimiter:
else:
await asyncio.sleep(0)
- async def __aenter__(self) -> "SlidingWindowLimiter":
+ async def __aenter__(self) -> SlidingWindowLimiter:
await self.acquire()
return self
@@ -73,14 +75,14 @@ class MessagingRateLimiter:
only the latest version of a message update is processed.
"""
- _instance: Optional["MessagingRateLimiter"] = None
+ _instance: MessagingRateLimiter | None = None
_lock = asyncio.Lock()
def __new__(cls, *args, **kwargs):
- return super(MessagingRateLimiter, cls).__new__(cls)
+ return super().__new__(cls)
@classmethod
- async def get_instance(cls) -> "MessagingRateLimiter":
+ async def get_instance(cls) -> MessagingRateLimiter:
"""Get the singleton instance of the limiter."""
async with cls._lock:
if cls._instance is None:
@@ -100,12 +102,12 @@ class MessagingRateLimiter:
self.limiter = SlidingWindowLimiter(rate_limit, rate_window)
# Custom queue state - using deque for O(1) popleft
self._queue_list: deque[str] = deque() # Deque of dedup_keys in order
- self._queue_map: Dict[
+ self._queue_map: dict[
str, tuple[Callable[[], Awaitable[Any]], list[asyncio.Future]]
] = {}
self._condition = asyncio.Condition()
self._shutdown = asyncio.Event()
- self._worker_task: Optional[asyncio.Task] = None
+ self._worker_task: asyncio.Task | None = None
self._initialized = True
self._paused_until = 0
@@ -216,7 +218,7 @@ class MessagingRateLimiter:
task.cancel()
try:
await asyncio.wait_for(task, timeout=timeout)
- except asyncio.TimeoutError:
+ except TimeoutError:
logger.warning("MessagingRateLimiter worker did not stop before timeout")
except asyncio.CancelledError:
pass
@@ -243,7 +245,7 @@ class MessagingRateLimiter:
async with self._condition:
if dedup_key in self._queue_map:
# Compaction: Update existing task with new func, append new futures
- old_func, old_futures = self._queue_map[dedup_key]
+ _old_func, old_futures = self._queue_map[dedup_key]
old_futures.extend(futures)
self._queue_map[dedup_key] = (func, old_futures)
logger.debug(
@@ -258,7 +260,7 @@ class MessagingRateLimiter:
self._condition.notify_all()
async def enqueue(
- self, func: Callable[[], Awaitable[Any]], dedup_key: Optional[str] = None
+ self, func: Callable[[], Awaitable[Any]], dedup_key: str | None = None
) -> Any:
"""
Enqueue a messaging task and return its future result.
@@ -273,7 +275,7 @@ class MessagingRateLimiter:
return await future
def fire_and_forget(
- self, func: Callable[[], Awaitable[Any]], dedup_key: Optional[str] = None
+ self, func: Callable[[], Awaitable[Any]], dedup_key: str | None = None
):
"""Enqueue a task without waiting for the result."""
if dedup_key is None:
@@ -307,4 +309,4 @@ class MessagingRateLimiter:
future.set_exception(e)
break
- asyncio.create_task(_wrapped())
+ _ = asyncio.create_task(_wrapped())
diff --git a/messaging/models.py b/messaging/models.py
index 53391db5..1503c4ab 100644
--- a/messaging/models.py
+++ b/messaging/models.py
@@ -1,8 +1,8 @@
"""Platform-agnostic message models."""
from dataclasses import dataclass, field
-from typing import Optional, Any
-from datetime import datetime, timezone
+from datetime import UTC, datetime
+from typing import Any
@dataclass
@@ -20,11 +20,11 @@ class IncomingMessage:
platform: str # "telegram", "discord", "slack", etc.
# Optional fields
- reply_to_message_id: Optional[str] = None
- username: Optional[str] = None
+ reply_to_message_id: str | None = None
+ username: str | None = None
# Pre-sent status message ID (e.g. "Transcribing voice note..."); handler edits in place
- status_message_id: Optional[str] = None
- timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+ status_message_id: str | None = None
+ timestamp: datetime = field(default_factory=lambda: datetime.now(UTC))
# Platform-specific raw event for edge cases
raw_event: Any = None
diff --git a/messaging/platforms/__init__.py b/messaging/platforms/__init__.py
index 65dda7ee..88261a7a 100644
--- a/messaging/platforms/__init__.py
+++ b/messaging/platforms/__init__.py
@@ -1,11 +1,11 @@
"""Messaging platform adapters (Telegram, Discord, etc.)."""
-from .base import MessagingPlatform, SessionManagerInterface, CLISession
+from .base import CLISession, MessagingPlatform, SessionManagerInterface
from .factory import create_messaging_platform
__all__ = [
+ "CLISession",
"MessagingPlatform",
"SessionManagerInterface",
- "CLISession",
"create_messaging_platform",
]
diff --git a/messaging/platforms/base.py b/messaging/platforms/base.py
index ac93ef98..74228de0 100644
--- a/messaging/platforms/base.py
+++ b/messaging/platforms/base.py
@@ -1,17 +1,13 @@
"""Abstract base class for messaging platforms."""
from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator, Awaitable, Callable
from typing import (
- Callable,
- Awaitable,
- Optional,
+ Any,
Protocol,
- Tuple,
runtime_checkable,
- AsyncGenerator,
- Any,
- Dict,
)
+
from ..models import IncomingMessage
@@ -20,8 +16,8 @@ class CLISession(Protocol):
"""Protocol for CLI session - avoid circular import from cli package."""
def start_task(
- self, prompt: str, session_id: Optional[str] = None, fork_session: bool = False
- ) -> AsyncGenerator[Dict, Any]:
+ self, prompt: str, session_id: str | None = None, fork_session: bool = False
+ ) -> AsyncGenerator[dict, Any]:
"""Start a task in the CLI session."""
...
@@ -41,8 +37,8 @@ class SessionManagerInterface(Protocol):
"""
async def get_or_create_session(
- self, session_id: Optional[str] = None
- ) -> Tuple[CLISession, str, bool]:
+ self, session_id: str | None = None
+ ) -> tuple[CLISession, str, bool]:
"""
Get an existing session or create a new one.
@@ -93,8 +89,8 @@ class MessagingPlatform(ABC):
self,
chat_id: str,
text: str,
- reply_to: Optional[str] = None,
- parse_mode: Optional[str] = None,
+ reply_to: str | None = None,
+ parse_mode: str | None = None,
) -> str:
"""
Send a message to a chat.
@@ -116,7 +112,7 @@ class MessagingPlatform(ABC):
chat_id: str,
message_id: str,
text: str,
- parse_mode: Optional[str] = None,
+ parse_mode: str | None = None,
) -> None:
"""
Edit an existing message.
@@ -149,10 +145,10 @@ class MessagingPlatform(ABC):
self,
chat_id: str,
text: str,
- reply_to: Optional[str] = None,
- parse_mode: Optional[str] = None,
+ reply_to: str | None = None,
+ parse_mode: str | None = None,
fire_and_forget: bool = True,
- ) -> Optional[str]:
+ ) -> str | None:
"""
Enqueue a message to be sent.
@@ -167,7 +163,7 @@ class MessagingPlatform(ABC):
chat_id: str,
message_id: str,
text: str,
- parse_mode: Optional[str] = None,
+ parse_mode: str | None = None,
fire_and_forget: bool = True,
) -> None:
"""
diff --git a/messaging/platforms/discord.py b/messaging/platforms/discord.py
index 9afdc304..afde38f0 100644
--- a/messaging/platforms/discord.py
+++ b/messaging/platforms/discord.py
@@ -5,16 +5,18 @@ Implements MessagingPlatform for Discord using discord.py.
"""
import asyncio
+import contextlib
import os
import tempfile
+from collections.abc import Awaitable, Callable
from pathlib import Path
-from typing import Callable, Awaitable, Optional, Any, Set, cast
+from typing import Any, cast
from loguru import logger
-from .base import MessagingPlatform
from ..models import IncomingMessage
from ..rendering.discord_markdown import format_status_discord
+from .base import MessagingPlatform
AUDIO_EXTENSIONS = (".ogg", ".mp4", ".mp3", ".wav", ".m4a")
@@ -39,7 +41,7 @@ def _get_discord() -> Any:
return _discord_module
-def _parse_allowed_channels(raw: Optional[str]) -> Set[str]:
+def _parse_allowed_channels(raw: str | None) -> set[str]:
"""Parse comma-separated channel IDs into a set of strings."""
if not raw or not raw.strip():
return set()
@@ -54,7 +56,7 @@ if DISCORD_AVAILABLE and _discord_module is not None:
def __init__(
self,
- platform: "DiscordPlatform",
+ platform: DiscordPlatform,
intents: _discord.Intents,
) -> None:
super().__init__(intents=intents)
@@ -84,8 +86,8 @@ class DiscordPlatform(MessagingPlatform):
def __init__(
self,
- bot_token: Optional[str] = None,
- allowed_channel_ids: Optional[str] = None,
+ bot_token: str | None = None,
+ allowed_channel_ids: str | None = None,
):
if not DISCORD_AVAILABLE:
raise ImportError(
@@ -105,12 +107,12 @@ class DiscordPlatform(MessagingPlatform):
assert _DiscordClient is not None
self._client = _DiscordClient(self, intents)
- self._message_handler: Optional[
- Callable[[IncomingMessage], Awaitable[None]]
- ] = None
+ self._message_handler: Callable[[IncomingMessage], Awaitable[None]] | None = (
+ None
+ )
self._connected = False
- self._limiter: Optional[Any] = None
- self._start_task: Optional[asyncio.Task] = None
+ self._limiter: Any | None = None
+ self._start_task: asyncio.Task | None = None
def _get_audio_attachment(self, message: Any) -> Any | None:
"""Return first audio attachment, or None."""
@@ -164,9 +166,8 @@ class DiscordPlatform(MessagingPlatform):
elif "mp3" in ct or fn.endswith(".mp3"):
ext = ".mp3"
- tmp = tempfile.NamedTemporaryFile(suffix=ext, delete=False)
- tmp_path = Path(tmp.name)
- tmp.close()
+ with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as tmp:
+ tmp_path = Path(tmp.name)
try:
await attachment.save(str(tmp_path))
@@ -215,10 +216,8 @@ class DiscordPlatform(MessagingPlatform):
)
return True
finally:
- try:
+ with contextlib.suppress(OSError):
tmp_path.unlink(missing_ok=True)
- except OSError:
- pass
async def _on_discord_message(self, message: Any) -> None:
"""Handle incoming Discord messages."""
@@ -275,14 +274,12 @@ class DiscordPlatform(MessagingPlatform):
await self._message_handler(incoming)
except Exception as e:
logger.error(f"Error handling message: {e}")
- try:
+ with contextlib.suppress(Exception):
await self.send_message(
channel_id,
format_status_discord("Error:", str(e)[:200]),
reply_to=message_id,
)
- except Exception:
- pass
def _truncate(self, text: str, limit: int = DISCORD_MESSAGE_LIMIT) -> str:
"""Truncate text to Discord's message limit."""
@@ -325,12 +322,10 @@ class DiscordPlatform(MessagingPlatform):
if self._start_task and not self._start_task.done():
try:
await asyncio.wait_for(self._start_task, timeout=5.0)
- except asyncio.TimeoutError, asyncio.CancelledError:
+ except TimeoutError, asyncio.CancelledError:
self._start_task.cancel()
- try:
+ with contextlib.suppress(asyncio.CancelledError):
await self._start_task
- except asyncio.CancelledError:
- pass
self._connected = False
logger.info("Discord platform stopped")
@@ -339,8 +334,8 @@ class DiscordPlatform(MessagingPlatform):
self,
chat_id: str,
text: str,
- reply_to: Optional[str] = None,
- parse_mode: Optional[str] = None,
+ reply_to: str | None = None,
+ parse_mode: str | None = None,
) -> str:
"""Send a message to a channel."""
channel = self._client.get_channel(int(chat_id))
@@ -367,7 +362,7 @@ class DiscordPlatform(MessagingPlatform):
chat_id: str,
message_id: str,
text: str,
- parse_mode: Optional[str] = None,
+ parse_mode: str | None = None,
) -> None:
"""Edit an existing message."""
channel = self._client.get_channel(int(chat_id))
@@ -411,10 +406,10 @@ class DiscordPlatform(MessagingPlatform):
self,
chat_id: str,
text: str,
- reply_to: Optional[str] = None,
- parse_mode: Optional[str] = None,
+ reply_to: str | None = None,
+ parse_mode: str | None = None,
fire_and_forget: bool = True,
- ) -> Optional[str]:
+ ) -> str | None:
"""Enqueue a message to be sent."""
if not self._limiter:
return await self.send_message(chat_id, text, reply_to, parse_mode)
@@ -432,7 +427,7 @@ class DiscordPlatform(MessagingPlatform):
chat_id: str,
message_id: str,
text: str,
- parse_mode: Optional[str] = None,
+ parse_mode: str | None = None,
fire_and_forget: bool = True,
) -> None:
"""Enqueue a message edit."""
@@ -495,9 +490,9 @@ class DiscordPlatform(MessagingPlatform):
def fire_and_forget(self, task: Awaitable[Any]) -> None:
"""Execute a coroutine without awaiting it."""
if asyncio.iscoroutine(task):
- asyncio.create_task(task)
+ _ = asyncio.create_task(task)
else:
- asyncio.ensure_future(task)
+ _ = asyncio.ensure_future(task)
def on_message(
self,
diff --git a/messaging/platforms/factory.py b/messaging/platforms/factory.py
index a165caa6..f260c3b3 100644
--- a/messaging/platforms/factory.py
+++ b/messaging/platforms/factory.py
@@ -6,8 +6,6 @@ To add a new platform (e.g. Discord, Slack):
2. Add a case to create_messaging_platform() below
"""
-from typing import Optional
-
from loguru import logger
from .base import MessagingPlatform
@@ -16,7 +14,7 @@ from .base import MessagingPlatform
def create_messaging_platform(
platform_type: str,
**kwargs,
-) -> Optional[MessagingPlatform]:
+) -> MessagingPlatform | None:
"""Create a messaging platform instance based on type.
Args:
diff --git a/messaging/platforms/telegram.py b/messaging/platforms/telegram.py
index 4a4cd6ef..1ae5bccd 100644
--- a/messaging/platforms/telegram.py
+++ b/messaging/platforms/telegram.py
@@ -5,6 +5,7 @@ Implements MessagingPlatform for Telegram using python-telegram-bot.
"""
import asyncio
+import contextlib
import os
import tempfile
from pathlib import Path
@@ -13,7 +14,8 @@ from pathlib import Path
# This must be set BEFORE importing telegram.error
os.environ["PTB_TIMEDELTA"] = "1"
-from typing import Callable, Awaitable, Optional, Any, TYPE_CHECKING
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
from loguru import logger
@@ -21,22 +23,21 @@ if TYPE_CHECKING:
from telegram import Update
from telegram.ext import ContextTypes
-from .base import MessagingPlatform
from ..models import IncomingMessage
from ..rendering.telegram_markdown import escape_md_v2, format_status
-
+from .base import MessagingPlatform
# Optional import - python-telegram-bot may not be installed
try:
from telegram import Update
+ from telegram.error import NetworkError, RetryAfter, TelegramError
from telegram.ext import (
Application,
CommandHandler,
- MessageHandler,
ContextTypes,
+ MessageHandler,
filters,
)
- from telegram.error import TelegramError, RetryAfter, NetworkError
from telegram.request import HTTPXRequest
TELEGRAM_AVAILABLE = True
@@ -56,8 +57,8 @@ class TelegramPlatform(MessagingPlatform):
def __init__(
self,
- bot_token: Optional[str] = None,
- allowed_user_id: Optional[str] = None,
+ bot_token: str | None = None,
+ allowed_user_id: str | None = None,
):
if not TELEGRAM_AVAILABLE:
raise ImportError(
@@ -72,12 +73,12 @@ class TelegramPlatform(MessagingPlatform):
# but start() will fail.
logger.warning("TELEGRAM_BOT_TOKEN not set")
- self._application: Optional[Application] = None
- self._message_handler: Optional[
- Callable[[IncomingMessage], Awaitable[None]]
- ] = None
+ self._application: Application | None = None
+ self._message_handler: Callable[[IncomingMessage], Awaitable[None]] | None = (
+ None
+ )
self._connected = False
- self._limiter: Optional[Any] = None # Will be MessagingRateLimiter
+ self._limiter: Any | None = None # Will be MessagingRateLimiter
async def start(self) -> None:
"""Initialize and connect to Telegram."""
@@ -174,7 +175,7 @@ class TelegramPlatform(MessagingPlatform):
for attempt in range(max_retries):
try:
return await func(*args, **kwargs)
- except (NetworkError, asyncio.TimeoutError) as e:
+ except (TimeoutError, NetworkError) as e:
if "Message is not modified" in str(e):
return None
if attempt < max_retries - 1:
@@ -229,8 +230,8 @@ class TelegramPlatform(MessagingPlatform):
self,
chat_id: str,
text: str,
- reply_to: Optional[str] = None,
- parse_mode: Optional[str] = "MarkdownV2",
+ reply_to: str | None = None,
+ parse_mode: str | None = "MarkdownV2",
) -> str:
"""Send a message to a chat."""
app = self._application
@@ -254,7 +255,7 @@ class TelegramPlatform(MessagingPlatform):
chat_id: str,
message_id: str,
text: str,
- parse_mode: Optional[str] = "MarkdownV2",
+ parse_mode: str | None = "MarkdownV2",
) -> None:
"""Edit an existing message."""
app = self._application
@@ -322,10 +323,10 @@ class TelegramPlatform(MessagingPlatform):
self,
chat_id: str,
text: str,
- reply_to: Optional[str] = None,
- parse_mode: Optional[str] = "MarkdownV2",
+ reply_to: str | None = None,
+ parse_mode: str | None = "MarkdownV2",
fire_and_forget: bool = True,
- ) -> Optional[str]:
+ ) -> str | None:
"""Enqueue a message to be sent (using limiter)."""
# Note: Bot API handles limits better, but we still use our limiter for nice queuing
if not self._limiter:
@@ -345,7 +346,7 @@ class TelegramPlatform(MessagingPlatform):
chat_id: str,
message_id: str,
text: str,
- parse_mode: Optional[str] = "MarkdownV2",
+ parse_mode: str | None = "MarkdownV2",
fire_and_forget: bool = True,
) -> None:
"""Enqueue a message edit."""
@@ -406,9 +407,9 @@ class TelegramPlatform(MessagingPlatform):
def fire_and_forget(self, task: Awaitable[Any]) -> None:
"""Execute a coroutine without awaiting it."""
if asyncio.iscoroutine(task):
- asyncio.create_task(task)
+ _ = asyncio.create_task(task)
else:
- asyncio.ensure_future(task)
+ _ = asyncio.ensure_future(task)
def on_message(
self,
@@ -423,7 +424,7 @@ class TelegramPlatform(MessagingPlatform):
return self._connected
async def _on_start_command(
- self, update: "Update", context: "ContextTypes.DEFAULT_TYPE"
+ self, update: Update, context: ContextTypes.DEFAULT_TYPE
) -> None:
"""Handle /start command."""
if update.message:
@@ -432,7 +433,7 @@ class TelegramPlatform(MessagingPlatform):
await self._on_telegram_message(update, context)
async def _on_telegram_message(
- self, update: "Update", context: "ContextTypes.DEFAULT_TYPE"
+ self, update: Update, context: ContextTypes.DEFAULT_TYPE
) -> None:
"""Handle incoming updates."""
if (
@@ -447,10 +448,9 @@ class TelegramPlatform(MessagingPlatform):
chat_id = str(update.effective_chat.id)
# Security check
- if self.allowed_user_id:
- if user_id != str(self.allowed_user_id).strip():
- logger.warning(f"Unauthorized access attempt from {user_id}")
- return
+ if self.allowed_user_id and user_id != str(self.allowed_user_id).strip():
+ logger.warning(f"Unauthorized access attempt from {user_id}")
+ return
message_id = str(update.message.message_id)
reply_to = (
@@ -486,18 +486,16 @@ class TelegramPlatform(MessagingPlatform):
await self._message_handler(incoming)
except Exception as e:
logger.error(f"Error handling message: {e}")
- try:
+ with contextlib.suppress(Exception):
await self.send_message(
chat_id,
f"❌ *{escape_md_v2('Error:')}* {escape_md_v2(str(e)[:200])}",
reply_to=incoming.message_id,
parse_mode="MarkdownV2",
)
- except Exception:
- pass
async def _on_telegram_voice(
- self, update: "Update", context: "ContextTypes.DEFAULT_TYPE"
+ self, update: Update, context: ContextTypes.DEFAULT_TYPE
) -> None:
"""Handle incoming voice messages."""
if (
@@ -547,9 +545,8 @@ class TelegramPlatform(MessagingPlatform):
elif voice.mime_type and "mp4" in voice.mime_type:
suffix = ".mp4"
- tmp = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
- tmp_path = Path(tmp.name)
- tmp.close()
+ with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+ tmp_path = Path(tmp.name)
try:
tg_file = await context.bot.get_file(voice.file_id)
@@ -594,7 +591,5 @@ class TelegramPlatform(MessagingPlatform):
"Could not transcribe voice note. Please try again or send text."
)
finally:
- try:
+ with contextlib.suppress(OSError):
tmp_path.unlink(missing_ok=True)
- except OSError:
- pass
diff --git a/messaging/rendering/__init__.py b/messaging/rendering/__init__.py
index c3d33653..0c0528e2 100644
--- a/messaging/rendering/__init__.py
+++ b/messaging/rendering/__init__.py
@@ -1,37 +1,41 @@
"""Markdown rendering utilities for messaging platforms."""
from .discord_markdown import (
- escape_discord,
- escape_discord_code,
discord_bold,
discord_code_inline,
- format_status as format_status_discord_fn,
+ escape_discord,
+ escape_discord_code,
format_status_discord,
render_markdown_to_discord,
)
+from .discord_markdown import (
+ format_status as format_status_discord_fn,
+)
from .telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
escape_md_v2_link_url,
mdv2_bold,
mdv2_code_inline,
- format_status as format_status_telegram_fn,
render_markdown_to_mdv2,
)
+from .telegram_markdown import (
+ format_status as format_status_telegram_fn,
+)
__all__ = [
- "escape_discord",
- "escape_discord_code",
"discord_bold",
"discord_code_inline",
- "format_status_discord_fn",
- "format_status_discord",
- "render_markdown_to_discord",
+ "escape_discord",
+ "escape_discord_code",
"escape_md_v2",
"escape_md_v2_code",
"escape_md_v2_link_url",
+ "format_status_discord",
+ "format_status_discord_fn",
+ "format_status_telegram_fn",
"mdv2_bold",
"mdv2_code_inline",
- "format_status_telegram_fn",
+ "render_markdown_to_discord",
"render_markdown_to_mdv2",
]
diff --git a/messaging/rendering/discord_markdown.py b/messaging/rendering/discord_markdown.py
index 5e6e2aab..b684f288 100644
--- a/messaging/rendering/discord_markdown.py
+++ b/messaging/rendering/discord_markdown.py
@@ -5,7 +5,6 @@ Used by the message handler and Discord platform adapter.
"""
import re
-from typing import List, Optional
from markdown_it import MarkdownIt
@@ -38,7 +37,7 @@ def _normalize_gfm_tables(text: str) -> str:
if len(lines) < 2:
return text
- out_lines: List[str] = []
+ out_lines: list[str] = []
in_fence = False
for idx, line in enumerate(lines):
@@ -52,11 +51,12 @@ def _normalize_gfm_tables(text: str) -> str:
and idx + 1 < len(lines)
and _is_gfm_table_header_line(line)
and _TABLE_SEP_RE.match(lines[idx + 1])
+ and out_lines
+ and out_lines[-1].strip() != ""
):
- if out_lines and out_lines[-1].strip() != "":
- m = re.match(r"^(\s*)", line)
- indent = m.group(1) if m else ""
- out_lines.append(indent)
+ m = re.match(r"^(\s*)", line)
+ indent = m.group(1) if m else ""
+ out_lines.append(indent)
out_lines.append(line)
@@ -83,7 +83,7 @@ def discord_code_inline(text: str) -> str:
return f"`{escape_discord_code(text)}`"
-def format_status_discord(label: str, suffix: Optional[str] = None) -> str:
+def format_status_discord(label: str, suffix: str | None = None) -> str:
"""Format a status message for Discord (label in bold, optional suffix)."""
base = discord_bold(label)
if suffix:
@@ -91,7 +91,7 @@ def format_status_discord(label: str, suffix: Optional[str] = None) -> str:
return base
-def format_status(emoji: str, label: str, suffix: Optional[str] = None) -> str:
+def format_status(emoji: str, label: str, suffix: str | None = None) -> str:
"""Format a status message with emoji for Discord (matches Telegram API)."""
base = f"{emoji} {discord_bold(label)}"
if suffix:
@@ -108,21 +108,18 @@ def render_markdown_to_discord(text: str) -> str:
tokens = _MD.parse(text)
def render_inline_table_plain(children) -> str:
- out: List[str] = []
+ out: list[str] = []
for tok in children:
- if tok.type == "text":
- out.append(tok.content)
- elif tok.type == "code_inline":
+ if tok.type == "text" or tok.type == "code_inline":
out.append(tok.content)
elif tok.type in {"softbreak", "hardbreak"}:
out.append(" ")
- elif tok.type == "image":
- if tok.content:
- out.append(tok.content)
+ elif tok.type == "image" and tok.content:
+ out.append(tok.content)
return "".join(out)
def render_inline(children) -> str:
- out: List[str] = []
+ out: list[str] = []
i = 0
while i < len(children):
tok = children[i]
@@ -131,17 +128,11 @@ def render_markdown_to_discord(text: str) -> str:
out.append(escape_discord(tok.content))
elif t in {"softbreak", "hardbreak"}:
out.append("\n")
- elif t == "em_open":
- out.append("*")
- elif t == "em_close":
+ elif t == "em_open" or t == "em_close":
out.append("*")
- elif t == "strong_open":
+ elif t == "strong_open" or t == "strong_close":
out.append("**")
- elif t == "strong_close":
- out.append("**")
- elif t == "s_open":
- out.append("~~")
- elif t == "s_close":
+ elif t == "s_open" or t == "s_close":
out.append("~~")
elif t == "code_inline":
out.append(f"`{escape_discord_code(tok.content)}`")
@@ -162,9 +153,7 @@ def render_markdown_to_discord(text: str) -> str:
i += 1
link_text = ""
for child in inner_tokens:
- if child.type == "text":
- link_text += child.content
- elif child.type == "code_inline":
+ if child.type == "text" or child.type == "code_inline":
link_text += child.content
out.append(f"[{escape_discord(link_text)}]({href})")
elif t == "image":
@@ -187,9 +176,9 @@ def render_markdown_to_discord(text: str) -> str:
i += 1
return "".join(out)
- out: List[str] = []
- list_stack: List[dict] = []
- pending_prefix: Optional[str] = None
+ out: list[str] = []
+ list_stack: list[dict] = []
+ pending_prefix: str | None = None
blockquote_level = 0
in_heading = False
@@ -262,17 +251,17 @@ def render_markdown_to_discord(text: str) -> str:
out.append("\n")
pending_prefix = None
- rows: List[List[str]] = []
- row_is_header: List[bool] = []
+ rows: list[list[str]] = []
+ row_is_header: list[bool] = []
j = i + 1
in_thead = False
in_row = False
- current_row: List[str] = []
+ current_row: list[str] = []
current_row_header = False
in_cell = False
- cell_parts: List[str] = []
+ cell_parts: list[str] = []
while j < len(tokens):
tt = tokens[j].type
@@ -306,23 +295,25 @@ def render_markdown_to_discord(text: str) -> str:
if rows:
col_count = max((len(r) for r in rows), default=0)
- norm_rows: List[List[str]] = []
+ norm_rows: list[list[str]] = []
for r in rows:
if len(r) < col_count:
r = r + [""] * (col_count - len(r))
norm_rows.append(r)
- widths: List[int] = []
+ widths: list[int] = []
for c in range(col_count):
w = max((len(r[c]) for r in norm_rows), default=0)
widths.append(max(w, 3))
- def fmt_row(r: List[str]) -> str:
- cells = [r[c].ljust(widths[c]) for c in range(col_count)]
+ def fmt_row(
+ r: list[str], _w: list[int] = widths, _c: int = col_count
+ ) -> str:
+ cells = [r[c].ljust(_w[c]) for c in range(_c)]
return "| " + " | ".join(cells) + " |"
- def fmt_sep() -> str:
- cells = ["-" * widths[c] for c in range(col_count)]
+ def fmt_sep(_w: list[int] = widths, _c: int = col_count) -> str:
+ cells = ["-" * _w[c] for c in range(_c)]
return "| " + " | ".join(cells) + " |"
last_header_idx = -1
@@ -330,7 +321,7 @@ def render_markdown_to_discord(text: str) -> str:
if is_h:
last_header_idx = idx
- lines: List[str] = []
+ lines: list[str] = []
for idx, r in enumerate(norm_rows):
lines.append(fmt_row(r))
if idx == last_header_idx:
@@ -364,10 +355,10 @@ def render_markdown_to_discord(text: str) -> str:
__all__ = [
- "escape_discord",
- "escape_discord_code",
"discord_bold",
"discord_code_inline",
+ "escape_discord",
+ "escape_discord_code",
"format_status",
"format_status_discord",
"render_markdown_to_discord",
diff --git a/messaging/rendering/telegram_markdown.py b/messaging/rendering/telegram_markdown.py
index aa9efe5f..093c3089 100644
--- a/messaging/rendering/telegram_markdown.py
+++ b/messaging/rendering/telegram_markdown.py
@@ -5,7 +5,6 @@ Used by the message handler and Telegram platform adapter.
"""
import re
-from typing import List, Optional
from markdown_it import MarkdownIt
@@ -44,7 +43,7 @@ def _normalize_gfm_tables(text: str) -> str:
if len(lines) < 2:
return text
- out_lines: List[str] = []
+ out_lines: list[str] = []
in_fence = False
for idx, line in enumerate(lines):
@@ -58,11 +57,12 @@ def _normalize_gfm_tables(text: str) -> str:
and idx + 1 < len(lines)
and _is_gfm_table_header_line(line)
and _TABLE_SEP_RE.match(lines[idx + 1])
+ and out_lines
+ and out_lines[-1].strip() != ""
):
- if out_lines and out_lines[-1].strip() != "":
- m = re.match(r"^(\s*)", line)
- indent = m.group(1) if m else ""
- out_lines.append(indent)
+ m = re.match(r"^(\s*)", line)
+ indent = m.group(1) if m else ""
+ out_lines.append(indent)
out_lines.append(line)
@@ -94,7 +94,7 @@ def mdv2_code_inline(text: str) -> str:
return f"`{escape_md_v2_code(text)}`"
-def format_status(emoji: str, label: str, suffix: Optional[str] = None) -> str:
+def format_status(emoji: str, label: str, suffix: str | None = None) -> str:
"""Format a status message with emoji and optional suffix."""
base = f"{emoji} {mdv2_bold(label)}"
if suffix:
@@ -111,32 +111,27 @@ def render_markdown_to_mdv2(text: str) -> str:
tokens = _MD.parse(text)
def render_inline_table_plain(children) -> str:
- out: List[str] = []
+ out: list[str] = []
for tok in children:
- if tok.type == "text":
- out.append(tok.content)
- elif tok.type == "code_inline":
+ if tok.type == "text" or tok.type == "code_inline":
out.append(tok.content)
elif tok.type in {"softbreak", "hardbreak"}:
out.append(" ")
- elif tok.type == "image":
- if tok.content:
- out.append(tok.content)
+ elif tok.type == "image" and tok.content:
+ out.append(tok.content)
return "".join(out)
def render_inline_plain(children) -> str:
- out: List[str] = []
+ out: list[str] = []
for tok in children:
- if tok.type == "text":
- out.append(escape_md_v2(tok.content))
- elif tok.type == "code_inline":
+ if tok.type == "text" or tok.type == "code_inline":
out.append(escape_md_v2(tok.content))
elif tok.type in {"softbreak", "hardbreak"}:
out.append("\n")
return "".join(out)
def render_inline(children) -> str:
- out: List[str] = []
+ out: list[str] = []
i = 0
while i < len(children):
tok = children[i]
@@ -145,17 +140,11 @@ def render_markdown_to_mdv2(text: str) -> str:
out.append(escape_md_v2(tok.content))
elif t in {"softbreak", "hardbreak"}:
out.append("\n")
- elif t == "em_open":
+ elif t == "em_open" or t == "em_close":
out.append("_")
- elif t == "em_close":
- out.append("_")
- elif t == "strong_open":
- out.append("*")
- elif t == "strong_close":
+ elif t == "strong_open" or t == "strong_close":
out.append("*")
- elif t == "s_open":
- out.append("~")
- elif t == "s_close":
+ elif t == "s_open" or t == "s_close":
out.append("~")
elif t == "code_inline":
out.append(f"`{escape_md_v2_code(tok.content)}`")
@@ -176,9 +165,7 @@ def render_markdown_to_mdv2(text: str) -> str:
i += 1
link_text = ""
for child in inner_tokens:
- if child.type == "text":
- link_text += child.content
- elif child.type == "code_inline":
+ if child.type == "text" or child.type == "code_inline":
link_text += child.content
out.append(
f"[{escape_md_v2(link_text)}]({escape_md_v2_link_url(href)})"
@@ -203,9 +190,9 @@ def render_markdown_to_mdv2(text: str) -> str:
i += 1
return "".join(out)
- out: List[str] = []
- list_stack: List[dict] = []
- pending_prefix: Optional[str] = None
+ out: list[str] = []
+ list_stack: list[dict] = []
+ pending_prefix: str | None = None
blockquote_level = 0
in_heading = False
@@ -279,17 +266,17 @@ def render_markdown_to_mdv2(text: str) -> str:
out.append("\n")
pending_prefix = None
- rows: List[List[str]] = []
- row_is_header: List[bool] = []
+ rows: list[list[str]] = []
+ row_is_header: list[bool] = []
j = i + 1
in_thead = False
in_row = False
- current_row: List[str] = []
+ current_row: list[str] = []
current_row_header = False
in_cell = False
- cell_parts: List[str] = []
+ cell_parts: list[str] = []
while j < len(tokens):
tt = tokens[j].type
@@ -323,23 +310,25 @@ def render_markdown_to_mdv2(text: str) -> str:
if rows:
col_count = max((len(r) for r in rows), default=0)
- norm_rows: List[List[str]] = []
+ norm_rows: list[list[str]] = []
for r in rows:
if len(r) < col_count:
r = r + [""] * (col_count - len(r))
norm_rows.append(r)
- widths: List[int] = []
+ widths: list[int] = []
for c in range(col_count):
w = max((len(r[c]) for r in norm_rows), default=0)
widths.append(max(w, 3))
- def fmt_row(r: List[str]) -> str:
- cells = [r[c].ljust(widths[c]) for c in range(col_count)]
+ def fmt_row(
+ r: list[str], _w: list[int] = widths, _c: int = col_count
+ ) -> str:
+ cells = [r[c].ljust(_w[c]) for c in range(_c)]
return "| " + " | ".join(cells) + " |"
- def fmt_sep() -> str:
- cells = ["-" * widths[c] for c in range(col_count)]
+ def fmt_sep(_w: list[int] = widths, _c: int = col_count) -> str:
+ cells = ["-" * _w[c] for c in range(_c)]
return "| " + " | ".join(cells) + " |"
last_header_idx = -1
@@ -347,7 +336,7 @@ def render_markdown_to_mdv2(text: str) -> str:
if is_h:
last_header_idx = idx
- lines: List[str] = []
+ lines: list[str] = []
for idx, r in enumerate(norm_rows):
lines.append(fmt_row(r))
if idx == last_header_idx:
@@ -384,8 +373,8 @@ __all__ = [
"escape_md_v2",
"escape_md_v2_code",
"escape_md_v2_link_url",
+ "format_status",
"mdv2_bold",
"mdv2_code_inline",
- "format_status",
"render_markdown_to_mdv2",
]
diff --git a/messaging/session.py b/messaging/session.py
index d7771785..4f997a47 100644
--- a/messaging/session.py
+++ b/messaging/session.py
@@ -7,9 +7,10 @@ and message trees for conversation continuation.
import json
import os
-from datetime import datetime, timezone
-from typing import Optional, Dict, List, Any
import threading
+from datetime import UTC, datetime
+from typing import Any
+
from loguru import logger
@@ -24,18 +25,18 @@ class SessionStore:
def __init__(self, storage_path: str = "sessions.json"):
self.storage_path = storage_path
self._lock = threading.Lock()
- self._trees: Dict[str, dict] = {} # root_id -> tree data
- self._node_to_tree: Dict[str, str] = {} # node_id -> root_id
+ self._trees: dict[str, dict] = {} # root_id -> tree data
+ self._node_to_tree: dict[str, str] = {} # node_id -> root_id
# Per-chat message ID log used to support best-effort UI clearing (/clear).
# Key: "{platform}:{chat_id}" -> list of records
- self._message_log: Dict[str, List[Dict[str, Any]]] = {}
- self._message_log_ids: Dict[str, set[str]] = {}
+ self._message_log: dict[str, list[dict[str, Any]]] = {}
+ self._message_log_ids: dict[str, set[str]] = {}
self._dirty = False
- self._save_timer: Optional[threading.Timer] = None
+ self._save_timer: threading.Timer | None = None
self._save_debounce_secs = 0.5
cap_raw = os.getenv("MAX_MESSAGE_LOG_ENTRIES_PER_CHAT", "").strip()
try:
- self._message_log_cap: Optional[int] = int(cap_raw) if cap_raw else None
+ self._message_log_cap: int | None = int(cap_raw) if cap_raw else None
except ValueError:
self._message_log_cap = None
self._load()
@@ -49,7 +50,7 @@ class SessionStore:
return
try:
- with open(self.storage_path, "r", encoding="utf-8") as f:
+ with open(self.storage_path, encoding="utf-8") as f:
data = json.load(f)
# Load trees
@@ -64,7 +65,7 @@ class SessionStore:
for chat_key, items in raw_log.items():
if not isinstance(chat_key, str) or not isinstance(items, list):
continue
- cleaned: List[Dict[str, Any]] = []
+ cleaned: list[dict[str, Any]] = []
seen: set[str] = set()
for it in items:
if not isinstance(it, dict):
@@ -164,7 +165,7 @@ class SessionStore:
rec = {
"message_id": mid,
- "ts": datetime.now(timezone.utc).isoformat(),
+ "ts": datetime.now(UTC).isoformat(),
"direction": str(direction),
"kind": str(kind),
}
@@ -182,7 +183,7 @@ class SessionStore:
self._schedule_save()
- def get_message_ids_for_chat(self, platform: str, chat_id: str) -> List[str]:
+ def get_message_ids_for_chat(self, platform: str, chat_id: str) -> list[str]:
"""Get all recorded message IDs for a chat (in insertion order)."""
chat_key = self._make_chat_key(str(platform), str(chat_id))
with self._lock:
@@ -216,18 +217,18 @@ class SessionStore:
self._trees[root_id] = tree_data
# Update node-to-tree mapping
- for node_id in tree_data.get("nodes", {}).keys():
+ for node_id in tree_data.get("nodes", {}):
self._node_to_tree[node_id] = root_id
self._schedule_save()
logger.debug(f"Saved tree {root_id}")
- def get_tree(self, root_id: str) -> Optional[dict]:
+ def get_tree(self, root_id: str) -> dict | None:
"""Get a tree by its root ID."""
with self._lock:
return self._trees.get(root_id)
- def get_tree_root_for_node(self, node_id: str) -> Optional[str]:
+ def get_tree_root_for_node(self, node_id: str) -> str | None:
"""Get the root ID of the tree containing a node."""
with self._lock:
return self._node_to_tree.get(node_id)
@@ -238,7 +239,7 @@ class SessionStore:
self._node_to_tree[node_id] = root_id
self._schedule_save()
- def remove_node_mappings(self, node_ids: List[str]) -> None:
+ def remove_node_mappings(self, node_ids: list[str]) -> None:
"""Remove node IDs from the node-to-tree mapping."""
with self._lock:
for nid in node_ids:
@@ -250,22 +251,22 @@ class SessionStore:
with self._lock:
tree_data = self._trees.pop(root_id, None)
if tree_data:
- for node_id in tree_data.get("nodes", {}).keys():
+ for node_id in tree_data.get("nodes", {}):
self._node_to_tree.pop(node_id, None)
self._schedule_save()
- def get_all_trees(self) -> Dict[str, dict]:
+ def get_all_trees(self) -> dict[str, dict]:
"""Get all stored trees (public accessor)."""
with self._lock:
return dict(self._trees)
- def get_node_mapping(self) -> Dict[str, str]:
+ def get_node_mapping(self) -> dict[str, str]:
"""Get the node-to-tree mapping (public accessor)."""
with self._lock:
return dict(self._node_to_tree)
def sync_from_tree_data(
- self, trees: Dict[str, dict], node_to_tree: Dict[str, str]
+ self, trees: dict[str, dict], node_to_tree: dict[str, str]
) -> None:
"""Sync internal tree state from external data and persist."""
with self._lock:
@@ -276,7 +277,7 @@ class SessionStore:
def cleanup_old_trees(self, max_age_days: int = 30) -> int:
"""Remove trees older than max_age_days."""
with self._lock:
- cutoff = datetime.now(timezone.utc)
+ cutoff = datetime.now(UTC)
removed = 0
to_remove = []
@@ -296,7 +297,7 @@ class SessionStore:
for root_id in to_remove:
tree_data = self._trees.pop(root_id)
# Remove node mappings
- for node_id in tree_data.get("nodes", {}).keys():
+ for node_id in tree_data.get("nodes", {}):
self._node_to_tree.pop(node_id, None)
removed += 1
diff --git a/messaging/telegram.py b/messaging/telegram.py
index 6475e3ae..c2176914 100644
--- a/messaging/telegram.py
+++ b/messaging/telegram.py
@@ -1,12 +1,12 @@
"""Backward-compatible re-export. Use messaging.platforms.telegram for new code."""
from .platforms.telegram import (
- TelegramPlatform,
TELEGRAM_AVAILABLE,
+ TelegramPlatform,
)
# Re-export telegram.error types when python-telegram-bot is installed
-__all__ = ["TelegramPlatform", "TELEGRAM_AVAILABLE"]
+__all__ = ["TELEGRAM_AVAILABLE", "TelegramPlatform"]
try:
from telegram.error import NetworkError, RetryAfter, TelegramError
diff --git a/messaging/telegram_markdown.py b/messaging/telegram_markdown.py
index b7911bf9..e74f0db5 100644
--- a/messaging/telegram_markdown.py
+++ b/messaging/telegram_markdown.py
@@ -4,9 +4,9 @@ from .rendering.telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
escape_md_v2_link_url,
+ format_status,
mdv2_bold,
mdv2_code_inline,
- format_status,
render_markdown_to_mdv2,
)
@@ -14,8 +14,8 @@ __all__ = [
"escape_md_v2",
"escape_md_v2_code",
"escape_md_v2_link_url",
+ "format_status",
"mdv2_bold",
"mdv2_code_inline",
- "format_status",
"render_markdown_to_mdv2",
]
diff --git a/messaging/transcript.py b/messaging/transcript.py
index e69c76e5..c85a43f6 100644
--- a/messaging/transcript.py
+++ b/messaging/transcript.py
@@ -11,8 +11,10 @@ from __future__ import annotations
import json
import os
from collections import deque
+from collections.abc import Callable, Iterable
from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, Iterable, List, Optional
+from typing import Any
+
from loguru import logger
@@ -27,7 +29,7 @@ def _safe_json_dumps(obj: Any) -> str:
class Segment:
kind: str
- def render(self, ctx: "RenderCtx") -> str:
+ def render(self, ctx: RenderCtx) -> str:
raise NotImplementedError
@@ -35,7 +37,7 @@ class Segment:
class ThinkingSegment(Segment):
def __init__(self) -> None:
super().__init__(kind="thinking")
- self._parts: List[str] = []
+ self._parts: list[str] = []
def append(self, t: str) -> None:
if t:
@@ -45,7 +47,7 @@ class ThinkingSegment(Segment):
def text(self) -> str:
return "".join(self._parts)
- def render(self, ctx: "RenderCtx") -> str:
+ def render(self, ctx: RenderCtx) -> str:
raw = self.text or ""
if ctx.thinking_tail_max is not None and len(raw) > ctx.thinking_tail_max:
raw = "..." + raw[-(ctx.thinking_tail_max - 3) :]
@@ -57,7 +59,7 @@ class ThinkingSegment(Segment):
class TextSegment(Segment):
def __init__(self) -> None:
super().__init__(kind="text")
- self._parts: List[str] = []
+ self._parts: list[str] = []
def append(self, t: str) -> None:
if t:
@@ -67,7 +69,7 @@ class TextSegment(Segment):
def text(self) -> str:
return "".join(self._parts)
- def render(self, ctx: "RenderCtx") -> str:
+ def render(self, ctx: RenderCtx) -> str:
raw = self.text or ""
if ctx.text_tail_max is not None and len(raw) > ctx.text_tail_max:
raw = "..." + raw[-(ctx.text_tail_max - 3) :]
@@ -86,7 +88,7 @@ class ToolCallSegment(Segment):
self.tool_use_id = str(tool_use_id or "")
self.name = str(name or "tool")
self.indent_level = max(0, int(indent_level))
- self._parts: List[str] = []
+ self._parts: list[str] = []
def set_initial_input(self, inp: Any) -> None:
if inp is None:
@@ -104,7 +106,7 @@ class ToolCallSegment(Segment):
def input_text(self) -> str:
return "".join(self._parts)
- def render(self, ctx: "RenderCtx") -> str:
+ def render(self, ctx: RenderCtx) -> str:
name = ctx.code_inline(self.name)
# Per UX requirement: do not display tool args/results, only the tool call.
prefix = " " * self.indent_level
@@ -114,7 +116,7 @@ class ToolCallSegment(Segment):
@dataclass
class ToolResultSegment(Segment):
tool_use_id: str
- name: Optional[str]
+ name: str | None
content_text: str
is_error: bool = False
@@ -123,7 +125,7 @@ class ToolResultSegment(Segment):
tool_use_id: str,
content: Any,
*,
- name: Optional[str] = None,
+ name: str | None = None,
is_error: bool = False,
) -> None:
super().__init__(kind="tool_result")
@@ -135,7 +137,7 @@ class ToolResultSegment(Segment):
else:
self.content_text = _safe_json_dumps(content)
- def render(self, ctx: "RenderCtx") -> str:
+ def render(self, ctx: RenderCtx) -> str:
raw = self.content_text or ""
if ctx.tool_output_tail_max is not None and len(raw) > ctx.tool_output_tail_max:
raw = "..." + raw[-(ctx.tool_output_tail_max - 3) :]
@@ -150,7 +152,7 @@ class SubagentSegment(Segment):
description: str
tool_calls: int = 0
tools_used: set[str] = field(default_factory=set)
- current_tool: Optional[ToolCallSegment] = None
+ current_tool: ToolCallSegment | None = None
def __init__(self, description: str) -> None:
super().__init__(kind="subagent")
@@ -167,10 +169,10 @@ class SubagentSegment(Segment):
self.current_tool = ToolCallSegment(tool_use_id, name, indent_level=1)
return self.current_tool
- def render(self, ctx: "RenderCtx") -> str:
+ def render(self, ctx: RenderCtx) -> str:
inner_prefix = " "
- lines: List[str] = [
+ lines: list[str] = [
f"🤖 {ctx.bold('Subagent:')} {ctx.code_inline(self.description)}"
]
@@ -183,10 +185,7 @@ class SubagentSegment(Segment):
lines.append(rendered)
tools_used = sorted(self.tools_used)
- if tools_used:
- tools_set_raw = "{%s}" % (", ".join(tools_used))
- else:
- tools_set_raw = "{}"
+ tools_set_raw = "{{{}}}".format(", ".join(tools_used)) if tools_used else "{}"
# Keep braces inside a code entity so MarkdownV2 doesn't require escaping them.
lines.append(
@@ -206,7 +205,7 @@ class ErrorSegment(Segment):
super().__init__(kind="error")
self.message = str(message or "Unknown error")
- def render(self, ctx: "RenderCtx") -> str:
+ def render(self, ctx: RenderCtx) -> str:
return f"⚠️ {ctx.bold('Error:')} {ctx.code_inline(self.message)}"
@@ -218,38 +217,38 @@ class RenderCtx:
escape_text: Callable[[str], str]
render_markdown: Callable[[str], str]
- thinking_tail_max: Optional[int] = 1000
- tool_input_tail_max: Optional[int] = 1200
- tool_output_tail_max: Optional[int] = 1600
- text_tail_max: Optional[int] = 2000
+ thinking_tail_max: int | None = 1000
+ tool_input_tail_max: int | None = 1200
+ tool_output_tail_max: int | None = 1600
+ text_tail_max: int | None = 2000
class TranscriptBuffer:
"""Maintains an ordered, truncatable transcript of events."""
def __init__(self, *, show_tool_results: bool = True) -> None:
- self._segments: List[Segment] = []
- self._open_thinking_by_index: Dict[int, ThinkingSegment] = {}
- self._open_text_by_index: Dict[int, TextSegment] = {}
+ self._segments: list[Segment] = []
+ self._open_thinking_by_index: dict[int, ThinkingSegment] = {}
+ self._open_text_by_index: dict[int, TextSegment] = {}
# content_block index -> tool call segment (for streaming tool args)
- self._open_tools_by_index: Dict[int, ToolCallSegment] = {}
+ self._open_tools_by_index: dict[int, ToolCallSegment] = {}
# tool_use_id -> tool name (for tool_result labeling)
- self._tool_name_by_id: Dict[str, str] = {}
+ self._tool_name_by_id: dict[str, str] = {}
self._show_tool_results = bool(show_tool_results)
# subagent context stack. Each entry is the Task tool_use_id we are waiting to close.
- self._subagent_stack: List[str] = []
+ self._subagent_stack: list[str] = []
# Parallel stack of segments for rendering nested subagents.
- self._subagent_segments: List[SubagentSegment] = []
+ self._subagent_segments: list[SubagentSegment] = []
self._debug_subagent_stack = os.getenv("DEBUG_SUBAGENT_STACK") == "1"
def _in_subagent(self) -> bool:
return bool(self._subagent_stack)
- def _subagent_current(self) -> Optional[SubagentSegment]:
+ def _subagent_current(self) -> SubagentSegment | None:
return self._subagent_segments[-1] if self._subagent_segments else None
def _task_heading_from_input(self, inp: Any) -> str:
@@ -353,7 +352,7 @@ class TranscriptBuffer:
self._segments.append(seg)
return seg
- def apply(self, ev: Dict[str, Any]) -> None:
+ def apply(self, ev: dict[str, Any]) -> None:
"""Apply a parsed event to the transcript."""
et = ev.get("type")
@@ -542,10 +541,10 @@ class TranscriptBuffer:
self._segments.append(ErrorSegment(str(ev.get("message", ""))))
return
- def render(self, ctx: RenderCtx, *, limit_chars: int, status: Optional[str]) -> str:
+ def render(self, ctx: RenderCtx, *, limit_chars: int, status: str | None) -> str:
"""Render transcript with truncation (drop oldest segments)."""
# Filter out empty rendered segments.
- rendered: List[str] = []
+ rendered: list[str] = []
for seg in self._segments:
try:
out = seg.render(ctx)
diff --git a/messaging/transcription.py b/messaging/transcription.py
index e42dde41..5ca5c556 100644
--- a/messaging/transcription.py
+++ b/messaging/transcription.py
@@ -4,8 +4,9 @@ Uses local faster-whisper for free, offline transcription.
"""
import os
+from collections.abc import Iterator
from pathlib import Path
-from typing import Any, Iterator, Protocol, cast
+from typing import Any, Protocol, cast
from loguru import logger
@@ -116,10 +117,7 @@ def _transcribe_local(file_path: Path, whisper_model: str, whisper_device: str)
segments, _info = model.transcribe(str(file_path), beam_size=5)
else:
raise
- parts: list[str] = []
- for segment in segments:
- if segment.text:
- parts.append(segment.text)
+ parts = [s.text for s in segments if s.text]
result = " ".join(parts).strip()
logger.debug(f"Local transcription: {len(result)} chars")
return result or "(no speech detected)"
diff --git a/messaging/tree_data.py b/messaging/tree_data.py
index 09a77a3f..396fc80d 100644
--- a/messaging/tree_data.py
+++ b/messaging/tree_data.py
@@ -1,5 +1,5 @@
"""Backward-compatible re-export. Use messaging.trees.data for new code."""
-from .trees.data import MessageTree, MessageNode, MessageState
+from .trees.data import MessageNode, MessageState, MessageTree
-__all__ = ["MessageTree", "MessageNode", "MessageState"]
+__all__ = ["MessageNode", "MessageState", "MessageTree"]
diff --git a/messaging/tree_queue.py b/messaging/tree_queue.py
index a826113b..9bb995df 100644
--- a/messaging/tree_queue.py
+++ b/messaging/tree_queue.py
@@ -1,10 +1,10 @@
"""Backward-compatible re-export. Use messaging.trees.queue_manager for new code."""
from .trees.queue_manager import (
- TreeQueueManager,
- MessageTree,
MessageNode,
MessageState,
+ MessageTree,
+ TreeQueueManager,
)
-__all__ = ["TreeQueueManager", "MessageTree", "MessageNode", "MessageState"]
+__all__ = ["MessageNode", "MessageState", "MessageTree", "TreeQueueManager"]
diff --git a/messaging/trees/__init__.py b/messaging/trees/__init__.py
index 79f23ae7..b3b556eb 100644
--- a/messaging/trees/__init__.py
+++ b/messaging/trees/__init__.py
@@ -1,11 +1,11 @@
"""Message tree data structures and queue management."""
-from .data import MessageTree, MessageNode, MessageState
+from .data import MessageNode, MessageState, MessageTree
from .queue_manager import TreeQueueManager
__all__ = [
- "TreeQueueManager",
- "MessageTree",
"MessageNode",
"MessageState",
+ "MessageTree",
+ "TreeQueueManager",
]
diff --git a/messaging/trees/data.py b/messaging/trees/data.py
index 040b14c4..717d4214 100644
--- a/messaging/trees/data.py
+++ b/messaging/trees/data.py
@@ -6,14 +6,39 @@ Contains MessageState, MessageNode, and MessageTree classes.
import asyncio
from collections import deque
from contextlib import asynccontextmanager
-from enum import Enum
-from datetime import datetime, timezone
-from typing import Dict, Optional, List, Any, cast
from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Any
-from ..models import IncomingMessage
from loguru import logger
+from ..models import IncomingMessage
+
+
+class _SnapshotQueue(asyncio.Queue[str]):
+ """
+ Queue with snapshot/remove helpers.
+
+ Extends asyncio.Queue to expose read-only snapshot and in-place remove
+ without inflating _unfinished_tasks (drain/put would require task_done).
+ """
+
+ _queue: deque # Set by asyncio.Queue.__init__
+
+ def get_snapshot(self) -> list[str]:
+ """Return current queue contents in FIFO order (read-only copy)."""
+ return list(self._queue)
+
+ def remove_if_present(self, item: str) -> bool:
+ """Remove item from queue if present. Returns True if removed."""
+ if item not in self._queue:
+ return False
+ object.__setattr__(
+ self, "_queue", deque(x for x in self._queue if x != item)
+ )
+ return True
+
class MessageState(Enum):
"""State of a message node in the tree."""
@@ -39,12 +64,12 @@ class MessageNode:
incoming: IncomingMessage # The original message
status_message_id: str # Bot's status message ID
state: MessageState = MessageState.PENDING
- parent_id: Optional[str] = None # Parent node ID (None for root)
- session_id: Optional[str] = None # Claude session ID (forked from parent)
- children_ids: List[str] = field(default_factory=list)
- created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
- completed_at: Optional[datetime] = None
- error_message: Optional[str] = None
+ parent_id: str | None = None # Parent node ID (None for root)
+ session_id: str | None = None # Claude session ID (forked from parent)
+ children_ids: list[str] = field(default_factory=list)
+ created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+ completed_at: datetime | None = None
+ error_message: str | None = None
context: Any = None # Additional context if needed
def to_dict(self) -> dict:
@@ -73,7 +98,7 @@ class MessageNode:
}
@classmethod
- def from_dict(cls, data: dict) -> "MessageNode":
+ def from_dict(cls, data: dict) -> MessageNode:
"""Create from dictionary (JSON deserialization)."""
incoming_data = data["incoming"]
incoming = IncomingMessage(
@@ -119,19 +144,19 @@ class MessageTree:
root_node: The root message node
"""
self.root_id = root_node.node_id
- self._nodes: Dict[str, MessageNode] = {root_node.node_id: root_node}
- self._status_to_node: Dict[str, str] = {
+ self._nodes: dict[str, MessageNode] = {root_node.node_id: root_node}
+ self._status_to_node: dict[str, str] = {
root_node.status_message_id: root_node.node_id
}
- self._queue: asyncio.Queue[str] = asyncio.Queue()
+ self._queue: _SnapshotQueue = _SnapshotQueue()
self._lock = asyncio.Lock()
self._is_processing = False
- self._current_node_id: Optional[str] = None
- self._current_task: Optional[asyncio.Task] = None
+ self._current_node_id: str | None = None
+ self._current_task: asyncio.Task | None = None
logger.debug(f"Created MessageTree with root {self.root_id}")
- def set_current_task(self, task: Optional[asyncio.Task]) -> None:
+ def set_current_task(self, task: asyncio.Task | None) -> None:
"""Set the current processing task. Caller must hold lock."""
self._current_task = task
@@ -178,7 +203,7 @@ class MessageTree:
logger.debug(f"Added node {node_id} as child of {parent_id}")
return node
- def get_node(self, node_id: str) -> Optional[MessageNode]:
+ def get_node(self, node_id: str) -> MessageNode | None:
"""Get a node by ID (O(1) lookup)."""
return self._nodes.get(node_id)
@@ -186,21 +211,21 @@ class MessageTree:
"""Get the root node."""
return self._nodes[self.root_id]
- def get_children(self, node_id: str) -> List[MessageNode]:
+ def get_children(self, node_id: str) -> list[MessageNode]:
"""Get all child nodes of a given node."""
node = self._nodes.get(node_id)
if not node:
return []
return [self._nodes[cid] for cid in node.children_ids if cid in self._nodes]
- def get_parent(self, node_id: str) -> Optional[MessageNode]:
+ def get_parent(self, node_id: str) -> MessageNode | None:
"""Get the parent node."""
node = self._nodes.get(node_id)
if not node or not node.parent_id:
return None
return self._nodes.get(node.parent_id)
- def get_parent_session_id(self, node_id: str) -> Optional[str]:
+ def get_parent_session_id(self, node_id: str) -> str | None:
"""
Get the parent's session ID for forking.
@@ -213,8 +238,8 @@ class MessageTree:
self,
node_id: str,
state: MessageState,
- session_id: Optional[str] = None,
- error_message: Optional[str] = None,
+ session_id: str | None = None,
+ error_message: str | None = None,
) -> None:
"""Update a node's state."""
async with self._lock:
@@ -229,7 +254,7 @@ class MessageTree:
if error_message:
node.error_message = error_message
if state in (MessageState.COMPLETED, MessageState.ERROR):
- node.completed_at = datetime.now(timezone.utc)
+ node.completed_at = datetime.now(UTC)
logger.debug(f"Node {node_id} state -> {state.value}")
@@ -246,7 +271,7 @@ class MessageTree:
logger.debug(f"Enqueued node {node_id}, position {position}")
return position
- async def dequeue(self) -> Optional[str]:
+ async def dequeue(self) -> str | None:
"""
Get the next node ID from the queue.
@@ -257,7 +282,7 @@ class MessageTree:
except asyncio.QueueEmpty:
return None
- async def get_queue_snapshot(self) -> List[str]:
+ async def get_queue_snapshot(self) -> list[str]:
"""
Get a snapshot of the current queue order.
@@ -265,10 +290,7 @@ class MessageTree:
List of node IDs in FIFO order.
"""
async with self._lock:
- # Read internal deque directly to avoid mutating queue state.
- # Drain/put approach would inflate _unfinished_tasks without task_done().
- queue_deque = cast(deque, getattr(self._queue, "_queue"))
- return list(queue_deque)
+ return self._queue.get_snapshot()
def get_queue_size(self) -> int:
"""Get number of messages waiting in queue."""
@@ -280,17 +302,8 @@ class MessageTree:
Caller must hold the tree lock (e.g. via with_lock).
Returns True if node was removed, False if not in queue.
-
- Note: asyncio.Queue has no built-in remove; we filter via the internal
- deque. O(n) in queue size; acceptable for typical tree queue sizes.
"""
- queue_deque = cast(deque, getattr(self._queue, "_queue"))
- if node_id not in queue_deque:
- return False
- object.__setattr__(
- self._queue, "_queue", deque(x for x in queue_deque if x != node_id)
- )
- return True
+ return self._queue.remove_if_present(node_id)
@asynccontextmanager
async def with_lock(self):
@@ -298,7 +311,7 @@ class MessageTree:
async with self._lock:
yield
- def set_processing_state(self, node_id: Optional[str], is_processing: bool) -> None:
+ def set_processing_state(self, node_id: str | None, is_processing: bool) -> None:
"""Set processing state. Caller must hold lock for consistency with queue operations."""
self._is_processing = is_processing
self._current_node_id = node_id if is_processing else None
@@ -324,12 +337,12 @@ class MessageTree:
def drain_queue_and_mark_cancelled(
self, error_message: str = "Cancelled by user"
- ) -> List["MessageNode"]:
+ ) -> list[MessageNode]:
"""
Drain the queue, mark each node as ERROR, and return affected nodes.
Does not acquire lock; caller must ensure no concurrent queue access.
"""
- nodes: List[MessageNode] = []
+ nodes: list[MessageNode] = []
while True:
try:
node_id = self._queue.get_nowait()
@@ -348,7 +361,7 @@ class MessageTree:
self._current_node_id = None
@property
- def current_node_id(self) -> Optional[str]:
+ def current_node_id(self) -> str | None:
"""Get the ID of the node currently being processed."""
return self._current_node_id
@@ -360,7 +373,7 @@ class MessageTree:
}
@classmethod
- def from_dict(cls, data: dict) -> "MessageTree":
+ def from_dict(cls, data: dict) -> MessageTree:
"""Deserialize tree from dictionary."""
root_id = data["root_id"]
nodes_data = data["nodes"]
@@ -378,7 +391,7 @@ class MessageTree:
return tree
- def all_nodes(self) -> List[MessageNode]:
+ def all_nodes(self) -> list[MessageNode]:
"""Get all nodes in the tree."""
return list(self._nodes.values())
@@ -386,12 +399,12 @@ class MessageTree:
"""Check if a node exists in this tree."""
return node_id in self._nodes
- def find_node_by_status_message(self, status_msg_id: str) -> Optional[MessageNode]:
+ def find_node_by_status_message(self, status_msg_id: str) -> MessageNode | None:
"""Find the node that has this status message ID (O(1) lookup)."""
node_id = self._status_to_node.get(status_msg_id)
return self._nodes.get(node_id) if node_id else None
- def get_descendants(self, node_id: str) -> List[str]:
+ def get_descendants(self, node_id: str) -> list[str]:
"""
Get node_id and all descendant IDs (subtree).
@@ -400,7 +413,7 @@ class MessageTree:
"""
if node_id not in self._nodes:
return []
- result: List[str] = []
+ result: list[str] = []
stack = [node_id]
while stack:
nid = stack.pop()
@@ -410,7 +423,7 @@ class MessageTree:
stack.extend(node.children_ids)
return result
- def remove_branch(self, branch_root_id: str) -> List[MessageNode]:
+ def remove_branch(self, branch_root_id: str) -> list[MessageNode]:
"""
Remove a subtree (branch_root and all descendants) from the tree.
diff --git a/messaging/trees/processor.py b/messaging/trees/processor.py
index 897b3953..2e8cdf8b 100644
--- a/messaging/trees/processor.py
+++ b/messaging/trees/processor.py
@@ -4,11 +4,12 @@ Handles the async processing lifecycle of tree nodes.
"""
import asyncio
-from typing import Callable, Awaitable, Optional
+from collections.abc import Awaitable, Callable
-from .data import MessageTree, MessageNode, MessageState
from loguru import logger
+from .data import MessageNode, MessageState, MessageTree
+
class TreeQueueProcessor:
"""
@@ -19,26 +20,23 @@ class TreeQueueProcessor:
def __init__(
self,
- queue_update_callback: Optional[
- Callable[[MessageTree], Awaitable[None]]
- ] = None,
- node_started_callback: Optional[
- Callable[[MessageTree, str], Awaitable[None]]
- ] = None,
+ queue_update_callback: Callable[[MessageTree], Awaitable[None]] | None = None,
+ node_started_callback: Callable[[MessageTree, str], Awaitable[None]]
+ | None = None,
):
self._queue_update_callback = queue_update_callback
self._node_started_callback = node_started_callback
def set_queue_update_callback(
self,
- queue_update_callback: Optional[Callable[[MessageTree], Awaitable[None]]],
+ queue_update_callback: Callable[[MessageTree], Awaitable[None]] | None,
) -> None:
"""Update the callback used to refresh queue positions."""
self._queue_update_callback = queue_update_callback
def set_node_started_callback(
self,
- node_started_callback: Optional[Callable[[MessageTree, str], Awaitable[None]]],
+ node_started_callback: Callable[[MessageTree, str], Awaitable[None]] | None,
) -> None:
"""Update the callback used when a queued node starts processing."""
self._node_started_callback = node_started_callback
diff --git a/messaging/trees/queue_manager.py b/messaging/trees/queue_manager.py
index a410f190..801f5cef 100644
--- a/messaging/trees/queue_manager.py
+++ b/messaging/trees/queue_manager.py
@@ -5,21 +5,22 @@ Uses TreeRepository for data, TreeQueueProcessor for async logic.
"""
import asyncio
-from datetime import datetime, timezone
-from typing import Callable, Awaitable, List, Optional
+from collections.abc import Awaitable, Callable
+from datetime import UTC, datetime
+
+from loguru import logger
from ..models import IncomingMessage
-from .data import MessageState, MessageNode, MessageTree
-from .repository import TreeRepository
+from .data import MessageNode, MessageState, MessageTree
from .processor import TreeQueueProcessor
-from loguru import logger
+from .repository import TreeRepository
# Backward compatibility: re-export moved classes
__all__ = [
- "TreeQueueManager",
- "MessageState",
"MessageNode",
+ "MessageState",
"MessageTree",
+ "TreeQueueManager",
]
@@ -37,12 +38,9 @@ class TreeQueueManager:
def __init__(
self,
- queue_update_callback: Optional[
- Callable[[MessageTree], Awaitable[None]]
- ] = None,
- node_started_callback: Optional[
- Callable[[MessageTree, str], Awaitable[None]]
- ] = None,
+ queue_update_callback: Callable[[MessageTree], Awaitable[None]] | None = None,
+ node_started_callback: Callable[[MessageTree, str], Awaitable[None]]
+ | None = None,
):
self._repository = TreeRepository()
self._processor = TreeQueueProcessor(
@@ -125,19 +123,19 @@ class TreeQueueManager:
logger.info(f"Added node {node_id} to tree {tree.root_id}")
return tree, node
- def get_tree(self, root_id: str) -> Optional[MessageTree]:
+ def get_tree(self, root_id: str) -> MessageTree | None:
"""Get a tree by its root ID."""
return self._repository.get_tree(root_id)
- def get_tree_for_node(self, node_id: str) -> Optional[MessageTree]:
+ def get_tree_for_node(self, node_id: str) -> MessageTree | None:
"""Get the tree containing a given node."""
return self._repository.get_tree_for_node(node_id)
- def get_node(self, node_id: str) -> Optional[MessageNode]:
+ def get_node(self, node_id: str) -> MessageNode | None:
"""Get a node from any tree."""
return self._repository.get_node(node_id)
- def resolve_parent_node_id(self, msg_id: str) -> Optional[str]:
+ def resolve_parent_node_id(self, msg_id: str) -> str | None:
"""Resolve a message ID to the actual parent node ID."""
return self._repository.resolve_parent_node_id(msg_id)
@@ -178,7 +176,7 @@ class TreeQueueManager:
"""Get queue size for the tree containing a node."""
return self._repository.get_queue_size(node_id)
- def get_pending_children(self, node_id: str) -> List[MessageNode]:
+ def get_pending_children(self, node_id: str) -> list[MessageNode]:
"""Get all pending child nodes (recursively) of a given node."""
return self._repository.get_pending_children(node_id)
@@ -187,7 +185,7 @@ class TreeQueueManager:
node_id: str,
error_message: str,
propagate_to_children: bool = True,
- ) -> List[MessageNode]:
+ ) -> list[MessageNode]:
"""
Mark a node as ERROR and optionally propagate to pending children.
@@ -223,7 +221,7 @@ class TreeQueueManager:
return affected
- def cancel_tree(self, root_id: str) -> List[MessageNode]:
+ def cancel_tree(self, root_id: str) -> list[MessageNode]:
"""
Cancel all queued and in-progress messages in a tree.
@@ -276,7 +274,7 @@ class TreeQueueManager:
return cancelled_nodes
- async def cancel_node(self, node_id: str) -> List[MessageNode]:
+ async def cancel_node(self, node_id: str) -> list[MessageNode]:
"""
Cancel a single node (queued or in-progress) without affecting other nodes.
@@ -311,16 +309,16 @@ class TreeQueueManager:
node.state = MessageState.ERROR
node.error_message = "Cancelled by user"
- node.completed_at = datetime.now(timezone.utc)
+ node.completed_at = datetime.now(UTC)
return [node]
- async def cancel_all(self) -> List[MessageNode]:
+ async def cancel_all(self) -> list[MessageNode]:
"""Cancel all messages in all trees (async wrapper)."""
async with self._lock:
return self.cancel_all_sync()
- def cancel_all_sync(self) -> List[MessageNode]:
+ def cancel_all_sync(self) -> list[MessageNode]:
"""
Cancel all messages in all trees (synchronous/locked version).
NOTE: Must be called with self._lock held.
@@ -352,14 +350,14 @@ class TreeQueueManager:
def set_queue_update_callback(
self,
- queue_update_callback: Optional[Callable[[MessageTree], Awaitable[None]]],
+ queue_update_callback: Callable[[MessageTree], Awaitable[None]] | None,
) -> None:
"""Set callback for queue position updates."""
self._processor.set_queue_update_callback(queue_update_callback)
def set_node_started_callback(
self,
- node_started_callback: Optional[Callable[[MessageTree, str], Awaitable[None]]],
+ node_started_callback: Callable[[MessageTree, str], Awaitable[None]] | None,
) -> None:
"""Set callback for when a queued node starts processing."""
self._processor.set_node_started_callback(node_started_callback)
@@ -368,7 +366,7 @@ class TreeQueueManager:
"""Register a node ID to a tree (for external mapping)."""
self._repository.register_node(node_id, root_id)
- async def cancel_branch(self, branch_root_id: str) -> List[MessageNode]:
+ async def cancel_branch(self, branch_root_id: str) -> list[MessageNode]:
"""
Cancel all PENDING/IN_PROGRESS nodes in the subtree (branch_root + descendants).
@@ -379,7 +377,7 @@ class TreeQueueManager:
return []
branch_ids = set(tree.get_descendants(branch_root_id))
- cancelled: List[MessageNode] = []
+ cancelled: list[MessageNode] = []
async with tree.with_lock():
for nid in branch_ids:
@@ -394,13 +392,13 @@ class TreeQueueManager:
self._processor.cancel_current(tree)
node.state = MessageState.ERROR
node.error_message = "Cancelled by user"
- node.completed_at = datetime.now(timezone.utc)
+ node.completed_at = datetime.now(UTC)
cancelled.append(node)
else:
tree.remove_from_queue(nid)
node.state = MessageState.ERROR
node.error_message = "Cancelled by user"
- node.completed_at = datetime.now(timezone.utc)
+ node.completed_at = datetime.now(UTC)
cancelled.append(node)
if cancelled:
@@ -409,7 +407,7 @@ class TreeQueueManager:
async def remove_branch(
self, branch_root_id: str
- ) -> tuple[List[MessageNode], str, bool]:
+ ) -> tuple[list[MessageNode], str, bool]:
"""
Remove a branch (subtree) from the tree.
@@ -445,13 +443,10 @@ class TreeQueueManager:
def from_dict(
cls,
data: dict,
- queue_update_callback: Optional[
- Callable[[MessageTree], Awaitable[None]]
- ] = None,
- node_started_callback: Optional[
- Callable[[MessageTree, str], Awaitable[None]]
- ] = None,
- ) -> "TreeQueueManager":
+ queue_update_callback: Callable[[MessageTree], Awaitable[None]] | None = None,
+ node_started_callback: Callable[[MessageTree, str], Awaitable[None]]
+ | None = None,
+ ) -> TreeQueueManager:
"""Deserialize from dictionary."""
manager = cls(
queue_update_callback=queue_update_callback,
diff --git a/messaging/trees/repository.py b/messaging/trees/repository.py
index 9f44cd76..294ecb24 100644
--- a/messaging/trees/repository.py
+++ b/messaging/trees/repository.py
@@ -3,11 +3,9 @@
Provides data access layer for managing trees and node mappings.
"""
-from typing import Dict, Optional, List
-
from loguru import logger
-from .data import MessageTree, MessageNode, MessageState
+from .data import MessageNode, MessageState, MessageTree
class TreeRepository:
@@ -18,21 +16,21 @@ class TreeRepository:
"""
def __init__(self):
- self._trees: Dict[str, MessageTree] = {} # root_id -> tree
- self._node_to_tree: Dict[str, str] = {} # node_id -> root_id
+ self._trees: dict[str, MessageTree] = {} # root_id -> tree
+ self._node_to_tree: dict[str, str] = {} # node_id -> root_id
- def get_tree(self, root_id: str) -> Optional[MessageTree]:
+ def get_tree(self, root_id: str) -> MessageTree | None:
"""Get a tree by its root ID."""
return self._trees.get(root_id)
- def get_tree_for_node(self, node_id: str) -> Optional[MessageTree]:
+ def get_tree_for_node(self, node_id: str) -> MessageTree | None:
"""Get the tree containing a given node."""
root_id = self._node_to_tree.get(node_id)
if not root_id:
return None
return self._trees.get(root_id)
- def get_node(self, node_id: str) -> Optional[MessageNode]:
+ def get_node(self, node_id: str) -> MessageNode | None:
"""Get a node from any tree."""
tree = self.get_tree_for_node(node_id)
return tree.get_node(node_id) if tree else None
@@ -71,7 +69,7 @@ class TreeRepository:
tree = self.get_tree_for_node(node_id)
return tree.get_queue_size() if tree else 0
- def resolve_parent_node_id(self, msg_id: str) -> Optional[str]:
+ def resolve_parent_node_id(self, msg_id: str) -> str | None:
"""
Resolve a message ID to the actual parent node ID.
@@ -96,7 +94,7 @@ class TreeRepository:
return None
- def get_pending_children(self, node_id: str) -> List[MessageNode]:
+ def get_pending_children(self, node_id: str) -> list[MessageNode]:
"""
Get all pending child nodes (recursively) of a given node.
@@ -121,20 +119,20 @@ class TreeRepository:
return pending
- def all_trees(self) -> List[MessageTree]:
+ def all_trees(self) -> list[MessageTree]:
"""Get all trees in the repository."""
return list(self._trees.values())
- def tree_ids(self) -> List[str]:
+ def tree_ids(self) -> list[str]:
"""Get all tree root IDs."""
return list(self._trees.keys())
- def unregister_nodes(self, node_ids: List[str]) -> None:
+ def unregister_nodes(self, node_ids: list[str]) -> None:
"""Remove node IDs from the node-to-tree mapping."""
for nid in node_ids:
self._node_to_tree.pop(nid, None)
- def remove_tree(self, root_id: str) -> Optional[MessageTree]:
+ def remove_tree(self, root_id: str) -> MessageTree | None:
"""
Remove a tree and all its node mappings from the repository.
@@ -157,7 +155,7 @@ class TreeRepository:
}
@classmethod
- def from_dict(cls, data: dict) -> "TreeRepository":
+ def from_dict(cls, data: dict) -> TreeRepository:
"""Deserialize from dictionary."""
from .data import MessageTree
diff --git a/providers/__init__.py b/providers/__init__.py
index 987589d2..3fdb0329 100644
--- a/providers/__init__.py
+++ b/providers/__init__.py
@@ -1,28 +1,28 @@
"""Providers package - implement your own provider by extending BaseProvider."""
from .base import BaseProvider, ProviderConfig
-from .lmstudio import LMStudioProvider
-from .nvidia_nim import NvidiaNimProvider
-from .open_router import OpenRouterProvider
from .exceptions import (
- ProviderError,
+ APIError,
AuthenticationError,
InvalidRequestError,
- RateLimitError,
OverloadedError,
- APIError,
+ ProviderError,
+ RateLimitError,
)
+from .lmstudio import LMStudioProvider
+from .nvidia_nim import NvidiaNimProvider
+from .open_router import OpenRouterProvider
__all__ = [
+ "APIError",
+ "AuthenticationError",
"BaseProvider",
- "ProviderConfig",
+ "InvalidRequestError",
"LMStudioProvider",
"NvidiaNimProvider",
"OpenRouterProvider",
+ "OverloadedError",
+ "ProviderConfig",
"ProviderError",
- "AuthenticationError",
- "InvalidRequestError",
"RateLimitError",
- "OverloadedError",
- "APIError",
]
diff --git a/providers/base.py b/providers/base.py
index 58625df6..ca4921fe 100644
--- a/providers/base.py
+++ b/providers/base.py
@@ -1,7 +1,8 @@
"""Base provider interface - extend this to implement your own provider."""
from abc import ABC, abstractmethod
-from typing import Any, AsyncIterator, Optional
+from collections.abc import AsyncIterator
+from typing import Any
from pydantic import BaseModel
@@ -14,8 +15,8 @@ class ProviderConfig(BaseModel):
"""
api_key: str
- base_url: Optional[str] = None
- rate_limit: Optional[int] = None
+ base_url: str | None = None
+ rate_limit: int | None = None
rate_window: int = 60
http_read_timeout: float = 300.0
http_write_timeout: float = 10.0
diff --git a/providers/common/__init__.py b/providers/common/__init__.py
index eb4adfcd..77dbc059 100644
--- a/providers/common/__init__.py
+++ b/providers/common/__init__.py
@@ -1,25 +1,25 @@
"""Shared provider utilities used by NIM, OpenRouter, and LM Studio."""
-from .sse_builder import SSEBuilder, ContentBlockManager, map_stop_reason
-from .think_parser import ThinkTagParser, ContentType, ContentChunk
+from .error_mapping import map_error
from .heuristic_tool_parser import HeuristicToolParser
from .message_converter import (
AnthropicToOpenAIConverter,
get_block_attr,
get_block_type,
)
-from .error_mapping import map_error
+from .sse_builder import ContentBlockManager, SSEBuilder, map_stop_reason
+from .think_parser import ContentChunk, ContentType, ThinkTagParser
__all__ = [
- "SSEBuilder",
+ "AnthropicToOpenAIConverter",
"ContentBlockManager",
- "map_stop_reason",
- "ThinkTagParser",
- "ContentType",
"ContentChunk",
+ "ContentType",
"HeuristicToolParser",
- "AnthropicToOpenAIConverter",
+ "SSEBuilder",
+ "ThinkTagParser",
"get_block_attr",
"get_block_type",
"map_error",
+ "map_stop_reason",
]
diff --git a/providers/common/error_mapping.py b/providers/common/error_mapping.py
index 9fc1a89a..b6a67dae 100644
--- a/providers/common/error_mapping.py
+++ b/providers/common/error_mapping.py
@@ -3,11 +3,11 @@
import openai
from providers.exceptions import (
+ APIError,
AuthenticationError,
InvalidRequestError,
- RateLimitError,
OverloadedError,
- APIError,
+ RateLimitError,
)
from providers.rate_limit import GlobalRateLimiter
diff --git a/providers/common/heuristic_tool_parser.py b/providers/common/heuristic_tool_parser.py
index 1028e44b..430ee632 100644
--- a/providers/common/heuristic_tool_parser.py
+++ b/providers/common/heuristic_tool_parser.py
@@ -1,9 +1,9 @@
import re
import uuid
from enum import Enum
-from typing import List, Dict, Any, Tuple
-from loguru import logger
+from typing import Any
+from loguru import logger
# Some OpenAI-compatible backends/models occasionally leak internal sentinel tokens
# into `delta.content` (e.g. "<|tool_call_end|>"). These should never be shown to
@@ -64,7 +64,7 @@ class HeuristicToolParser:
self.buffer = self.buffer[start:]
return prefix
- def feed(self, text: str) -> Tuple[str, List[Dict[str, Any]]]:
+ def feed(self, text: str) -> tuple[str, list[dict[str, Any]]]:
"""
Feed text into the parser.
Returns a tuple of (filtered_text, detected_tool_calls).
@@ -201,7 +201,7 @@ class HeuristicToolParser:
return filtered_output, detected_tools
- def flush(self) -> List[Dict[str, Any]]:
+ def flush(self) -> list[dict[str, Any]]:
"""
Flush any remaining tool calls in the buffer.
"""
diff --git a/providers/common/message_converter.py b/providers/common/message_converter.py
index bcd7ecf1..6b249a43 100644
--- a/providers/common/message_converter.py
+++ b/providers/common/message_converter.py
@@ -1,7 +1,7 @@
"""Message and tool format converters."""
import json
-from typing import Any, Dict, List, Optional
+from typing import Any
def get_block_attr(block: Any, attr: str, default: Any = None) -> Any:
@@ -13,7 +13,7 @@ def get_block_attr(block: Any, attr: str, default: Any = None) -> Any:
return default
-def get_block_type(block: Any) -> Optional[str]:
+def get_block_type(block: Any) -> str | None:
"""Get block type from object or dict."""
return get_block_attr(block, "type")
@@ -23,10 +23,10 @@ class AnthropicToOpenAIConverter:
@staticmethod
def convert_messages(
- messages: List[Any],
+ messages: list[Any],
*,
include_reasoning_for_openrouter: bool = False,
- ) -> List[Dict[str, Any]]:
+ ) -> list[dict[str, Any]]:
"""Convert a list of Anthropic messages to OpenAI format.
When include_reasoning_for_openrouter is True, assistant messages with
@@ -60,14 +60,14 @@ class AnthropicToOpenAIConverter:
@staticmethod
def _convert_assistant_message(
- content: List[Any],
+ content: list[Any],
*,
include_reasoning_for_openrouter: bool = False,
- ) -> List[Dict[str, Any]]:
+ ) -> list[dict[str, Any]]:
"""Convert assistant message blocks, preserving interleaved thinking+text order."""
- content_parts: List[str] = []
- thinking_parts: List[str] = []
- tool_calls: List[Dict[str, Any]] = []
+ content_parts: list[str] = []
+ thinking_parts: list[str] = []
+ tool_calls: list[dict[str, Any]] = []
for block in content:
block_type = get_block_type(block)
@@ -101,7 +101,7 @@ class AnthropicToOpenAIConverter:
if not content_str and not tool_calls:
content_str = " "
- msg: Dict[str, Any] = {
+ msg: dict[str, Any] = {
"role": "assistant",
"content": content_str,
}
@@ -113,10 +113,10 @@ class AnthropicToOpenAIConverter:
return [msg]
@staticmethod
- def _convert_user_message(content: List[Any]) -> List[Dict[str, Any]]:
+ def _convert_user_message(content: list[Any]) -> list[dict[str, Any]]:
"""Convert user message blocks (including tool results), preserving order."""
- result: List[Dict[str, Any]] = []
- text_parts: List[str] = []
+ result: list[dict[str, Any]] = []
+ text_parts: list[str] = []
def flush_text() -> None:
if text_parts:
@@ -150,7 +150,7 @@ class AnthropicToOpenAIConverter:
return result
@staticmethod
- def convert_tools(tools: List[Any]) -> List[Dict[str, Any]]:
+ def convert_tools(tools: list[Any]) -> list[dict[str, Any]]:
"""Convert Anthropic tools to OpenAI format."""
return [
{
@@ -165,15 +165,16 @@ class AnthropicToOpenAIConverter:
]
@staticmethod
- def convert_system_prompt(system: Any) -> Optional[Dict[str, str]]:
+ def convert_system_prompt(system: Any) -> dict[str, str] | None:
"""Convert Anthropic system prompt to OpenAI format."""
if isinstance(system, str):
return {"role": "system", "content": system}
elif isinstance(system, list):
- text_parts = []
- for block in system:
- if get_block_type(block) == "text":
- text_parts.append(get_block_attr(block, "text", ""))
+ text_parts = [
+ get_block_attr(block, "text", "")
+ for block in system
+ if get_block_type(block) == "text"
+ ]
if text_parts:
return {"role": "system", "content": "\n\n".join(text_parts).strip()}
return None
diff --git a/providers/common/sse_builder.py b/providers/common/sse_builder.py
index 80bebbb2..d446303f 100644
--- a/providers/common/sse_builder.py
+++ b/providers/common/sse_builder.py
@@ -1,8 +1,9 @@
"""SSE event builder for Anthropic-format streaming responses."""
import json
+from collections.abc import Iterator
from dataclasses import dataclass, field
-from typing import Optional, Dict, Any, Iterator, List, Tuple
+from typing import Any
from loguru import logger
@@ -23,7 +24,7 @@ STOP_REASON_MAP = {
}
-def map_stop_reason(openai_reason: Optional[str]) -> str:
+def map_stop_reason(openai_reason: str | None) -> str:
"""Map OpenAI finish_reason to Anthropic stop_reason."""
return (
STOP_REASON_MAP.get(openai_reason, "end_turn") if openai_reason else "end_turn"
@@ -39,14 +40,14 @@ class ContentBlockManager:
text_index: int = -1
thinking_started: bool = False
text_started: bool = False
- tool_indices: Dict[int, int] = field(default_factory=dict)
- tool_contents: Dict[int, str] = field(default_factory=dict)
- tool_names: Dict[int, str] = field(default_factory=dict)
- tool_ids: Dict[int, str] = field(default_factory=dict)
- tool_started: Dict[int, bool] = field(default_factory=dict)
+ tool_indices: dict[int, int] = field(default_factory=dict)
+ tool_contents: dict[int, str] = field(default_factory=dict)
+ tool_names: dict[int, str] = field(default_factory=dict)
+ tool_ids: dict[int, str] = field(default_factory=dict)
+ tool_started: dict[int, bool] = field(default_factory=dict)
# Buffer streaming args for tools where we don't want to emit partial deltas.
- task_arg_buffer: Dict[int, str] = field(default_factory=dict)
- task_args_emitted: Dict[int, bool] = field(default_factory=dict)
+ task_arg_buffer: dict[int, str] = field(default_factory=dict)
+ task_args_emitted: dict[int, bool] = field(default_factory=dict)
def allocate_index(self) -> int:
"""Allocate and return the next block index."""
@@ -72,7 +73,7 @@ class ContentBlockManager:
else:
self.tool_names[index] = prev + name
- def buffer_task_args(self, index: int, args: str) -> Optional[dict]:
+ def buffer_task_args(self, index: int, args: str) -> dict | None:
"""Buffer Task tool args and return parsed JSON when complete.
Returns the parsed (and patched) args dict once the buffer forms
@@ -95,9 +96,9 @@ class ContentBlockManager:
self.task_arg_buffer.pop(index, None)
return args_json
- def flush_task_arg_buffers(self) -> List[Tuple[int, str]]:
+ def flush_task_arg_buffers(self) -> list[tuple[int, str]]:
"""Flush any remaining Task arg buffers. Returns (tool_index, json_str) pairs."""
- results: List[Tuple[int, str]] = []
+ results: list[tuple[int, str]] = []
for tool_index, buf in list(self.task_arg_buffer.items()):
if self.task_args_emitted.get(tool_index, False):
self.task_arg_buffer.pop(tool_index, None)
@@ -136,7 +137,7 @@ class SSEBuilder:
self._accumulated_text = ""
self._accumulated_reasoning = ""
- def _format_event(self, event_type: str, data: Dict[str, Any]) -> str:
+ def _format_event(self, event_type: str, data: dict[str, Any]) -> str:
"""Format as SSE string."""
event_str = f"event: {event_type}\ndata: {json.dumps(data)}\n\n"
logger.debug(f"SSE_EVENT: {event_type} - {event_str.strip()}")
@@ -184,7 +185,7 @@ class SSEBuilder:
# Content block events
def content_block_start(self, index: int, block_type: str, **kwargs) -> str:
"""Generate content_block_start event."""
- content_block: Dict[str, Any] = {"type": block_type}
+ content_block: dict[str, Any] = {"type": block_type}
if block_type == "thinking":
content_block["thinking"] = kwargs.get("thinking", "")
elif block_type == "text":
@@ -205,7 +206,7 @@ class SSEBuilder:
def content_block_delta(self, index: int, delta_type: str, content: str) -> str:
"""Generate content_block_delta event."""
- delta: Dict[str, Any] = {"type": delta_type}
+ delta: dict[str, Any] = {"type": delta_type}
if delta_type == "thinking_delta":
delta["thinking"] = content
elif delta_type == "text_delta":
diff --git a/providers/common/think_parser.py b/providers/common/think_parser.py
index 923ad7db..8e0dee89 100644
--- a/providers/common/think_parser.py
+++ b/providers/common/think_parser.py
@@ -1,7 +1,7 @@
"""Think tag parser for extracting reasoning content from responses."""
+from collections.abc import Iterator
from dataclasses import dataclass
-from typing import Optional, Iterator
from enum import Enum
@@ -63,7 +63,7 @@ class ThinkTagParser:
else:
break
- def _parse_outside_think(self) -> Optional[ContentChunk]:
+ def _parse_outside_think(self) -> ContentChunk | None:
"""Parse content outside think tags."""
think_start = self._buffer.find(self.OPEN_TAG)
orphan_close = self._buffer.find(self.CLOSE_TAG)
@@ -115,7 +115,7 @@ class ThinkTagParser:
# Continue parsing inside think tag
return self._parse_inside_think()
- def _parse_inside_think(self) -> Optional[ContentChunk]:
+ def _parse_inside_think(self) -> ContentChunk | None:
"""Parse content inside think tags."""
think_end = self._buffer.find(self.CLOSE_TAG)
@@ -150,7 +150,7 @@ class ThinkTagParser:
# Continue parsing outside think tag
return self._parse_outside_think()
- def flush(self) -> Optional[ContentChunk]:
+ def flush(self) -> ContentChunk | None:
"""Flush any remaining buffered content."""
if self._buffer:
chunk_type = (
diff --git a/providers/lmstudio/client.py b/providers/lmstudio/client.py
index 67ee31ce..e7e74f32 100644
--- a/providers/lmstudio/client.py
+++ b/providers/lmstudio/client.py
@@ -2,12 +2,11 @@
from typing import Any
-from providers.openai_compat import OpenAICompatibleProvider
from providers.base import ProviderConfig
+from providers.openai_compat import OpenAICompatibleProvider
from .request import build_request_body
-
LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1"
diff --git a/providers/lmstudio/request.py b/providers/lmstudio/request.py
index dd87e3a8..8abf67f1 100644
--- a/providers/lmstudio/request.py
+++ b/providers/lmstudio/request.py
@@ -1,15 +1,15 @@
"""Request builder for LM Studio provider."""
-from typing import Any, Dict
+from typing import Any
-from providers.common.message_converter import AnthropicToOpenAIConverter
from loguru import logger
+from providers.common.message_converter import AnthropicToOpenAIConverter
LMSTUDIO_DEFAULT_MAX_TOKENS = 81920
-def _set_if_not_none(body: Dict[str, Any], key: str, value: Any) -> None:
+def _set_if_not_none(body: dict[str, Any], key: str, value: Any) -> None:
if value is not None:
body[key] = value
@@ -32,7 +32,7 @@ def build_request_body(request_data: Any) -> dict:
if system_msg:
messages.insert(0, system_msg)
- body: Dict[str, Any] = {
+ body: dict[str, Any] = {
"model": request_data.model,
"messages": messages,
}
diff --git a/providers/logging_utils.py b/providers/logging_utils.py
index aebd28a7..84dd5cb7 100644
--- a/providers/logging_utils.py
+++ b/providers/logging_utils.py
@@ -6,13 +6,14 @@ while maintaining full traceability through request IDs and content hashes.
import hashlib
import json
-from typing import Any, Dict, List
+from typing import Any
-from utils.text import extract_text_from_content
from loguru import logger
+from utils.text import extract_text_from_content
+
-def generate_request_fingerprint(messages: List[Any]) -> str:
+def generate_request_fingerprint(messages: list[Any]) -> str:
"""Generate unique short hash for message content.
Creates a SHA256 hash of all message content, returning an 8-char prefix
@@ -38,7 +39,7 @@ def generate_request_fingerprint(messages: List[Any]) -> str:
return f"fp_{hash_digest[:8]}"
-def get_last_user_message_preview(messages: List[Any], max_len: int = 100) -> str:
+def get_last_user_message_preview(messages: list[Any], max_len: int = 100) -> str:
"""Extract a preview of the last user message."""
for msg in reversed(messages):
if hasattr(msg, "role") and msg.role == "user":
@@ -49,7 +50,7 @@ def get_last_user_message_preview(messages: List[Any], max_len: int = 100) -> st
return "(no user message)"
-def get_tool_names(tools: List[Any] | None, max_count: int = 5) -> List[str]:
+def get_tool_names(tools: list[Any] | None, max_count: int = 5) -> list[str]:
"""Extract tool names from tool list, limiting to max_count."""
if not tools:
return []
@@ -64,7 +65,7 @@ def get_tool_names(tools: List[Any] | None, max_count: int = 5) -> List[str]:
return names
-def build_request_summary(request_data: Any) -> Dict[str, Any]:
+def build_request_summary(request_data: Any) -> dict[str, Any]:
"""Build compact metadata dict for logging.
Returns a dictionary with key metrics about the request without
@@ -97,7 +98,7 @@ def build_request_summary(request_data: Any) -> Dict[str, Any]:
def log_full_payload(
- logger_instance: Any, request_id: str, payload: Dict[str, Any]
+ logger_instance: Any, request_id: str, payload: dict[str, Any]
) -> None:
"""Log full payload to the standard logger."""
logger_instance.debug(
diff --git a/providers/model_utils.py b/providers/model_utils.py
index 3339ff7d..b2a9bf56 100644
--- a/providers/model_utils.py
+++ b/providers/model_utils.py
@@ -4,7 +4,6 @@ Centralizes model name mapping logic to avoid duplication across the codebase.
"""
import os
-from typing import Optional
# Provider prefixes to strip from model names
_PROVIDER_PREFIXES = ["anthropic/", "openai/", "gemini/"]
@@ -43,7 +42,7 @@ def is_claude_model(model: str) -> bool:
return any(name in model_lower for name in _CLAUDE_IDENTIFIERS)
-def normalize_model_name(model: str, default_model: Optional[str] = None) -> str:
+def normalize_model_name(model: str, default_model: str | None = None) -> str:
"""
Normalize a model name by stripping prefixes and mapping to default if needed.
diff --git a/providers/nvidia_nim/client.py b/providers/nvidia_nim/client.py
index 4acdf201..714c438a 100644
--- a/providers/nvidia_nim/client.py
+++ b/providers/nvidia_nim/client.py
@@ -3,8 +3,8 @@
from typing import Any
from config.nim import NimSettings
-from providers.openai_compat import OpenAICompatibleProvider
from providers.base import ProviderConfig
+from providers.openai_compat import OpenAICompatibleProvider
from .request import build_request_body
diff --git a/providers/nvidia_nim/request.py b/providers/nvidia_nim/request.py
index dac44a1c..b25f8637 100644
--- a/providers/nvidia_nim/request.py
+++ b/providers/nvidia_nim/request.py
@@ -1,19 +1,20 @@
"""Request builder for NVIDIA NIM provider."""
-from typing import Any, Dict
+from typing import Any
+
+from loguru import logger
from config.nim import NimSettings
from providers.common.message_converter import AnthropicToOpenAIConverter
-from loguru import logger
-def _set_if_not_none(body: Dict[str, Any], key: str, value: Any) -> None:
+def _set_if_not_none(body: dict[str, Any], key: str, value: Any) -> None:
if value is not None:
body[key] = value
def _set_extra(
- extra_body: Dict[str, Any], key: str, value: Any, ignore_value: Any = None
+ extra_body: dict[str, Any], key: str, value: Any, ignore_value: Any = None
) -> None:
if key in extra_body:
return
@@ -40,7 +41,7 @@ def build_request_body(request_data: Any, nim: NimSettings) -> dict:
if system_msg:
messages.insert(0, system_msg)
- body: Dict[str, Any] = {
+ body: dict[str, Any] = {
"model": request_data.model,
"messages": messages,
}
@@ -84,7 +85,7 @@ def build_request_body(request_data: Any, nim: NimSettings) -> dict:
body["parallel_tool_calls"] = nim.parallel_tool_calls
# Handle non-standard parameters via extra_body
- extra_body: Dict[str, Any] = {}
+ extra_body: dict[str, Any] = {}
request_extra = getattr(request_data, "extra_body", None)
if request_extra:
extra_body.update(request_extra)
diff --git a/providers/nvidia_nim/utils/__init__.py b/providers/nvidia_nim/utils/__init__.py
index 295c90c9..bbca7f40 100644
--- a/providers/nvidia_nim/utils/__init__.py
+++ b/providers/nvidia_nim/utils/__init__.py
@@ -1,27 +1,27 @@
"""Utility modules for providers (re-exports from providers.common)."""
from providers.common import (
- SSEBuilder,
+ AnthropicToOpenAIConverter,
ContentBlockManager,
- map_stop_reason,
- ThinkTagParser,
- ContentType,
ContentChunk,
+ ContentType,
HeuristicToolParser,
- AnthropicToOpenAIConverter,
+ SSEBuilder,
+ ThinkTagParser,
get_block_attr,
get_block_type,
+ map_stop_reason,
)
__all__ = [
- "SSEBuilder",
+ "AnthropicToOpenAIConverter",
"ContentBlockManager",
- "map_stop_reason",
- "ThinkTagParser",
- "HeuristicToolParser",
- "ContentType",
"ContentChunk",
- "AnthropicToOpenAIConverter",
+ "ContentType",
+ "HeuristicToolParser",
+ "SSEBuilder",
+ "ThinkTagParser",
"get_block_attr",
"get_block_type",
+ "map_stop_reason",
]
diff --git a/providers/open_router/client.py b/providers/open_router/client.py
index 79a126b6..a55d18a6 100644
--- a/providers/open_router/client.py
+++ b/providers/open_router/client.py
@@ -1,14 +1,14 @@
"""OpenRouter provider implementation."""
-from typing import Any, Iterator
+from collections.abc import Iterator
+from typing import Any
-from providers.openai_compat import OpenAICompatibleProvider
from providers.base import ProviderConfig
from providers.common import SSEBuilder
+from providers.openai_compat import OpenAICompatibleProvider
from .request import build_request_body
-
OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
@@ -34,6 +34,5 @@ class OpenRouterProvider(OpenAICompatibleProvider):
for item in reasoning_details:
text = item.get("text", "") if isinstance(item, dict) else ""
if text:
- for event in sse.ensure_thinking_block():
- yield event
+ yield from sse.ensure_thinking_block()
yield sse.emit_thinking_delta(text)
diff --git a/providers/open_router/request.py b/providers/open_router/request.py
index 3af8763a..b231272e 100644
--- a/providers/open_router/request.py
+++ b/providers/open_router/request.py
@@ -1,15 +1,15 @@
"""Request builder for OpenRouter provider."""
-from typing import Any, Dict
+from typing import Any
-from providers.common.message_converter import AnthropicToOpenAIConverter
from loguru import logger
+from providers.common.message_converter import AnthropicToOpenAIConverter
OPENROUTER_DEFAULT_MAX_TOKENS = 81920
-def _set_if_not_none(body: Dict[str, Any], key: str, value: Any) -> None:
+def _set_if_not_none(body: dict[str, Any], key: str, value: Any) -> None:
if value is not None:
body[key] = value
@@ -32,7 +32,7 @@ def build_request_body(request_data: Any) -> dict:
if system_msg:
messages.insert(0, system_msg)
- body: Dict[str, Any] = {
+ body: dict[str, Any] = {
"model": request_data.model,
"messages": messages,
}
@@ -55,7 +55,7 @@ def build_request_body(request_data: Any) -> dict:
body["tool_choice"] = tool_choice
# OpenRouter reasoning: extra_body={"reasoning": {"enabled": True}}
- extra_body: Dict[str, Any] = {}
+ extra_body: dict[str, Any] = {}
request_extra = getattr(request_data, "extra_body", None)
if request_extra:
extra_body.update(request_extra)
diff --git a/providers/openai_compat.py b/providers/openai_compat.py
index ccc465d6..ffb99cb1 100644
--- a/providers/openai_compat.py
+++ b/providers/openai_compat.py
@@ -2,22 +2,23 @@
import json
import uuid
-from typing import Any, AsyncIterator, Iterator, Optional
+from collections.abc import AsyncIterator, Iterator
+from typing import Any
import httpx
from loguru import logger
from openai import AsyncOpenAI
from providers.base import BaseProvider, ProviderConfig
-from providers.rate_limit import GlobalRateLimiter
from providers.common import (
+ ContentType,
+ HeuristicToolParser,
SSEBuilder,
- map_stop_reason,
ThinkTagParser,
- HeuristicToolParser,
- ContentType,
map_error,
+ map_stop_reason,
)
+from providers.rate_limit import GlobalRateLimiter
class OpenAICompatibleProvider(BaseProvider):
@@ -30,7 +31,7 @@ class OpenAICompatibleProvider(BaseProvider):
provider_name: str,
base_url: str,
api_key: str,
- nim_settings: Optional[Any] = None,
+ nim_settings: Any | None = None,
):
super().__init__(config)
self._provider_name = provider_name
diff --git a/providers/rate_limit.py b/providers/rate_limit.py
index bcef02ba..25b1f720 100644
--- a/providers/rate_limit.py
+++ b/providers/rate_limit.py
@@ -1,10 +1,11 @@
"""Global rate limiter for API requests."""
import asyncio
-from collections import deque
import random
import time
-from typing import Any, Callable, Optional, TypeVar
+from collections import deque
+from collections.abc import Callable
+from typing import Any, TypeVar
import openai
from loguru import logger
@@ -22,7 +23,7 @@ class GlobalRateLimiter:
Reactive limits - pauses all requests when a 429 is hit.
"""
- _instance: Optional["GlobalRateLimiter"] = None
+ _instance: GlobalRateLimiter | None = None
def __init__(self, rate_limit: int = 40, rate_window: float = 60.0):
# Prevent double initialization in singleton
@@ -49,9 +50,9 @@ class GlobalRateLimiter:
@classmethod
def get_instance(
cls,
- rate_limit: Optional[int] = None,
- rate_window: Optional[float] = None,
- ) -> "GlobalRateLimiter":
+ rate_limit: int | None = None,
+ rate_window: float | None = None,
+ ) -> GlobalRateLimiter:
"""Get or create the singleton instance.
Args:
@@ -167,7 +168,7 @@ class GlobalRateLimiter:
Raises:
The last exception if all retries are exhausted.
"""
- last_exc: Optional[Exception] = None
+ last_exc: Exception | None = None
for attempt in range(1 + max_retries):
await self.wait_if_blocked()
diff --git a/pyproject.toml b/pyproject.toml
index 55265966..cf781c5b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -49,7 +49,9 @@ select = [
"RUF", # Ruff-specific rules
]
ignore = [
- "E501", # line too long — enforced by the formatter instead
+ "E501", # line too long — enforced by the formatter instead
+ "B008", # FastAPI Depends() in argument defaults is intentional
+ "RUF006", # fire-and-forget tasks intentionally not awaited
]
[tool.ruff.lint.isort]
diff --git a/server.py b/server.py
index 68e1f3c8..b025be00 100644
--- a/server.py
+++ b/server.py
@@ -11,8 +11,9 @@ __all__ = ["app", "create_app"]
if __name__ == "__main__":
import uvicorn
- from config.settings import get_settings
+
from cli.process_registry import kill_all_best_effort
+ from config.settings import get_settings
settings = get_settings()
try:
diff --git a/tests/api/test_api.py b/tests/api/test_api.py
index 8c845374..35c5ae47 100644
--- a/tests/api/test_api.py
+++ b/tests/api/test_api.py
@@ -1,7 +1,9 @@
+from unittest.mock import MagicMock
+
from fastapi.testclient import TestClient
+
from api.app import app
from api.dependencies import get_provider
-from unittest.mock import MagicMock
from providers.nvidia_nim import NvidiaNimProvider
# Mock provider
@@ -75,8 +77,8 @@ def test_model_mapping():
def test_error_fallbacks():
from providers.exceptions import (
AuthenticationError,
- RateLimitError,
OverloadedError,
+ RateLimitError,
)
base_payload = {"model": "test", "messages": [], "max_tokens": 10, "stream": True}
diff --git a/tests/api/test_app_lifespan_and_errors.py b/tests/api/test_app_lifespan_and_errors.py
index 9019c759..64a4af77 100644
--- a/tests/api/test_app_lifespan_and_errors.py
+++ b/tests/api/test_app_lifespan_and_errors.py
@@ -1,7 +1,7 @@
+import importlib
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
-import importlib
import pytest
from fastapi.testclient import TestClient
@@ -36,10 +36,10 @@ def test_create_app_provider_error_handler_returns_anthropic_format():
):
with TestClient(app) as client:
resp = client.get("/raise_provider")
- assert resp.status_code == 401
- body = resp.json()
- assert body["type"] == "error"
- assert body["error"]["type"] == "authentication_error"
+ assert resp.status_code == 401
+ body = resp.json()
+ assert body["type"] == "error"
+ assert body["error"]["type"] == "authentication_error"
def test_create_app_general_exception_handler_returns_500():
@@ -71,10 +71,10 @@ def test_create_app_general_exception_handler_returns_500():
):
with TestClient(app, raise_server_exceptions=False) as client:
resp = client.get("/raise_general")
- assert resp.status_code == 500
- body = resp.json()
- assert body["type"] == "error"
- assert body["error"]["type"] == "api_error"
+ assert resp.status_code == 500
+ body = resp.json()
+ assert body["type"] == "error"
+ assert body["error"]["type"] == "api_error"
@pytest.mark.parametrize(
@@ -135,9 +135,9 @@ def test_app_lifespan_sets_state_and_cleans_up(tmp_path, messaging_enabled):
patch(
"messaging.tree_queue.TreeQueueManager.from_dict", return_value=fake_queue
),
+ TestClient(app),
):
- with TestClient(app):
- pass
+ pass
if messaging_enabled:
create_platform.assert_called_once()
@@ -203,9 +203,9 @@ def test_app_lifespan_cleanup_continues_if_platform_stop_raises(tmp_path):
),
patch("messaging.session.SessionStore", return_value=session_store),
patch("cli.manager.CLISessionManager", return_value=cli_manager),
+ TestClient(app),
):
- with TestClient(app):
- pass
+ pass
fake_platform.stop.assert_awaited_once()
cli_manager.stop_all.assert_awaited_once()
@@ -241,9 +241,9 @@ def test_app_lifespan_messaging_import_error_no_crash(tmp_path, caplog):
"messaging.factory.create_messaging_platform",
side_effect=ImportError("discord not installed"),
),
+ TestClient(app),
):
- with TestClient(app):
- pass
+ pass
assert getattr(app.state, "messaging_platform", None) is None
cleanup_provider.assert_awaited_once()
@@ -294,9 +294,9 @@ def test_app_lifespan_platform_start_exception_cleanup_still_runs(tmp_path):
),
patch("messaging.session.SessionStore", return_value=session_store),
patch("cli.manager.CLISessionManager", return_value=cli_manager),
+ TestClient(app),
):
- with TestClient(app):
- pass
+ pass
cleanup_provider.assert_awaited_once()
@@ -331,7 +331,7 @@ def test_app_lifespan_flush_pending_save_exception_warning_only(tmp_path):
session_store.get_all_trees.return_value = []
session_store.get_node_mapping.return_value = {}
session_store.sync_from_tree_data = MagicMock()
- session_store.flush_pending_save = MagicMock(side_effect=IOError("disk full"))
+ session_store.flush_pending_save = MagicMock(side_effect=OSError("disk full"))
cli_manager = MagicMock()
cli_manager.stop_all = AsyncMock()
@@ -347,9 +347,9 @@ def test_app_lifespan_flush_pending_save_exception_warning_only(tmp_path):
),
patch("messaging.session.SessionStore", return_value=session_store),
patch("cli.manager.CLISessionManager", return_value=cli_manager),
+ TestClient(app),
):
- with TestClient(app):
- pass
+ pass
session_store.flush_pending_save.assert_called_once()
cleanup_provider.assert_awaited_once()
diff --git a/tests/api/test_dependencies.py b/tests/api/test_dependencies.py
index 89d56aad..095bc9d2 100644
--- a/tests/api/test_dependencies.py
+++ b/tests/api/test_dependencies.py
@@ -1,11 +1,13 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
import pytest
from fastapi import HTTPException
-from unittest.mock import AsyncMock, MagicMock, patch
-from api.dependencies import get_provider, get_settings, cleanup_provider
+
+from api.dependencies import cleanup_provider, get_provider, get_settings
+from config.nim import NimSettings
from providers.lmstudio import LMStudioProvider
from providers.nvidia_nim import NvidiaNimProvider
from providers.open_router import OpenRouterProvider
-from config.nim import NimSettings
def _make_mock_settings(**overrides):
diff --git a/tests/api/test_detection.py b/tests/api/test_detection.py
index deed9140..a28564a0 100644
--- a/tests/api/test_detection.py
+++ b/tests/api/test_detection.py
@@ -3,10 +3,10 @@
from unittest.mock import patch
from api.detection import (
- is_prefix_detection_request,
is_filepath_extraction_request,
+ is_prefix_detection_request,
)
-from api.models.anthropic import MessagesRequest, Message
+from api.models.anthropic import Message, MessagesRequest
def _make_request(content: str, **kwargs) -> MessagesRequest:
@@ -66,7 +66,7 @@ class TestIsFilepathExtractionRequest:
"""Output containing < is split and first part used."""
content = "Command:\nls\nOutput:\na.txt b.txt <extra>\nfilepaths"
req = _make_request(content)
- is_fp, cmd, out = is_filepath_extraction_request(req)
+ is_fp, _cmd, out = is_filepath_extraction_request(req)
assert is_fp is True
assert "<" not in out
assert out == "a.txt b.txt"
@@ -75,6 +75,6 @@ class TestIsFilepathExtractionRequest:
"""Output containing \\n\\n is split and first part used."""
content = "Command:\nls\nOutput:\na.txt\nb.txt\n\nmore text\nfilepaths"
req = _make_request(content)
- is_fp, cmd, out = is_filepath_extraction_request(req)
+ is_fp, _cmd, out = is_filepath_extraction_request(req)
assert is_fp is True
assert "more" not in out
diff --git a/tests/api/test_models_validators.py b/tests/api/test_models_validators.py
index ad51f872..d4fa9ca5 100644
--- a/tests/api/test_models_validators.py
+++ b/tests/api/test_models_validators.py
@@ -1,6 +1,8 @@
-import pytest
from unittest.mock import patch
-from api.models.anthropic import MessagesRequest, TokenCountRequest, Message
+
+import pytest
+
+from api.models.anthropic import Message, MessagesRequest, TokenCountRequest
from config.settings import Settings
diff --git a/tests/api/test_optimization_handlers.py b/tests/api/test_optimization_handlers.py
index b2d4c797..25b4a5f4 100644
--- a/tests/api/test_optimization_handlers.py
+++ b/tests/api/test_optimization_handlers.py
@@ -2,15 +2,15 @@
from unittest.mock import patch
+from api.models.anthropic import ContentBlockText, Message, MessagesRequest
from api.optimization_handlers import (
+ try_filepath_mock,
+ try_optimizations,
try_prefix_detection,
try_quota_mock,
- try_title_skip,
try_suggestion_skip,
- try_filepath_mock,
- try_optimizations,
+ try_title_skip,
)
-from api.models.anthropic import MessagesRequest, Message, ContentBlockText
from config.settings import Settings
@@ -40,15 +40,17 @@ class TestTryPrefixDetection:
settings = Settings()
settings.fast_prefix_detection = True
req = _make_request("x")
- with patch(
- "api.optimization_handlers.is_prefix_detection_request",
- return_value=(True, "/ask"),
- ):
- with patch(
+ with (
+ patch(
+ "api.optimization_handlers.is_prefix_detection_request",
+ return_value=(True, "/ask"),
+ ),
+ patch(
"api.optimization_handlers.extract_command_prefix",
return_value="/ask",
- ):
- result = try_prefix_detection(req, settings)
+ ),
+ ):
+ result = try_prefix_detection(req, settings)
assert result is not None
block = result.content[0]
assert isinstance(block, ContentBlockText)
@@ -158,15 +160,17 @@ class TestTryFilepathMock:
settings = Settings()
settings.enable_filepath_extraction_mock = True
req = _make_request("x")
- with patch(
- "api.optimization_handlers.is_filepath_extraction_request",
- return_value=(True, "ls", "a.txt b.txt"),
- ):
- with patch(
+ with (
+ patch(
+ "api.optimization_handlers.is_filepath_extraction_request",
+ return_value=(True, "ls", "a.txt b.txt"),
+ ),
+ patch(
"api.optimization_handlers.extract_filepaths_from_command",
return_value="a.txt\nb.txt",
- ):
- result = try_filepath_mock(req, settings)
+ ),
+ ):
+ result = try_filepath_mock(req, settings)
assert result is not None
block = result.content[0]
assert isinstance(block, ContentBlockText)
@@ -176,15 +180,17 @@ class TestTryFilepathMock:
settings = Settings()
settings.enable_filepath_extraction_mock = True
req = _make_request("x")
- with patch(
- "api.optimization_handlers.is_filepath_extraction_request",
- return_value=(True, "ls", "out"),
- ):
- with patch(
+ with (
+ patch(
+ "api.optimization_handlers.is_filepath_extraction_request",
+ return_value=(True, "ls", "out"),
+ ),
+ patch(
"api.optimization_handlers.extract_filepaths_from_command",
return_value="",
- ):
- result = try_filepath_mock(req, settings)
+ ),
+ ):
+ result = try_filepath_mock(req, settings)
assert result is not None
block = result.content[0]
assert isinstance(block, ContentBlockText)
diff --git a/tests/api/test_request_utils.py b/tests/api/test_request_utils.py
index 58826e5b..56b2705e 100644
--- a/tests/api/test_request_utils.py
+++ b/tests/api/test_request_utils.py
@@ -1,16 +1,17 @@
"""Tests for api/request_utils.py module."""
-import pytest
from unittest.mock import MagicMock
+import pytest
+
+from api.command_utils import extract_command_prefix
from api.detection import (
+ is_prefix_detection_request,
is_quota_check_request,
is_title_generation_request,
- is_prefix_detection_request,
)
-from api.command_utils import extract_command_prefix
+from api.models.anthropic import Message, MessagesRequest
from api.request_utils import get_token_count
-from api.models.anthropic import MessagesRequest, Message
class TestQuotaCheckRequest:
diff --git a/tests/api/test_request_utils_filepaths_and_suggestions.py b/tests/api/test_request_utils_filepaths_and_suggestions.py
index 4a916dee..17fa2fea 100644
--- a/tests/api/test_request_utils_filepaths_and_suggestions.py
+++ b/tests/api/test_request_utils_filepaths_and_suggestions.py
@@ -1,12 +1,13 @@
-import pytest
from unittest.mock import MagicMock
-from api.models.anthropic import MessagesRequest, Message
+import pytest
+
+from api.command_utils import extract_filepaths_from_command
from api.detection import (
- is_suggestion_mode_request,
is_filepath_extraction_request,
+ is_suggestion_mode_request,
)
-from api.command_utils import extract_filepaths_from_command
+from api.models.anthropic import Message, MessagesRequest
def _mk_req(messages, tools=None):
diff --git a/tests/api/test_response_models.py b/tests/api/test_response_models.py
index 7cbe1d8c..e2110049 100644
--- a/tests/api/test_response_models.py
+++ b/tests/api/test_response_models.py
@@ -1,11 +1,11 @@
"""Tests for api/models/responses.py Pydantic response models."""
-from api.models.responses import MessagesResponse, Usage, TokenCountResponse
from api.models.anthropic import (
ContentBlockText,
- ContentBlockToolUse,
ContentBlockThinking,
+ ContentBlockToolUse,
)
+from api.models.responses import MessagesResponse, TokenCountResponse, Usage
class TestUsage:
diff --git a/tests/api/test_routes_optimizations.py b/tests/api/test_routes_optimizations.py
index eb281c00..751a849d 100644
--- a/tests/api/test_routes_optimizations.py
+++ b/tests/api/test_routes_optimizations.py
@@ -1,6 +1,8 @@
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
from fastapi.testclient import TestClient
+
from api.app import app
from api.dependencies import get_settings
from config.settings import Settings
@@ -29,15 +31,17 @@ def test_create_message_fast_prefix_detection(client, mock_settings):
"messages": [{"role": "user", "content": "What is the prefix?"}],
}
- with patch(
- "api.optimization_handlers.is_prefix_detection_request",
- return_value=(True, "/ask"),
- ):
- with patch(
+ with (
+ patch(
+ "api.optimization_handlers.is_prefix_detection_request",
+ return_value=(True, "/ask"),
+ ),
+ patch(
"api.optimization_handlers.extract_command_prefix",
return_value="/ask",
- ):
- response = client.post("/v1/messages", json=payload)
+ ),
+ ):
+ response = client.post("/v1/messages", json=payload)
assert response.status_code == 200
data = response.json()
diff --git a/tests/api/test_server_module.py b/tests/api/test_server_module.py
index dec79719..887dfecc 100644
--- a/tests/api/test_server_module.py
+++ b/tests/api/test_server_module.py
@@ -10,9 +10,10 @@ def test_server_main_invokes_uvicorn_run(monkeypatch):
from types import SimpleNamespace
from unittest.mock import patch
- import config.settings as settings_mod
import uvicorn as uvicorn_mod
+ import config.settings as settings_mod
+
# Patch settings used by server.__main__ block.
old_get_settings = settings_mod.get_settings
mock_settings = SimpleNamespace(host="127.0.0.1", port=9999)
diff --git a/tests/cli/test_cli.py b/tests/cli/test_cli.py
index 151a3267..a5b20d9d 100644
--- a/tests/cli/test_cli.py
+++ b/tests/cli/test_cli.py
@@ -3,10 +3,10 @@
import asyncio
import json
import os
+from unittest.mock import AsyncMock, MagicMock, patch
import pytest
-from unittest.mock import AsyncMock, MagicMock, patch
from messaging.event_parser import parse_cli_event
# --- Existing Parser Tests ---
@@ -216,9 +216,7 @@ class TestCLISession:
) as mock_exec:
mock_exec.return_value = mock_process
- events = []
- async for event in session.start_task("Hello"):
- events.append(event)
+ events = [e async for e in session.start_task("Hello")]
# Verify command construction
# Arg 1 is subprocess command
@@ -310,9 +308,7 @@ class TestCLISession:
) as mock_exec:
mock_exec.return_value = mock_process
- events = []
- async for event in session.start_task("Hello"):
- events.append(event)
+ events = [e async for e in session.start_task("Hello")]
# Should have error event from stderr, then exit event
assert len(events) == 2
@@ -392,10 +388,9 @@ class TestCLISession:
) as mock_exec:
mock_exec.return_value = mock_process
- events = []
- async for event in session.start_task("test"):
- if event["type"] == "message":
- events.append(event)
+ events = [
+ e async for e in session.start_task("test") if e["type"] == "message"
+ ]
assert len(events) == 1
assert events[0]["content"] == "Split"
@@ -420,10 +415,9 @@ class TestCLISession:
) as mock_exec:
mock_exec.return_value = mock_process
- events = []
- async for event in session.start_task("test"):
- if event["type"] == "message":
- events.append(event)
+ events = [
+ e async for e in session.start_task("test") if e["type"] == "message"
+ ]
assert len(events) == 1
assert events[0]["content"] == "Remnant"
@@ -526,10 +520,7 @@ class TestCLISession:
) as mock_exec:
mock_exec.return_value = mock_process
- events = []
- async for event in session.start_task("test"):
- if event["type"] == "raw":
- events.append(event)
+ events = [e async for e in session.start_task("test") if e["type"] == "raw"]
assert len(events) == 1
assert events[0]["content"] == "Not valid json"
@@ -582,10 +573,10 @@ class TestCLISessionManager:
)
# Create first session
- s1, sid1, is_new1 = await manager.get_or_create_session()
+ s1, sid1, _is_new1 = await manager.get_or_create_session()
# Request same session
- s2, sid2, is_new2 = await manager.get_or_create_session(session_id=sid1)
+ s2, _sid2, is_new2 = await manager.get_or_create_session(session_id=sid1)
assert s1 is s2
assert is_new2 is False
diff --git a/tests/cli/test_cli_manager_edge_cases.py b/tests/cli/test_cli_manager_edge_cases.py
index c929fca9..0d1bfffc 100644
--- a/tests/cli/test_cli_manager_edge_cases.py
+++ b/tests/cli/test_cli_manager_edge_cases.py
@@ -1,6 +1,7 @@
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
+import pytest
+
@pytest.mark.asyncio
async def test_register_real_session_id_moves_pending_to_active_and_maps():
diff --git a/tests/config/test_logging_config.py b/tests/config/test_logging_config.py
index 117898b6..11a818cc 100644
--- a/tests/config/test_logging_config.py
+++ b/tests/config/test_logging_config.py
@@ -4,7 +4,6 @@ import json
import logging
from pathlib import Path
-
from config.logging_config import configure_logging
diff --git a/tests/conftest.py b/tests/conftest.py
index 9e9a51d9..f4ef1676 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,9 +1,11 @@
-import logging
-import pytest
import asyncio
+import contextlib
+import logging
import os
import sys
+import pytest
+
# Set mock environment BEFORE any imports that use Settings
os.environ.setdefault("NVIDIA_NIM_API_KEY", "test_key")
os.environ.setdefault("MODEL", "test-model")
@@ -14,12 +16,13 @@ sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")
from typing import Any
from unittest.mock import AsyncMock, MagicMock
-from providers.base import ProviderConfig
-from providers.nvidia_nim import NvidiaNimProvider
+
from config.nim import NimSettings
-from messaging.base import CLISession, SessionManagerInterface, MessagingPlatform
+from messaging.base import CLISession, MessagingPlatform, SessionManagerInterface
from messaging.models import IncomingMessage
from messaging.session import SessionStore
+from providers.base import ProviderConfig
+from providers.nvidia_nim import NvidiaNimProvider
@pytest.fixture
@@ -161,7 +164,7 @@ def _propagate_loguru_to_caplog():
handler_id = loguru_logger.add(_PropagateHandler(), format="{message}")
yield
- try:
- loguru_logger.remove(handler_id)
- except ValueError:
- pass # Handler already removed (e.g. by test_logging_config tests)
+ with contextlib.suppress(ValueError):
+ loguru_logger.remove(
+ handler_id
+ ) # Handler already removed (e.g. by test_logging_config)
diff --git a/tests/messaging/test_discord_markdown.py b/tests/messaging/test_discord_markdown.py
index b70a9d64..620039b3 100644
--- a/tests/messaging/test_discord_markdown.py
+++ b/tests/messaging/test_discord_markdown.py
@@ -1,15 +1,15 @@
"""Tests for messaging/discord_markdown.py."""
from messaging.discord_markdown import (
- escape_discord,
- escape_discord_code,
+ _is_gfm_table_header_line,
+ _normalize_gfm_tables,
discord_bold,
discord_code_inline,
- format_status_discord,
+ escape_discord,
+ escape_discord_code,
format_status,
+ format_status_discord,
render_markdown_to_discord,
- _is_gfm_table_header_line,
- _normalize_gfm_tables,
)
diff --git a/tests/messaging/test_discord_platform.py b/tests/messaging/test_discord_platform.py
index 22f525aa..c76d69c4 100644
--- a/tests/messaging/test_discord_platform.py
+++ b/tests/messaging/test_discord_platform.py
@@ -1,14 +1,15 @@
"""Tests for Discord platform adapter."""
import asyncio
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
+import pytest
+
from messaging.discord import (
+ DISCORD_AVAILABLE,
DiscordPlatform,
- _parse_allowed_channels,
_get_discord,
- DISCORD_AVAILABLE,
+ _parse_allowed_channels,
)
@@ -18,10 +19,12 @@ class TestGetDiscord:
def test_raises_when_discord_not_available(self):
import messaging.platforms.discord as discord_mod
- with patch.object(discord_mod, "DISCORD_AVAILABLE", False):
- with patch.object(discord_mod, "_discord_module", None):
- with pytest.raises(ImportError, match="discord.py is required"):
- _get_discord()
+ with (
+ patch.object(discord_mod, "DISCORD_AVAILABLE", False),
+ patch.object(discord_mod, "_discord_module", None),
+ pytest.raises(ImportError, match=r"discord\.py is required"),
+ ):
+ _get_discord()
class TestParseAllowedChannels:
@@ -130,22 +133,24 @@ class TestDiscordPlatform:
async def test_send_message_channel_not_found_raises(self):
platform = DiscordPlatform(bot_token="token")
platform._connected = True
- with patch.object(
- platform._client, "get_channel", MagicMock(return_value=None)
+ with (
+ patch.object(platform._client, "get_channel", MagicMock(return_value=None)),
+ pytest.raises(RuntimeError, match="Channel"),
):
- with pytest.raises(RuntimeError, match="Channel"):
- await platform.send_message("123", "Hello")
+ await platform.send_message("123", "Hello")
@pytest.mark.asyncio
async def test_send_message_channel_no_send_raises(self):
platform = DiscordPlatform(bot_token="token")
platform._connected = True
mock_channel = MagicMock(spec=[]) # No send attr
- with patch.object(
- platform._client, "get_channel", MagicMock(return_value=mock_channel)
+ with (
+ patch.object(
+ platform._client, "get_channel", MagicMock(return_value=mock_channel)
+ ),
+ pytest.raises(RuntimeError, match="Channel"),
):
- with pytest.raises(RuntimeError, match="Channel"):
- await platform.send_message("123", "Hello")
+ await platform.send_message("123", "Hello")
@pytest.mark.asyncio
async def test_queue_send_message_without_limiter_calls_send_message(self):
@@ -243,13 +248,15 @@ class TestDiscordPlatform:
mock_channel = AsyncMock()
mock_channel.send = AsyncMock(return_value=mock_msg)
platform._connected = True
- with patch.object(
- platform._client, "get_channel", MagicMock(return_value=mock_channel)
+ with (
+ patch.object(
+ platform._client, "get_channel", MagicMock(return_value=mock_channel)
+ ),
+ patch("messaging.platforms.discord._get_discord") as mock_get,
):
- with patch("messaging.platforms.discord._get_discord") as mock_get:
- mock_discord = MagicMock()
- mock_get.return_value = mock_discord
- msg_id = await platform.send_message("123", "Hello", reply_to="456")
+ mock_discord = MagicMock()
+ mock_get.return_value = mock_discord
+ msg_id = await platform.send_message("123", "Hello", reply_to="456")
assert msg_id == "999"
mock_channel.send.assert_awaited_once()
call_kw = mock_channel.send.call_args[1]
@@ -280,12 +287,14 @@ class TestDiscordPlatform:
mock_channel = AsyncMock()
mock_channel.fetch_message = AsyncMock(return_value=mock_msg)
platform._connected = True
- with patch.object(
- platform._client, "get_channel", MagicMock(return_value=mock_channel)
+ with (
+ patch.object(
+ platform._client, "get_channel", MagicMock(return_value=mock_channel)
+ ),
+ patch("messaging.platforms.discord._get_discord") as mock_get,
):
- with patch("messaging.platforms.discord._get_discord") as mock_get:
- mock_get.return_value = MagicMock()
- await platform.delete_message("123", "456")
+ mock_get.return_value = MagicMock()
+ await platform.delete_message("123", "456")
mock_msg.delete.assert_awaited_once()
@pytest.mark.asyncio
@@ -326,14 +335,19 @@ class TestDiscordPlatform:
async def _fake_start(_token):
platform._connected = True
- with patch.object(
- platform._client, "start", new_callable=AsyncMock, side_effect=_fake_start
- ):
- with patch(
+ with (
+ patch.object(
+ platform._client,
+ "start",
+ new_callable=AsyncMock,
+ side_effect=_fake_start,
+ ),
+ patch(
"messaging.limiter.MessagingRateLimiter.get_instance",
new_callable=AsyncMock,
- ):
- await platform.start()
+ ),
+ ):
+ await platform.start()
assert platform.is_connected is True
@pytest.mark.asyncio
@@ -351,11 +365,16 @@ class TestDiscordPlatform:
platform = DiscordPlatform(bot_token="token")
platform._connected = True
mock_close = AsyncMock()
- with patch.object(
- platform._client, "is_closed", new_callable=MagicMock, return_value=False
+ with (
+ patch.object(
+ platform._client,
+ "is_closed",
+ new_callable=MagicMock,
+ return_value=False,
+ ),
+ patch.object(platform._client, "close", mock_close),
):
- with patch.object(platform._client, "close", mock_close):
- platform._start_task = None
- await platform.stop()
+ platform._start_task = None
+ await platform.stop()
mock_close.assert_awaited_once()
assert platform.is_connected is False
diff --git a/tests/messaging/test_extract_text.py b/tests/messaging/test_extract_text.py
index dc543265..a98e2421 100644
--- a/tests/messaging/test_extract_text.py
+++ b/tests/messaging/test_extract_text.py
@@ -1,8 +1,9 @@
"""Tests for extract_text_from_content helper functions."""
-import pytest
from unittest.mock import MagicMock
+import pytest
+
from utils.text import extract_text_from_content
diff --git a/tests/messaging/test_handler.py b/tests/messaging/test_handler.py
index 750eb04d..e5011667 100644
--- a/tests/messaging/test_handler.py
+++ b/tests/messaging/test_handler.py
@@ -1,8 +1,10 @@
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
-from messaging.tree_data import MessageTree, MessageNode
-from messaging.models import IncomingMessage
+
+import pytest
+
from messaging.handler import ClaudeMessageHandler
+from messaging.models import IncomingMessage
+from messaging.tree_data import MessageNode, MessageTree
from messaging.tree_queue import MessageState
diff --git a/tests/messaging/test_handler_context_isolation.py b/tests/messaging/test_handler_context_isolation.py
index 268399d5..1732a03c 100644
--- a/tests/messaging/test_handler_context_isolation.py
+++ b/tests/messaging/test_handler_context_isolation.py
@@ -1,6 +1,7 @@
-import pytest
from unittest.mock import AsyncMock, MagicMock
+import pytest
+
from messaging.handler import ClaudeMessageHandler
from messaging.tree_data import MessageState
diff --git a/tests/messaging/test_handler_format.py b/tests/messaging/test_handler_format.py
index 4420c6f6..faf1f444 100644
--- a/tests/messaging/test_handler_format.py
+++ b/tests/messaging/test_handler_format.py
@@ -1,6 +1,7 @@
-import pytest
from unittest.mock import MagicMock
-from messaging.transcript import TranscriptBuffer, RenderCtx
+
+import pytest
+
from messaging.telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
@@ -8,6 +9,7 @@ from messaging.telegram_markdown import (
mdv2_code_inline,
render_markdown_to_mdv2,
)
+from messaging.transcript import RenderCtx, TranscriptBuffer
@pytest.fixture
diff --git a/tests/messaging/test_handler_integration.py b/tests/messaging/test_handler_integration.py
index 3d136a8f..9603ffea 100644
--- a/tests/messaging/test_handler_integration.py
+++ b/tests/messaging/test_handler_integration.py
@@ -1,6 +1,8 @@
-import pytest
import asyncio
from unittest.mock import MagicMock
+
+import pytest
+
from messaging.handler import ClaudeMessageHandler
from messaging.tree_data import MessageState
diff --git a/tests/messaging/test_handler_markdown_and_status_edges.py b/tests/messaging/test_handler_markdown_and_status_edges.py
index ed827e57..610f4436 100644
--- a/tests/messaging/test_handler_markdown_and_status_edges.py
+++ b/tests/messaging/test_handler_markdown_and_status_edges.py
@@ -1,9 +1,10 @@
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
+import pytest
+
from messaging.handler import ClaudeMessageHandler
-from messaging.telegram_markdown import render_markdown_to_mdv2
from messaging.models import IncomingMessage
+from messaging.telegram_markdown import render_markdown_to_mdv2
from messaging.tree_data import MessageNode, MessageState
diff --git a/tests/messaging/test_limiter.py b/tests/messaging/test_limiter.py
index cacab325..565e80f6 100644
--- a/tests/messaging/test_limiter.py
+++ b/tests/messaging/test_limiter.py
@@ -1,13 +1,16 @@
-import pytest
-import pytest_asyncio
import asyncio
-import time
import os
+import time
+
+import pytest
+import pytest_asyncio
# Set environment variables relative to test execution
os.environ["MESSAGING_RATE_LIMIT"] = "1"
os.environ["MESSAGING_RATE_WINDOW"] = "0.5"
+import contextlib
+
from messaging.limiter import MessagingRateLimiter
@@ -135,10 +138,8 @@ class TestMessagingRateLimiter:
return "success"
# First call fails and triggers pause
- try:
+ with contextlib.suppress(Exception):
await limiter.enqueue(mock_fail, dedup_key="key1")
- except Exception:
- pass # Expected
assert limiter._paused_until > 0
@@ -162,10 +163,8 @@ class TestMessagingRateLimiter:
async def mock_flood():
raise Exception("Flood wait: retry after 2 seconds")
- try:
+ with contextlib.suppress(Exception):
await limiter.enqueue(mock_flood, dedup_key="retry_parse")
- except Exception:
- pass
# Should have parsed "after 2" -> 2 seconds
assert limiter._paused_until > 0
@@ -179,10 +178,8 @@ class TestMessagingRateLimiter:
async def mock_error():
raise ValueError("some regular error")
- try:
+ with contextlib.suppress(ValueError):
await limiter.enqueue(mock_error, dedup_key="non_flood")
- except ValueError:
- pass
# Should NOT have paused since it's not a flood error
assert limiter._paused_until == 0
@@ -201,10 +198,8 @@ class TestMessagingRateLimiter:
async def mock_flood():
raise FloodWaitCustom()
- try:
+ with contextlib.suppress(Exception):
await limiter.enqueue(mock_flood, dedup_key="flood_sec")
- except Exception:
- pass
assert limiter._paused_until > 0
diff --git a/tests/messaging/test_messaging.py b/tests/messaging/test_messaging.py
index cd50eba6..5ba09fb5 100644
--- a/tests/messaging/test_messaging.py
+++ b/tests/messaging/test_messaging.py
@@ -1,10 +1,11 @@
"""Tests for messaging/ module."""
-import pytest
import json
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
from unittest.mock import patch
+import pytest
+
# --- Existing Tests ---
@@ -99,7 +100,7 @@ class TestSessionStore:
store = SessionStore(storage_path=str(tmp_path / "sessions.json"))
- old_date = (datetime.now(timezone.utc) - timedelta(days=40)).isoformat()
+ old_date = (datetime.now(UTC) - timedelta(days=40)).isoformat()
# Old tree
store.save_tree(
@@ -109,11 +110,7 @@ class TestSessionStore:
# New tree
store.save_tree(
"new_root",
- {
- "nodes": {
- "new_root": {"created_at": datetime.now(timezone.utc).isoformat()}
- }
- },
+ {"nodes": {"new_root": {"created_at": datetime.now(UTC).isoformat()}}},
)
removed = store.cleanup_old_trees(30)
@@ -165,7 +162,7 @@ class TestSessionStore:
store.save_tree("r1", {"root_id": "r1", "nodes": {"r1": {}}})
# Mock open to raise exception
- with patch("builtins.open", side_effect=IOError("Disk full")):
+ with patch("builtins.open", side_effect=OSError("Disk full")):
store.save_tree("r2", {"root_id": "r2", "nodes": {"r2": {}}})
# Should log error but not crash. Tree should be in memory.
@@ -199,8 +196,8 @@ class TestTreeQueueManager:
@pytest.mark.asyncio
async def test_create_tree_and_enqueue(self):
"""Test creating a tree and enqueueing."""
- from messaging.tree_queue import TreeQueueManager
from messaging.models import IncomingMessage
+ from messaging.tree_queue import TreeQueueManager
mgr = TreeQueueManager()
processed = []
diff --git a/tests/messaging/test_messaging_factory.py b/tests/messaging/test_messaging_factory.py
index a189046f..fb109fe8 100644
--- a/tests/messaging/test_messaging_factory.py
+++ b/tests/messaging/test_messaging_factory.py
@@ -1,6 +1,6 @@
"""Tests for messaging platform factory."""
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
from messaging.factory import create_messaging_platform
@@ -11,16 +11,18 @@ class TestCreateMessagingPlatform:
def test_telegram_with_token(self):
"""Create Telegram platform when bot_token is provided."""
mock_platform = MagicMock()
- with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- with patch(
+ with (
+ patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True),
+ patch(
"messaging.platforms.telegram.TelegramPlatform",
return_value=mock_platform,
- ):
- result = create_messaging_platform(
- "telegram",
- bot_token="test_token",
- allowed_user_id="12345",
- )
+ ),
+ ):
+ result = create_messaging_platform(
+ "telegram",
+ bot_token="test_token",
+ allowed_user_id="12345",
+ )
assert result is mock_platform
@@ -37,16 +39,18 @@ class TestCreateMessagingPlatform:
def test_discord_with_token(self):
"""Create Discord platform when discord_bot_token is provided."""
mock_platform = MagicMock()
- with patch("messaging.platforms.discord.DISCORD_AVAILABLE", True):
- with patch(
+ with (
+ patch("messaging.platforms.discord.DISCORD_AVAILABLE", True),
+ patch(
"messaging.platforms.discord.DiscordPlatform",
return_value=mock_platform,
- ):
- result = create_messaging_platform(
- "discord",
- discord_bot_token="test_token",
- allowed_discord_channels="123,456",
- )
+ ),
+ ):
+ result = create_messaging_platform(
+ "discord",
+ discord_bot_token="test_token",
+ allowed_discord_channels="123,456",
+ )
assert result is mock_platform
diff --git a/tests/messaging/test_reliability.py b/tests/messaging/test_reliability.py
index 97847f66..9a1c379e 100644
--- a/tests/messaging/test_reliability.py
+++ b/tests/messaging/test_reliability.py
@@ -1,8 +1,10 @@
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
-from messaging.telegram import TelegramPlatform
+
+import pytest
from telegram.error import NetworkError, RetryAfter, TelegramError
+from messaging.telegram import TelegramPlatform
+
@pytest.fixture
def telegram_platform():
@@ -74,7 +76,6 @@ async def test_telegram_no_retry_on_bad_request(telegram_platform):
def test_handler_build_message_hardening():
# Formatting hardening now lives in TranscriptBuffer rendering.
- from messaging.transcript import TranscriptBuffer, RenderCtx
from messaging.telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
@@ -82,6 +83,7 @@ def test_handler_build_message_hardening():
mdv2_code_inline,
render_markdown_to_mdv2,
)
+ from messaging.transcript import RenderCtx, TranscriptBuffer
ctx = RenderCtx(
bold=mdv2_bold,
@@ -110,7 +112,6 @@ def test_handler_build_message_hardening():
def test_render_output_never_exceeds_4096():
"""Transcript render with various status lengths never exceeds Telegram 4096 limit."""
- from messaging.transcript import TranscriptBuffer, RenderCtx
from messaging.telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
@@ -118,6 +119,7 @@ def test_render_output_never_exceeds_4096():
mdv2_code_inline,
render_markdown_to_mdv2,
)
+ from messaging.transcript import RenderCtx, TranscriptBuffer
ctx = RenderCtx(
bold=mdv2_bold,
diff --git a/tests/messaging/test_restart_reply_restore.py b/tests/messaging/test_restart_reply_restore.py
index 2e20f8a7..0203cfb3 100644
--- a/tests/messaging/test_restart_reply_restore.py
+++ b/tests/messaging/test_restart_reply_restore.py
@@ -1,10 +1,11 @@
-import pytest
from unittest.mock import AsyncMock, patch
+import pytest
+
from messaging.handler import ClaudeMessageHandler
+from messaging.models import IncomingMessage
from messaging.session import SessionStore
from messaging.tree_queue import TreeQueueManager
-from messaging.models import IncomingMessage
@pytest.mark.asyncio
diff --git a/tests/messaging/test_robust_formatting.py b/tests/messaging/test_robust_formatting.py
index 6deddf1a..e70d2a4d 100644
--- a/tests/messaging/test_robust_formatting.py
+++ b/tests/messaging/test_robust_formatting.py
@@ -1,6 +1,7 @@
-import pytest
from unittest.mock import MagicMock
-from messaging.transcript import TranscriptBuffer, RenderCtx
+
+import pytest
+
from messaging.telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
@@ -8,6 +9,7 @@ from messaging.telegram_markdown import (
mdv2_code_inline,
render_markdown_to_mdv2,
)
+from messaging.transcript import RenderCtx, TranscriptBuffer
@pytest.fixture
diff --git a/tests/messaging/test_session_store_edge_cases.py b/tests/messaging/test_session_store_edge_cases.py
index 05962d3b..f5625355 100644
--- a/tests/messaging/test_session_store_edge_cases.py
+++ b/tests/messaging/test_session_store_edge_cases.py
@@ -1,9 +1,10 @@
"""Edge case tests for messaging/session.py SessionStore."""
import json
-import pytest
from unittest.mock import patch
+import pytest
+
from messaging.session import SessionStore
@@ -82,7 +83,7 @@ class TestSessionStoreSaveEdgeCases:
def test_save_io_error_handled(self, tmp_store):
"""Write failure in _save() is logged but doesn't raise."""
tmp_store.save_tree("r1", {"root_id": "r1", "nodes": {"r1": {}}})
- with patch("builtins.open", side_effect=IOError("disk full")):
+ with patch("builtins.open", side_effect=OSError("disk full")):
tmp_store._save()
# Should not raise
@@ -126,7 +127,7 @@ class TestSessionStoreClearAll:
assert store.get_all_trees() == {}
assert store.get_node_mapping() == {}
- with open(path, "r", encoding="utf-8") as f:
+ with open(path, encoding="utf-8") as f:
data = json.load(f)
assert data["trees"] == {}
assert data["node_to_tree"] == {}
diff --git a/tests/messaging/test_telegram.py b/tests/messaging/test_telegram.py
index df3b3712..ece4f40b 100644
--- a/tests/messaging/test_telegram.py
+++ b/tests/messaging/test_telegram.py
@@ -1,5 +1,7 @@
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
from messaging.telegram import TelegramPlatform
diff --git a/tests/messaging/test_telegram_edge_cases.py b/tests/messaging/test_telegram_edge_cases.py
index 1edb8254..d0f9d986 100644
--- a/tests/messaging/test_telegram_edge_cases.py
+++ b/tests/messaging/test_telegram_edge_cases.py
@@ -41,7 +41,7 @@ async def test_telegram_platform_stop_no_application_is_noop():
@pytest.mark.asyncio
async def test_with_retry_returns_none_when_message_not_modified_network_error():
with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- from messaging.telegram import TelegramPlatform, NetworkError
+ from messaging.telegram import NetworkError, TelegramPlatform
platform = TelegramPlatform(bot_token="t")
@@ -54,7 +54,7 @@ async def test_with_retry_returns_none_when_message_not_modified_network_error()
@pytest.mark.asyncio
async def test_with_retry_retries_network_error_then_succeeds(monkeypatch):
with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- from messaging.telegram import TelegramPlatform, NetworkError
+ from messaging.telegram import NetworkError, TelegramPlatform
platform = TelegramPlatform(bot_token="t")
@@ -75,7 +75,7 @@ async def test_with_retry_retries_network_error_then_succeeds(monkeypatch):
@pytest.mark.asyncio
async def test_with_retry_honors_retry_after_timedelta(monkeypatch):
with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- from messaging.telegram import TelegramPlatform, RetryAfter
+ from messaging.telegram import RetryAfter, TelegramPlatform
platform = TelegramPlatform(bot_token="t")
@@ -96,7 +96,7 @@ async def test_with_retry_honors_retry_after_timedelta(monkeypatch):
@pytest.mark.asyncio
async def test_with_retry_drops_parse_mode_on_markdown_entity_error():
with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- from messaging.telegram import TelegramPlatform, TelegramError
+ from messaging.telegram import TelegramError, TelegramPlatform
platform = TelegramPlatform(bot_token="t")
@@ -200,7 +200,7 @@ async def test_on_telegram_message_handler_error_sends_error_message():
@pytest.mark.asyncio
async def test_telegram_start_retries_on_network_error(monkeypatch):
with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- from messaging.telegram import TelegramPlatform, NetworkError
+ from messaging.telegram import NetworkError, TelegramPlatform
platform = TelegramPlatform(bot_token="token", allowed_user_id=None)
@@ -225,7 +225,7 @@ async def test_telegram_start_retries_on_network_error(monkeypatch):
async def test_edit_message_with_text_exceeding_4096_raises():
"""edit_message with text > 4096 raises TelegramError (BadRequest)."""
with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- from messaging.telegram import TelegramPlatform, TelegramError
+ from messaging.telegram import TelegramError, TelegramPlatform
platform = TelegramPlatform(bot_token="t")
platform._application = MagicMock()
@@ -299,7 +299,7 @@ async def test_on_telegram_message_non_text_update_ignored():
async def test_with_retry_message_not_found_returns_none():
"""'message to edit not found' returns None without retry."""
with patch("messaging.platforms.telegram.TELEGRAM_AVAILABLE", True):
- from messaging.telegram import TelegramPlatform, TelegramError
+ from messaging.telegram import TelegramError, TelegramPlatform
platform = TelegramPlatform(bot_token="t")
diff --git a/tests/messaging/test_transcript.py b/tests/messaging/test_transcript.py
index d3e25a21..6a8ad063 100644
--- a/tests/messaging/test_transcript.py
+++ b/tests/messaging/test_transcript.py
@@ -1,6 +1,5 @@
from unittest.mock import patch
-from messaging.transcript import TranscriptBuffer, RenderCtx
from messaging.telegram_markdown import (
escape_md_v2,
escape_md_v2_code,
@@ -8,6 +7,7 @@ from messaging.telegram_markdown import (
mdv2_code_inline,
render_markdown_to_mdv2,
)
+from messaging.transcript import RenderCtx, TranscriptBuffer
def _ctx() -> RenderCtx:
diff --git a/tests/messaging/test_transcription.py b/tests/messaging/test_transcription.py
index e3b778d2..e58237fd 100644
--- a/tests/messaging/test_transcription.py
+++ b/tests/messaging/test_transcription.py
@@ -7,8 +7,8 @@ from unittest.mock import MagicMock, patch
import pytest
from messaging.transcription import (
- transcribe_audio,
MAX_AUDIO_SIZE_BYTES,
+ transcribe_audio,
)
@@ -79,13 +79,15 @@ def test_transcribe_local_import_error_raises():
f.write(b"fake ogg")
path = Path(f.name)
try:
- with patch(
- "messaging.transcription._get_local_model",
- side_effect=ImportError(
- "Voice notes require the voice extra. Install with: uv sync --extra voice"
+ with (
+ patch(
+ "messaging.transcription._get_local_model",
+ side_effect=ImportError(
+ "Voice notes require the voice extra. Install with: uv sync --extra voice"
+ ),
),
+ pytest.raises(ImportError, match="voice extra"),
):
- with pytest.raises(ImportError, match="voice extra"):
- transcribe_audio(path, "audio/ogg")
+ transcribe_audio(path, "audio/ogg")
finally:
path.unlink(missing_ok=True)
diff --git a/tests/messaging/test_tree_concurrency.py b/tests/messaging/test_tree_concurrency.py
index f1a14f0c..e42d41aa 100644
--- a/tests/messaging/test_tree_concurrency.py
+++ b/tests/messaging/test_tree_concurrency.py
@@ -1,10 +1,11 @@
"""Concurrency and race condition tests for tree data structures and queue manager."""
-import pytest
import asyncio
+import pytest
+
from messaging.models import IncomingMessage
-from messaging.tree_data import MessageState, MessageNode, MessageTree
+from messaging.tree_data import MessageNode, MessageState, MessageTree
from messaging.tree_queue import TreeQueueManager
diff --git a/tests/messaging/test_tree_processor.py b/tests/messaging/test_tree_processor.py
index 4a8ae494..ee4df46f 100644
--- a/tests/messaging/test_tree_processor.py
+++ b/tests/messaging/test_tree_processor.py
@@ -1,9 +1,12 @@
-import pytest
import asyncio
+import contextlib
from unittest.mock import AsyncMock, MagicMock
-from messaging.tree_processor import TreeQueueProcessor
-from messaging.tree_data import MessageTree, MessageNode, MessageState
+
+import pytest
+
from messaging.models import IncomingMessage
+from messaging.tree_data import MessageNode, MessageState, MessageTree
+from messaging.tree_processor import TreeQueueProcessor
@pytest.fixture
@@ -87,10 +90,8 @@ async def test_enqueue_and_start_when_free(tree_processor, sample_tree):
# Clean up task
sample_tree._current_task.cancel()
- try:
+ with contextlib.suppress(asyncio.CancelledError):
await sample_tree._current_task
- except asyncio.CancelledError:
- pass
@pytest.mark.asyncio
@@ -153,10 +154,8 @@ async def test_process_next_with_item(tree_processor, sample_tree):
# Clean up
sample_tree._current_task.cancel()
- try:
+ with contextlib.suppress(asyncio.CancelledError):
await sample_tree._current_task
- except asyncio.CancelledError:
- pass
@pytest.mark.asyncio
diff --git a/tests/messaging/test_tree_queue.py b/tests/messaging/test_tree_queue.py
index 85bd4cb3..04e2255f 100644
--- a/tests/messaging/test_tree_queue.py
+++ b/tests/messaging/test_tree_queue.py
@@ -1,15 +1,16 @@
"""Tests for tree-based message queue system."""
-import pytest
import asyncio
+import pytest
+
+from messaging.models import IncomingMessage
from messaging.tree_queue import (
- MessageState,
MessageNode,
+ MessageState,
MessageTree,
TreeQueueManager,
)
-from messaging.models import IncomingMessage
class TestMessageState:
diff --git a/tests/messaging/test_tree_repository.py b/tests/messaging/test_tree_repository.py
index df41fba7..0b61a30b 100644
--- a/tests/messaging/test_tree_repository.py
+++ b/tests/messaging/test_tree_repository.py
@@ -1,8 +1,10 @@
-import pytest
from unittest.mock import MagicMock
-from messaging.tree_repository import TreeRepository
-from messaging.tree_data import MessageTree, MessageNode, MessageState
+
+import pytest
+
from messaging.models import IncomingMessage
+from messaging.tree_data import MessageNode, MessageState, MessageTree
+from messaging.tree_repository import TreeRepository
@pytest.fixture
diff --git a/tests/messaging/test_voice_handlers.py b/tests/messaging/test_voice_handlers.py
index 739ee81d..b2537c88 100644
--- a/tests/messaging/test_voice_handlers.py
+++ b/tests/messaging/test_voice_handlers.py
@@ -6,8 +6,8 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from messaging.platforms.discord import DISCORD_AVAILABLE, DiscordPlatform
from messaging.platforms.telegram import TelegramPlatform
-from messaging.platforms.discord import DiscordPlatform, DISCORD_AVAILABLE
@pytest.fixture
diff --git a/tests/providers/test_converter.py b/tests/providers/test_converter.py
index 424dea31..9fa33852 100644
--- a/tests/providers/test_converter.py
+++ b/tests/providers/test_converter.py
@@ -1,5 +1,7 @@
import json
+
import pytest
+
from providers.common.message_converter import AnthropicToOpenAIConverter
# --- Mock Classes ---
diff --git a/tests/providers/test_error_mapping.py b/tests/providers/test_error_mapping.py
index 8b5ab318..9b0b2ba1 100644
--- a/tests/providers/test_error_mapping.py
+++ b/tests/providers/test_error_mapping.py
@@ -1,18 +1,18 @@
"""Tests for providers/nvidia_nim/errors.py error mapping."""
-import pytest
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
import openai
-from httpx import Response, Request
+import pytest
+from httpx import Request, Response
from providers.common import map_error
from providers.exceptions import (
+ APIError,
AuthenticationError,
InvalidRequestError,
- RateLimitError,
OverloadedError,
- APIError,
+ RateLimitError,
)
diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.py
index 2db20299..7299a0f6 100644
--- a/tests/providers/test_lmstudio.py
+++ b/tests/providers/test_lmstudio.py
@@ -1,9 +1,10 @@
"""Tests for LM Studio provider."""
import json
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
+import pytest
+
from providers.base import ProviderConfig
from providers.lmstudio import LMStudioProvider
from providers.lmstudio.request import LMSTUDIO_DEFAULT_MAX_TOKENS
@@ -65,10 +66,7 @@ def _make_request(model="test-model", **kwargs):
async def _collect_stream(provider, request):
"""Collect all SSE events from a stream."""
- events = []
- async for event in provider.stream_response(request):
- events.append(event)
- return events
+ return [e async for e in provider.stream_response(request)]
class MockMessage:
@@ -217,9 +215,7 @@ async def test_stream_response_text(lmstudio_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in lmstudio_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in lmstudio_provider.stream_response(req)]
assert len(events) > 0
assert "event: message_start" in events[0]
@@ -258,15 +254,16 @@ async def test_stream_response_reasoning_content(lmstudio_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in lmstudio_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in lmstudio_provider.stream_response(req)]
found_thinking = False
for e in events:
- if "event: content_block_delta" in e and '"thinking_delta"' in e:
- if "Thinking..." in e:
- found_thinking = True
+ if (
+ "event: content_block_delta" in e
+ and '"thinking_delta"' in e
+ and "Thinking..." in e
+ ):
+ found_thinking = True
assert found_thinking
@@ -424,9 +421,7 @@ async def test_stream_response_tool_call(lmstudio_provider):
new_callable=AsyncMock,
return_value=mock_stream(),
):
- events = []
- async for event in lmstudio_provider.stream_response(request):
- events.append(event)
+ events = [e async for e in lmstudio_provider.stream_response(request)]
starts = [
e for e in events if "event: content_block_start" in e and '"tool_use"' in e
diff --git a/tests/providers/test_model_utils.py b/tests/providers/test_model_utils.py
index 8b9bf5dd..cea6bebd 100644
--- a/tests/providers/test_model_utils.py
+++ b/tests/providers/test_model_utils.py
@@ -1,10 +1,10 @@
import pytest
from providers.model_utils import (
- strip_provider_prefixes,
+ get_original_model,
is_claude_model,
normalize_model_name,
- get_original_model,
+ strip_provider_prefixes,
)
diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.py
index 253b388f..fd6273aa 100644
--- a/tests/providers/test_nvidia_nim.py
+++ b/tests/providers/test_nvidia_nim.py
@@ -1,6 +1,8 @@
-import pytest
import json
-from unittest.mock import MagicMock, AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
from providers.nvidia_nim import NvidiaNimProvider
@@ -65,8 +67,8 @@ async def test_init(provider_config):
@pytest.mark.asyncio
async def test_init_uses_configurable_timeouts():
"""Test that provider passes configurable read/write/connect timeouts to client."""
- from providers.base import ProviderConfig
from config.nim import NimSettings
+ from providers.base import ProviderConfig
config = ProviderConfig(
api_key="test_key",
@@ -139,9 +141,7 @@ async def test_stream_response_text(nim_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in nim_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in nim_provider.stream_response(req)]
assert len(events) > 0
assert "event: message_start" in events[0]
@@ -180,16 +180,17 @@ async def test_stream_response_thinking_reasoning_content(nim_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in nim_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in nim_provider.stream_response(req)]
# Check for thinking_delta
found_thinking = False
for e in events:
- if "event: content_block_delta" in e and '"thinking_delta"' in e:
- if "Thinking..." in e:
- found_thinking = True
+ if (
+ "event: content_block_delta" in e
+ and '"thinking_delta"' in e
+ and "Thinking..." in e
+ ):
+ found_thinking = True
assert found_thinking
@@ -222,9 +223,7 @@ async def test_tool_call_stream(nim_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in nim_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in nim_provider.stream_response(req)]
starts = [
e for e in events if "event: content_block_start" in e and '"tool_use"' in e
diff --git a/tests/providers/test_nvidia_nim_request.py b/tests/providers/test_nvidia_nim_request.py
index 5c273833..029cb781 100644
--- a/tests/providers/test_nvidia_nim_request.py
+++ b/tests/providers/test_nvidia_nim_request.py
@@ -2,12 +2,12 @@
from unittest.mock import MagicMock
+from config.nim import NimSettings
from providers.nvidia_nim.request import (
- _set_if_not_none,
_set_extra,
+ _set_if_not_none,
build_request_body,
)
-from config.nim import NimSettings
class TestSetIfNotNone:
diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.py
index 4fcd3604..0f801a7e 100644
--- a/tests/providers/test_open_router.py
+++ b/tests/providers/test_open_router.py
@@ -1,11 +1,13 @@
"""Tests for OpenRouter provider."""
-import pytest
import json
-from unittest.mock import MagicMock, AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from providers.base import ProviderConfig
from providers.open_router import OpenRouterProvider
from providers.open_router.request import OPENROUTER_DEFAULT_MAX_TOKENS
-from providers.base import ProviderConfig
class MockMessage:
@@ -151,9 +153,7 @@ async def test_stream_response_text(open_router_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in open_router_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in open_router_provider.stream_response(req)]
assert len(events) > 0
assert "event: message_start" in events[0]
@@ -192,15 +192,16 @@ async def test_stream_response_reasoning_content(open_router_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in open_router_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in open_router_provider.stream_response(req)]
found_thinking = False
for e in events:
- if "event: content_block_delta" in e and '"thinking_delta"' in e:
- if "Thinking..." in e:
- found_thinking = True
+ if (
+ "event: content_block_delta" in e
+ and '"thinking_delta"' in e
+ and "Thinking..." in e
+ ):
+ found_thinking = True
assert found_thinking
@@ -225,9 +226,7 @@ async def test_stream_response_empty_choices_skipped(open_router_provider):
open_router_provider._client.chat.completions, "create", new_callable=AsyncMock
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in open_router_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in open_router_provider.stream_response(req)]
assert any("content_block_delta" in e and "ok" in e for e in events)
@@ -255,9 +254,7 @@ async def test_stream_response_delta_none_skipped(open_router_provider):
open_router_provider._client.chat.completions, "create", new_callable=AsyncMock
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in open_router_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in open_router_provider.stream_response(req)]
assert any("x" in e for e in events)
@@ -299,9 +296,7 @@ async def test_stream_response_reasoning_details(open_router_provider):
open_router_provider._client.chat.completions, "create", new_callable=AsyncMock
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in open_router_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in open_router_provider.stream_response(req)]
assert any("Step 1" in e for e in events)
@@ -318,9 +313,7 @@ async def test_stream_response_error_path(open_router_provider):
open_router_provider._client.chat.completions, "create", new_callable=AsyncMock
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in open_router_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in open_router_provider.stream_response(req)]
# Error is emitted; message_stop/done indicates stream completed
assert any("API failed" in e for e in events)
assert any("message_stop" in e for e in events)
@@ -346,8 +339,6 @@ async def test_stream_response_finish_reason_only(open_router_provider):
open_router_provider._client.chat.completions, "create", new_callable=AsyncMock
) as mock_create:
mock_create.return_value = mock_stream()
- events = []
- async for event in open_router_provider.stream_response(req):
- events.append(event)
+ events = [e async for e in open_router_provider.stream_response(req)]
assert any("message_delta" in e for e in events)
assert any("message_stop" in e for e in events)
diff --git a/tests/providers/test_parsers.py b/tests/providers/test_parsers.py
index 4a2ea19d..e84edaa2 100644
--- a/tests/providers/test_parsers.py
+++ b/tests/providers/test_parsers.py
@@ -1,6 +1,6 @@
import pytest
-from providers.common import ThinkTagParser, ContentType, HeuristicToolParser
+from providers.common import ContentType, HeuristicToolParser, ThinkTagParser
def test_think_tag_parser_basic():
@@ -48,11 +48,11 @@ def test_heuristic_tool_parser_streaming():
parser = HeuristicToolParser()
# Feed part 1
- filtered1, tools1 = parser.feed("● <function=Write>")
+ _filtered1, tools1 = parser.feed("● <function=Write>")
assert tools1 == []
# Feed part 2
- filtered2, tools2 = parser.feed("<parameter=path>test.txt</parameter>")
+ _filtered2, tools2 = parser.feed("<parameter=path>test.txt</parameter>")
assert tools2 == []
# Feed part 3 (triggering flush or completion)
@@ -126,7 +126,7 @@ def test_interleaved_thinking_and_tools():
assert thinking[0].content == "I need to search for a file."
# 2. Parse tool from remaining text
- filtered, tools = parser_tool.feed(text_remaining)
+ _filtered, tools = parser_tool.feed(text_remaining)
tools += parser_tool.flush()
assert len(tools) == 1
@@ -151,13 +151,13 @@ def test_partial_interleaved_streaming():
assert chunks2[0].content == " ends"
text_rem = chunks2[1].content
- filtered, tools = parser_tool.feed(text_rem)
+ _filtered, tools = parser_tool.feed(text_rem)
assert tools == []
# Chunk 3: Tool ends
chunks3 = list(parser_think.feed("tion=Read><parameter=path>test.py</parameter>"))
text_rem3 = "".join([c.content for c in chunks3])
- filtered3, tools3 = parser_tool.feed(text_rem3)
+ _filtered3, tools3 = parser_tool.feed(text_rem3)
tools3 += parser_tool.flush()
assert len(tools3) == 1
@@ -180,9 +180,9 @@ def test_split_across_markers():
chunk2 = full_text[i:]
tools = []
- filtered, t = p.feed(chunk1)
+ _filtered, t = p.feed(chunk1)
tools.extend(t)
- filtered2, t = p.feed(chunk2)
+ _filtered2, t = p.feed(chunk2)
tools.extend(t)
tools.extend(p.flush())
@@ -453,7 +453,7 @@ def test_heuristic_tool_parser_unicode_function_name():
"""Unicode characters in function parameters."""
parser = HeuristicToolParser()
text = "● <function=Search><parameter=query>日本語テスト</parameter>"
- filtered, tools = parser.feed(text)
+ _filtered, tools = parser.feed(text)
tools.extend(parser.flush())
assert len(tools) == 1
assert tools[0]["name"] == "Search"
@@ -471,6 +471,6 @@ def test_heuristic_tool_parser_unicode_function_name():
def test_heuristic_tool_parser_malformed_function_tag(malformed_text):
"""Malformed function tags should still be handled without crashing."""
parser = HeuristicToolParser()
- filtered, tools = parser.feed(malformed_text)
+ _filtered, tools = parser.feed(malformed_text)
tools.extend(parser.flush())
# Should not crash; may or may not detect a tool depending on regex match
diff --git a/tests/providers/test_provider_rate_limit.py b/tests/providers/test_provider_rate_limit.py
index 3a2fa437..b17d3ea4 100644
--- a/tests/providers/test_provider_rate_limit.py
+++ b/tests/providers/test_provider_rate_limit.py
@@ -1,8 +1,9 @@
-import pytest
-import pytest_asyncio
import asyncio
import time
+import pytest
+import pytest_asyncio
+
from providers.rate_limit import GlobalRateLimiter
@@ -38,9 +39,7 @@ class TestProviderRateLimiter:
# R2 -> 0.50s
# R3 -> 0.75s
# R4 -> 1.00s
- results = []
- for _ in range(5):
- results.append(await call_limiter())
+ results = [await call_limiter() for _ in range(5)]
total_time = time.time() - start_time
@@ -202,7 +201,7 @@ class TestProviderRateLimiter:
async def test_execute_with_retry_exhaust_retries_raises(self):
"""When all 429 retries exhausted, last exception is raised."""
import openai
- from httpx import Response, Request
+ from httpx import Request, Response
GlobalRateLimiter.reset_instance()
limiter = GlobalRateLimiter.get_instance(rate_limit=100, rate_window=60)
@@ -226,7 +225,7 @@ class TestProviderRateLimiter:
async def test_execute_with_retry_succeeds_on_retry(self):
"""429 then success returns result."""
import openai
- from httpx import Response, Request
+ from httpx import Request, Response
GlobalRateLimiter.reset_instance()
limiter = GlobalRateLimiter.get_instance(rate_limit=100, rate_window=60)
diff --git a/tests/providers/test_sse_builder.py b/tests/providers/test_sse_builder.py
index 0e8ca1e3..6557b4b7 100644
--- a/tests/providers/test_sse_builder.py
+++ b/tests/providers/test_sse_builder.py
@@ -1,12 +1,13 @@
"""Tests for providers/nvidia_nim/utils/sse_builder.py."""
import json
-import pytest
from unittest.mock import patch
+import pytest
+
from providers.common.sse_builder import (
- SSEBuilder,
ContentBlockManager,
+ SSEBuilder,
map_stop_reason,
)
diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.py
index 1b5c0fda..9909426a 100644
--- a/tests/providers/test_streaming_errors.py
+++ b/tests/providers/test_streaming_errors.py
@@ -1,12 +1,13 @@
"""Tests for streaming error handling in providers/nvidia_nim/client.py."""
import json
-import pytest
from unittest.mock import AsyncMock, MagicMock, patch
-from providers.nvidia_nim import NvidiaNimProvider
-from providers.base import ProviderConfig
+import pytest
+
from config.nim import NimSettings
+from providers.base import ProviderConfig
+from providers.nvidia_nim import NvidiaNimProvider
class AsyncStreamMock:
@@ -78,10 +79,7 @@ def _make_chunk(
async def _collect_stream(provider, request):
"""Collect all SSE events from a stream."""
- events = []
- async for event in provider.stream_response(request):
- events.append(event)
- return events
+ return [e async for e in provider.stream_response(request)]
class TestStreamingExceptionHandling:
@@ -96,19 +94,21 @@ class TestStreamingExceptionHandling:
mock_stream = AsyncMock()
mock_stream.__aiter__ = MagicMock(side_effect=RuntimeError("API failed"))
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- side_effect=RuntimeError("API failed"),
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ side_effect=RuntimeError("API failed"),
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
# Should have message_start, error text block, close blocks, message_delta, message_stop, done
event_text = "".join(events)
@@ -126,19 +126,21 @@ class TestStreamingExceptionHandling:
chunk1 = _make_chunk(content="Hello ")
stream_mock = AsyncStreamMock([chunk1], error=RuntimeError("Connection lost"))
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- return_value=stream_mock,
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
event_text = "".join(events)
assert "Hello" in event_text
@@ -154,19 +156,21 @@ class TestStreamingExceptionHandling:
empty_chunk = _make_chunk(finish_reason="stop")
stream_mock = AsyncStreamMock([empty_chunk])
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- return_value=stream_mock,
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
event_text = "".join(events)
assert '"text_delta"' in event_text
@@ -182,19 +186,21 @@ class TestStreamingExceptionHandling:
chunk2 = _make_chunk(finish_reason="stop")
stream_mock = AsyncStreamMock([chunk1, chunk2])
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- return_value=stream_mock,
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
event_text = "".join(events)
assert "thinking" in event_text
@@ -212,19 +218,21 @@ class TestStreamingExceptionHandling:
chunk3 = _make_chunk(finish_reason="stop")
stream_mock = AsyncStreamMock([chunk1, chunk2, chunk3])
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- return_value=stream_mock,
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
event_text = "".join(events)
assert "thinking_delta" in event_text
@@ -407,19 +415,21 @@ class TestStreamChunkEdgeCases:
finish_chunk = _make_chunk(finish_reason="stop")
stream_mock = AsyncStreamMock([empty_choices_chunk, finish_chunk])
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- return_value=stream_mock,
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
event_text = "".join(events)
assert "message_start" in event_text
@@ -442,19 +452,21 @@ class TestStreamChunkEdgeCases:
finish_chunk = _make_chunk(finish_reason="stop")
stream_mock = AsyncStreamMock([none_delta_chunk, finish_chunk])
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- return_value=stream_mock,
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
event_text = "".join(events)
assert "message_start" in event_text
@@ -472,19 +484,21 @@ class TestStreamChunkEdgeCases:
[chunk1], error=ConnectionResetError("Connection reset")
)
- with patch.object(
- provider._client.chat.completions,
- "create",
- new_callable=AsyncMock,
- return_value=stream_mock,
- ):
- with patch.object(
+ with (
+ patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream_mock,
+ ),
+ patch.object(
provider._global_rate_limiter,
"wait_if_blocked",
new_callable=AsyncMock,
return_value=False,
- ):
- events = await _collect_stream(provider, request)
+ ),
+ ):
+ events = await _collect_stream(provider, request)
event_text = "".join(events)
assert "Partial" in event_text
diff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.py
index b3fc3b2b..a36897aa 100644
--- a/tests/providers/test_subagent_interception.py
+++ b/tests/providers/test_subagent_interception.py
@@ -1,10 +1,12 @@
import json
-import pytest
from unittest.mock import MagicMock
-from providers.nvidia_nim import NvidiaNimProvider
-from providers.common import ContentBlockManager
-from providers.base import ProviderConfig
+
+import pytest
+
from config.nim import NimSettings
+from providers.base import ProviderConfig
+from providers.common import ContentBlockManager
+from providers.nvidia_nim import NvidiaNimProvider
@pytest.mark.asyncio
@@ -36,10 +38,8 @@ async def test_task_tool_interception():
},
}
- # Call the method
- events = []
- for event in provider._process_tool_call(tc, sse):
- events.append(event)
+ # Call the method (consume generator to trigger side effects)
+ list(provider._process_tool_call(tc, sse))
# Find the emit_tool_delta call and check args
calls = sse.emit_tool_delta.call_args_list