style: ruff format

Author: xfgong

cubepi/checkpointer/__init__.py

@@ -6,6 +6,7 @@
 def __getattr__(name: str) -> object:
     if name == "PostgresCheckpointer":
         from cubepi.checkpointer.postgres.checkpointer import PostgresCheckpointer
+
         return PostgresCheckpointer
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 

cubepi/checkpointer/postgres/checkpointer.py

@@ -3,6 +3,7 @@
 Append-only message log + per-thread KV (extra). Uses asyncpg pool +
 msgpack payload encoding. Schema version verified on context entry.
 """
+
 from __future__ import annotations
 
 import json
@@ -156,31 +157,39 @@ async def append(self, thread_id: str, messages: list[Message]) -> None:
             async with conn.transaction():
                 # Per-thread advisory lock for monotonic seq allocation
                 await conn.execute(
-                    "SELECT pg_advisory_xact_lock(hashtext($1))", thread_id,
+                    "SELECT pg_advisory_xact_lock(hashtext($1))",
+                    thread_id,
                 )
                 # Lazy thread row creation
                 await conn.execute(
                     "INSERT INTO cubepi_threads (thread_id) "
                     "VALUES ($1) ON CONFLICT DO NOTHING",
                     thread_id,
                 )
-                last_seq = await conn.fetchval(
-                    "SELECT COALESCE(MAX(seq), 0) FROM cubepi_messages "
-                    "WHERE thread_id = $1",
-                    thread_id,
-                ) or 0
+                last_seq = (
+                    await conn.fetchval(
+                        "SELECT COALESCE(MAX(seq), 0) FROM cubepi_messages "
+                        "WHERE thread_id = $1",
+                        thread_id,
+                    )
+                    or 0
+                )
 
                 rows = []
                 for i, m in enumerate(messages):
                     seq = last_seq + i + 1
-                    payload = msgpack.packb(m.model_dump(mode="json"), use_bin_type=True)
-                    rows.append((
-                        thread_id,
-                        seq,
-                        _role_of(m),
-                        json.dumps(m.metadata),
-                        payload,
-                    ))
+                    payload = msgpack.packb(
+                        m.model_dump(mode="json"), use_bin_type=True
+                    )
+                    rows.append(
+                        (
+                            thread_id,
+                            seq,
+                            _role_of(m),
+                            json.dumps(m.metadata),
+                            payload,
+                        )
+                    )
                 await conn.executemany(
                     "INSERT INTO cubepi_messages "
                     "(thread_id, seq, role, metadata, payload) "

cubepi/checkpointer/postgres/models.py

@@ -5,6 +5,7 @@
 they use. SQLAlchemy 2.0 declarative is the chosen style for cubepi
 internal definitions.
 """
+
 from __future__ import annotations
 
 import datetime as _dt
@@ -35,7 +36,9 @@ class CubepiThread(CubepiBase):
     )
     forked_at_seq: Mapped[int | None] = mapped_column(sa.BigInteger, nullable=True)
     extra: Mapped[dict[str, Any]] = mapped_column(
-        JSONB, nullable=False, server_default=sa.text("'{}'::jsonb"),
+        JSONB,
+        nullable=False,
+        server_default=sa.text("'{}'::jsonb"),
     )
     created_at: Mapped[_dt.datetime] = mapped_column(
         sa.TIMESTAMP(timezone=True),

cubepi/mcp/__init__.py

@@ -2,6 +2,7 @@
 
 cubepi[mcp] extra required.
 """
+
 from cubepi.mcp.http_loader import load_mcp_tools_http
 from cubepi.mcp.stdio_loader import load_mcp_tools_stdio
 

cubepi/mcp/_adapter.py

@@ -1,4 +1,5 @@
 """MCP tool descriptor → cubepi.AgentTool adapter."""
+
 from __future__ import annotations
 
 from typing import Any, Awaitable, Callable
@@ -67,7 +68,8 @@ def make_mcp_agent_tool(
         {"content": [{"type": "text", "text": ...}, ...], "isError": bool}
     """
     parameters_model = mcp_schema_to_pydantic_model(
-        tool_name=name, input_schema=input_schema,
+        tool_name=name,
+        input_schema=input_schema,
     )
 
     async def _execute(args) -> AgentToolResult:

cubepi/mcp/http_loader.py

@@ -1,4 +1,5 @@
 """HTTP/SSE transport MCP tool loader."""
+
 from __future__ import annotations
 
 from typing import Any
@@ -48,7 +49,7 @@ async def _call_remote(tool_name: str, args: dict[str, Any]) -> dict[str, Any]:
 def _serialize_call_tool_response(resp: Any) -> dict[str, Any]:
     """Normalize mcp SDK CallToolResult → dict for adapter."""
     content = []
-    for c in (resp.content or []):
+    for c in resp.content or []:
         if getattr(c, "type", None) == "text":
             content.append({"type": "text", "text": c.text})
     return {

cubepi/mcp/stdio_loader.py

@@ -1,4 +1,5 @@
 """stdio transport MCP tool loader."""
+
 from __future__ import annotations
 
 from typing import Any
@@ -31,7 +32,10 @@ async def load_mcp_tools_stdio(
     from mcp.client.stdio import stdio_client
 
     server_params = StdioServerParameters(
-        command=command, args=args, env=env, cwd=cwd,
+        command=command,
+        args=args,
+        env=env,
+        cwd=cwd,
     )
 
     async def _call_remote(tool_name: str, args_dict: dict[str, Any]) -> dict[str, Any]:
@@ -60,7 +64,7 @@ async def _call_remote(tool_name: str, args_dict: dict[str, Any]) -> dict[str, A
 
 def _serialize_call_tool_response(resp: Any) -> dict[str, Any]:
     content = []
-    for c in (resp.content or []):
+    for c in resp.content or []:
         if getattr(c, "type", None) == "text":
             content.append({"type": "text", "text": c.text})
     return {

cubepi/providers/anthropic.py

@@ -69,7 +69,9 @@ def __init__(
 
         self._client = anthropic.AsyncAnthropic(api_key=api_key)
         self._cache_retention = cache_retention
-        self._cache_policy: CacheMarkerPolicy = cache_policy or DefaultCacheMarkerPolicy()
+        self._cache_policy: CacheMarkerPolicy = (
+            cache_policy or DefaultCacheMarkerPolicy()
+        )
 
     async def stream(
         self,
@@ -219,7 +221,11 @@ def _apply_indices_markers(
                         content[-1] = {**last_block, "cache_control": cache_control}
                 elif isinstance(content, str):
                     msg["content"] = [
-                        {"type": "text", "text": content, "cache_control": cache_control}
+                        {
+                            "type": "text",
+                            "text": content,
+                            "cache_control": cache_control,
+                        }
                     ]
 
     @staticmethod

tests/checkpointer/test_postgres.py

@@ -13,6 +13,7 @@ def test_models_import() -> None:
         CubepiThread,
         cubepi_metadata,
     )
+
     assert EXPECTED_SCHEMA_VERSION == 1
     assert PARTITION_COUNT == 64
     # All three model classes are reachable via the public model module
@@ -45,15 +46,21 @@ def test_cubepi_message_has_gin_index() -> None:
 
 
 def test_create_message_partitions_op_yields_64_statements() -> None:
-    from cubepi.checkpointer.postgres.alembic_helpers import create_message_partitions_op
+    from cubepi.checkpointer.postgres.alembic_helpers import (
+        create_message_partitions_op,
+    )
+
     sql = create_message_partitions_op()
     assert sql.count("CREATE TABLE cubepi_messages_p") == 64
     assert "modulus 64, remainder 0" in sql
     assert "modulus 64, remainder 63" in sql
 
 
 def test_create_message_partitions_op_partitions_are_zero_padded() -> None:
-    from cubepi.checkpointer.postgres.alembic_helpers import create_message_partitions_op
+    from cubepi.checkpointer.postgres.alembic_helpers import (
+        create_message_partitions_op,
+    )
+
     sql = create_message_partitions_op()
     # Partition names use 2-digit padding so they sort lexicographically
     assert "cubepi_messages_p00 " in sql
@@ -62,6 +69,7 @@ def test_create_message_partitions_op_partitions_are_zero_padded() -> None:
 
 def test_write_schema_version_op_includes_expected_version() -> None:
     from cubepi.checkpointer.postgres.alembic_helpers import write_schema_version_op
+
     sql = write_schema_version_op()
     assert "INSERT INTO cubepi_schema_version" in sql
     assert "VALUES (1)" in sql
@@ -73,12 +81,14 @@ def test_schema_uninitialized_is_schema_error() -> None:
         CubepiSchemaError,
         CubepiSchemaUninitialized,
     )
+
     err = CubepiSchemaUninitialized("tables missing")
     assert isinstance(err, CubepiSchemaError)
 
 
 def test_schema_mismatch_carries_expected_actual() -> None:
     from cubepi.checkpointer.postgres.exceptions import CubepiSchemaMismatch
+
     err = CubepiSchemaMismatch(expected=2, actual=1, hint="run alembic")
     assert err.expected == 2
     assert err.actual == 1
@@ -89,6 +99,7 @@ def test_schema_mismatch_carries_expected_actual() -> None:
 
 def test_schema_mismatch_without_hint() -> None:
     from cubepi.checkpointer.postgres.exceptions import CubepiSchemaMismatch
+
     err = CubepiSchemaMismatch(expected=2, actual=1)
     # No hint suffix
     assert "expected=2" in str(err)
@@ -132,6 +143,7 @@ async def _setup_schema(dsn: str) -> None:
             create_message_partitions_op,
             write_schema_version_op,
         )
+
         await conn.execute(create_message_partitions_op())
         await conn.execute("""
             CREATE INDEX ix_cubepi_messages_metadata_gin
@@ -152,7 +164,10 @@ async def test_postgres_checkpointer_round_trip(clean_db) -> None:
     """Append + load round-trips messages with metadata."""
     from cubepi.checkpointer.postgres import PostgresCheckpointer
     from cubepi.providers.base import (
-        AssistantMessage, TextContent, Usage, UserMessage,
+        AssistantMessage,
+        TextContent,
+        Usage,
+        UserMessage,
     )
 
     await _setup_schema(clean_db)

tests/mcp/_fake_stdio_server.py

@@ -4,6 +4,7 @@
 
 Run as: python -m tests.mcp._fake_stdio_server
 """
+
 import asyncio