ruff

Author: Rafael Pierre

docs/scripts/generate_ref_files.py

@@ -31,6 +31,7 @@ def md_target(py_path: Path) -> Path:
     rel = py_path.relative_to(SRC_ROOT).with_suffix(".md")
     return DOCS_ROOT / rel
 
+
 def pretty_title(last_segment: str) -> str:
     """
     Convert a module/file segment like 'tool_context' to 'Tool Context'.
@@ -39,6 +40,7 @@ def pretty_title(last_segment: str) -> str:
     cleaned = last_segment.replace("_", " ").replace("-", " ")
     return capwords(cleaned)
 
+
 # ---- Main ------------------------------------------------------------
 
 

examples/realtime/cli/demo.py

@@ -52,7 +52,7 @@ def __init__(self) -> None:
         # Audio output state for callback system
         self.output_queue: queue.Queue[Any] = queue.Queue(maxsize=10)  # Buffer more chunks
         self.interrupt_event = threading.Event()
-        self.current_audio_chunk: np.ndarray | None = None  # type: ignore
+        self.current_audio_chunk: np.ndarray | None = None
         self.chunk_position = 0
 
     def _output_callback(self, outdata, frames: int, time, status) -> None:

tests/test_redis_session.py

@@ -53,7 +53,7 @@ async def test_init(self, redis_session):
         assert redis_session.messages_key == "test_messages:test_session_123"
         assert redis_session._redis_client is None
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_redis_client(self, mock_from_url, redis_session, mock_redis):
         """Test Redis client creation."""
         mock_from_url.return_value = mock_redis
@@ -66,12 +66,14 @@ async def test_get_redis_client(self, mock_from_url, redis_session, mock_redis):
             "redis://localhost:6379",
             db=0,
             decode_responses=True,
-            retry_on_error=[redis_session._get_redis_client.__globals__['redis'].BusyLoadingError,
-                           redis_session._get_redis_client.__globals__['redis'].ConnectionError],
+            retry_on_error=[
+                redis_session._get_redis_client.__globals__["redis"].BusyLoadingError,
+                redis_session._get_redis_client.__globals__["redis"].ConnectionError,
+            ],
             retry_on_timeout=True,
         )
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_redis_client_reuse(self, mock_from_url, redis_session, mock_redis):
         """Test that Redis client is reused."""
         mock_from_url.return_value = mock_redis
@@ -82,7 +84,7 @@ async def test_get_redis_client_reuse(self, mock_from_url, redis_session, mock_r
         assert client == mock_redis
         mock_from_url.assert_not_called()
 
-    @patch('agents.memory.providers.redis.time.time')
+    @patch("agents.memory.providers.redis.time.time")
     async def test_ensure_session_exists_new_session(self, mock_time, redis_session, mock_redis):
         """Test creating new session metadata."""
         mock_time.return_value = 1234567890.0
@@ -102,7 +104,7 @@ async def test_ensure_session_exists_new_session(self, mock_time, redis_session,
                 "session_id": "test_session_123",
                 "created_at": "1234567890.0",
                 "updated_at": "1234567890.0",
-            }
+            },
         )
         mock_redis.expire.assert_any_call("test_session:test_session_123", 3600)
 
@@ -115,20 +117,18 @@ async def test_ensure_session_exists_existing_session(self, redis_session, mock_
         mock_redis.hset.assert_not_called()
         assert mock_redis.expire.call_count == 2  # TTL set for both keys
 
-    @patch('agents.memory.providers.redis.time.time')
+    @patch("agents.memory.providers.redis.time.time")
     async def test_update_session_timestamp(self, mock_time, redis_session, mock_redis):
         """Test updating session timestamp."""
         mock_time.return_value = 1234567890.0
 
         await redis_session._update_session_timestamp(mock_redis)
 
         mock_redis.hset.assert_called_once_with(
-            "test_session:test_session_123",
-            "updated_at",
-            "1234567890.0"
+            "test_session:test_session_123", "updated_at", "1234567890.0"
         )
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_items_no_limit(self, mock_from_url, redis_session, mock_redis, sample_items):
         """Test retrieving all items without limit."""
         mock_from_url.return_value = mock_redis
@@ -139,7 +139,7 @@ async def test_get_items_no_limit(self, mock_from_url, redis_session, mock_redis
         mock_redis.lrange.assert_called_once_with("test_messages:test_session_123", 0, -1)
         assert items == sample_items
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_items_with_limit(
         self, mock_from_url, redis_session, mock_redis, sample_items
     ):
@@ -152,7 +152,7 @@ async def test_get_items_with_limit(
         mock_redis.lrange.assert_called_once_with("test_messages:test_session_123", -2, -1)
         assert items == sample_items[-2:]
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_items_empty_list(self, mock_from_url, redis_session, mock_redis):
         """Test retrieving items from empty session."""
         mock_from_url.return_value = mock_redis
@@ -162,7 +162,7 @@ async def test_get_items_empty_list(self, mock_from_url, redis_session, mock_red
 
         assert items == []
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_items_invalid_json(
         self, mock_from_url, redis_session, mock_redis, sample_items
     ):
@@ -171,16 +171,16 @@ async def test_get_items_invalid_json(
         mock_redis.lrange.return_value = [
             json.dumps(sample_items[0]),
             "invalid json",
-            json.dumps(sample_items[1])
+            json.dumps(sample_items[1]),
         ]
 
         items = await redis_session.get_items()
 
         # Should skip invalid JSON and return valid items
         assert items == [sample_items[0], sample_items[1]]
 
-    @patch('agents.memory.providers.redis.redis.from_url')
-    @patch('agents.memory.providers.redis.time.time')
+    @patch("agents.memory.providers.redis.redis.from_url")
+    @patch("agents.memory.providers.redis.time.time")
     async def test_add_items(
         self, mock_time, mock_from_url, redis_session, mock_redis, sample_items
     ):
@@ -200,19 +200,16 @@ async def test_add_items(
 
         # Verify pipeline operations
         mock_pipeline.rpush.assert_called_once_with(
-            "test_messages:test_session_123",
-            *[json.dumps(item) for item in sample_items]
+            "test_messages:test_session_123", *[json.dumps(item) for item in sample_items]
         )
         mock_pipeline.hset.assert_called_once_with(
-            "test_session:test_session_123",
-            "updated_at",
-            "1234567890.0"
+            "test_session:test_session_123", "updated_at", "1234567890.0"
         )
         mock_pipeline.expire.assert_any_call("test_session:test_session_123", 3600)
         mock_pipeline.expire.assert_any_call("test_messages:test_session_123", 3600)
         mock_pipeline.execute.assert_called_once()
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_add_items_empty_list(self, mock_from_url, redis_session, mock_redis):
         """Test adding empty list of items."""
         mock_from_url.return_value = mock_redis
@@ -222,7 +219,7 @@ async def test_add_items_empty_list(self, mock_from_url, redis_session, mock_red
         # Should not call Redis operations for empty list
         mock_redis.pipeline.assert_not_called()
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_pop_item(self, mock_from_url, redis_session, mock_redis, sample_items):
         """Test popping most recent item."""
         mock_from_url.return_value = mock_redis
@@ -235,7 +232,7 @@ async def test_pop_item(self, mock_from_url, redis_session, mock_redis, sample_i
         redis_session._update_session_timestamp.assert_called_once_with(mock_redis)
         assert item == sample_items[-1]
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_pop_item_empty_session(self, mock_from_url, redis_session, mock_redis):
         """Test popping from empty session."""
         mock_from_url.return_value = mock_redis
@@ -247,7 +244,7 @@ async def test_pop_item_empty_session(self, mock_from_url, redis_session, mock_r
         assert item is None
         redis_session._update_session_timestamp.assert_not_called()
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_pop_item_invalid_json(self, mock_from_url, redis_session, mock_redis):
         """Test popping item with invalid JSON."""
         mock_from_url.return_value = mock_redis
@@ -259,26 +256,25 @@ async def test_pop_item_invalid_json(self, mock_from_url, redis_session, mock_re
         assert item is None
         redis_session._update_session_timestamp.assert_called_once_with(mock_redis)
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_clear_session(self, mock_from_url, redis_session, mock_redis):
         """Test clearing session data."""
         mock_from_url.return_value = mock_redis
 
         await redis_session.clear_session()
 
         mock_redis.delete.assert_called_once_with(
-            "test_session:test_session_123",
-            "test_messages:test_session_123"
+            "test_session:test_session_123", "test_messages:test_session_123"
         )
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_session_info(self, mock_from_url, redis_session, mock_redis):
         """Test retrieving session metadata."""
         mock_from_url.return_value = mock_redis
         expected_info = {
             "session_id": "test_session_123",
             "created_at": "1234567890.0",
-            "updated_at": "1234567890.0"
+            "updated_at": "1234567890.0",
         }
         mock_redis.hgetall.return_value = expected_info
 
@@ -287,7 +283,7 @@ async def test_get_session_info(self, mock_from_url, redis_session, mock_redis):
         mock_redis.hgetall.assert_called_once_with("test_session:test_session_123")
         assert info == expected_info
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_session_info_not_exists(self, mock_from_url, redis_session, mock_redis):
         """Test retrieving session metadata when session doesn't exist."""
         mock_from_url.return_value = mock_redis
@@ -297,7 +293,7 @@ async def test_get_session_info_not_exists(self, mock_from_url, redis_session, m
 
         assert info is None
 
-    @patch('agents.memory.providers.redis.redis.from_url')
+    @patch("agents.memory.providers.redis.redis.from_url")
     async def test_get_session_size(self, mock_from_url, redis_session, mock_redis):
         """Test getting session message count."""
         mock_from_url.return_value = mock_redis