fix: remove reformat

Author: dori

src/mcp_as_a_judge/db/cleanup_service.py

@@ -5,8 +5,6 @@
 removing least recently used sessions when session limits are exceeded.
 """
 
-
-
 from sqlalchemy import Engine, func
 from sqlmodel import Session, select
 
@@ -46,8 +44,6 @@ def __init__(self, engine: Engine) -> None:
         self.engine = engine
         self.max_total_sessions = MAX_TOTAL_SESSIONS
 
-
-
     def get_session_count(self) -> int:
         """
         Get the total number of unique sessions in the database.

src/mcp_as_a_judge/db/providers/sqlite_provider.py

@@ -30,7 +30,8 @@ class SQLiteProvider(ConversationHistoryDB):
     - SQLModel with SQLAlchemy for type safety
     - In-memory or file-based SQLite storage
     - Two-level cleanup strategy:
-      1. Session-based LRU cleanup (runs when new sessions are created, removes least recently used)
+      1. Session-based LRU cleanup (runs when new sessions are created,
+         removes least recently used)
       2. Per-session FIFO cleanup (max 20 records per session, runs on every save)
     - Session-based conversation retrieval
     """
@@ -81,12 +82,11 @@ def _create_tables(self) -> None:
         SQLModel.metadata.create_all(self.engine)
         logger.info("📋 Created conversation_history table with SQLModel")
 
-
-
     def _cleanup_excess_sessions(self) -> int:
         """
         Remove least recently used sessions when total sessions exceed limit.
-        This implements LRU cleanup to maintain session limit for better memory management.
+        This implements LRU cleanup to maintain session limit for better memory
+        management.
         Runs immediately when new sessions are created and limit is exceeded.
         """
         return self._cleanup_service.cleanup_excess_sessions()
@@ -105,8 +105,8 @@ def _cleanup_old_messages(self, session_id: str) -> int:
             current_count = len(current_records)
 
             logger.info(
-                f"🧹 FIFO cleanup check for session {session_id}: {current_count} records "
-                f"(max: {self._max_session_records})"
+                f"🧹 FIFO cleanup check for session {session_id}: "
+                f"{current_count} records (max: {self._max_session_records})"
             )
 
             if current_count <= self._max_session_records:
@@ -137,7 +137,8 @@ def _cleanup_old_messages(self, session_id: str) -> int:
             session.commit()
 
             logger.info(
-                f"✅ LRU cleanup completed: removed {len(old_records)} records from session {session_id}"
+                f"✅ LRU cleanup completed: removed {len(old_records)} records "
+                f"from session {session_id}"
             )
             return len(old_records)
 
@@ -187,7 +188,8 @@ async def save_conversation(
             logger.info(f"🆕 New session detected: {session_id}, running LRU cleanup")
             self._cleanup_excess_sessions()
 
-        # Per-session FIFO cleanup: maintain max 20 records per session (runs on every save)
+        # Per-session FIFO cleanup: maintain max 20 records per session
+        # (runs on every save)
         self._cleanup_old_messages(session_id)
 
         return record_id

tests/test_conversation_history_lifecycle.py

@@ -203,7 +203,9 @@ async def test_immediate_cleanup_integration(self):
         # Should still have only 2 sessions (LRU cleanup triggered)
         final_count = db._cleanup_service.get_session_count()
         assert final_count == 2
-        print(f"✅ After immediate LRU cleanup: {final_count} sessions (limit maintained)")
+        print(
+            f"✅ After immediate LRU cleanup: {final_count} sessions (limit maintained)"
+        )
 
     @pytest.mark.asyncio
     async def test_lru_session_cleanup_lifecycle(self):
@@ -242,7 +244,8 @@ async def test_lru_session_cleanup_lifecycle(self):
         )
         print("   Session A: Updated with recent activity (now most recently used)")
 
-        # Session D: Created fourth (should trigger cleanup, but Session A should be preserved)
+        # Session D: Created fourth (should trigger cleanup, but Session A
+        # should be preserved)
         await db.save_conversation("session_D", "tool1", "input1", "output1")
         print("   Session D: Created (cleanup triggered)")
 
@@ -252,24 +255,39 @@ async def test_lru_session_cleanup_lifecycle(self):
 
         # Verify automatic LRU cleanup happened (should be at limit of 3)
         current_count = db._cleanup_service.get_session_count()
-        assert current_count == 3, f"Expected 3 sessions after automatic cleanup, got {current_count}"
-        print(f"✅ Phase 1: Automatic LRU cleanup maintained limit - {current_count} sessions remain")
+        assert current_count == 3, (
+            f"Expected 3 sessions after automatic cleanup, got {current_count}"
+        )
+        print(
+            f"✅ Phase 1: Automatic LRU cleanup maintained limit - "
+            f"{current_count} sessions remain"
+        )
 
         # PHASE 2: Verify which sessions remain after automatic cleanup
         print("\n🔍 PHASE 2: Verifying remaining sessions after automatic cleanup...")
 
         # Check which sessions still exist
         remaining_sessions = []
-        for session_id in ["session_A", "session_B", "session_C", "session_D", "session_E"]:
+        for session_id in [
+            "session_A",
+            "session_B",
+            "session_C",
+            "session_D",
+            "session_E"
+        ]:
             records = await db.get_session_conversations(session_id)
             if records:
                 remaining_sessions.append(session_id)
 
         print(f"   Remaining sessions: {remaining_sessions}")
-        assert len(remaining_sessions) == 3, f"Expected 3 remaining sessions, got {len(remaining_sessions)}"
+        assert len(remaining_sessions) == 3, (
+            f"Expected 3 remaining sessions, got {len(remaining_sessions)}"
+        )
 
         # Session A should remain initially (preserved due to recent activity)
-        assert "session_A" in remaining_sessions, "Session A should remain initially (most recently used)"
+        assert "session_A" in remaining_sessions, (
+            "Session A should remain initially (most recently used)"
+        )
         print("✅ Phase 2: Session A initially preserved due to recent activity")
 
         # PHASE 3: Test that cleanup maintains the limit
@@ -280,8 +298,12 @@ async def test_lru_session_cleanup_lifecycle(self):
 
         # Should still be at limit
         final_count = db._cleanup_service.get_session_count()
-        assert final_count == 3, f"Expected 3 sessions after adding new session, got {final_count}"
-        print(f"✅ Phase 3: Session limit maintained at {final_count} after adding new session")
+        assert final_count == 3, (
+            f"Expected 3 sessions after adding new session, got {final_count}"
+        )
+        print(
+            f"✅ Phase 3: Session limit maintained at {final_count} after adding new session"
+        )
 
         # PHASE 4: Verify which sessions remain after adding session_F
         print("\n🔍 PHASE 4: Verifying final remaining sessions...")
@@ -303,14 +325,17 @@ async def test_lru_session_cleanup_lifecycle(self):
                 final_remaining_sessions.append(session_id)
                 last_activity = max(r.timestamp for r in records)
                 print(
-                    f"   ✅ {session_id}: {len(records)} records, last activity: {last_activity}"
+                    f"   ✅ {session_id}: {len(records)} records, "
+                    f"last activity: {last_activity}"
                 )
             else:
                 final_deleted_sessions.append(session_id)
                 print(f"   ❌ {session_id}: DELETED (was least recently used)")
 
         # Verify we have exactly 3 sessions
-        assert len(final_remaining_sessions) == 3, f"Expected 3 remaining sessions, got {len(final_remaining_sessions)}"
+        assert len(final_remaining_sessions) == 3, (
+            f"Expected 3 remaining sessions, got {len(final_remaining_sessions)}"
+        )
 
         # The 3 most recently used sessions should remain (D, E, F)
         # Session A gets removed because even though it was updated,
@@ -321,21 +346,28 @@ async def test_lru_session_cleanup_lifecycle(self):
             f"Expected {expected_remaining}, got {actual_remaining}"
         )
 
-        print("✅ Phase 4: LRU cleanup working correctly - most recent sessions preserved")
+        print(
+            "✅ Phase 4: LRU cleanup working correctly - most recent sessions preserved"
+        )
 
         # PHASE 5: Verify that LRU cleanup works correctly over time
         print("\n📊 PHASE 5: Verifying LRU behavior over time...")
 
         # Session A was initially preserved but then removed when Session F was created
         # This demonstrates that LRU is based on actual timestamps, not update sequence
         print("   - Session A was initially preserved due to recent activity")
-        print("   - Session A was later removed when newer sessions (D, E, F) became more recent")
+        print(
+            "   - Session A was later removed when newer sessions (D, E, F) "
+            "became more recent"
+        )
         print("   - This shows LRU is working correctly based on actual timestamps")
 
         print("\n🎯 IMMEDIATE LRU CLEANUP SUMMARY:")
         print("   - Cleanup happens immediately when new sessions are created")
         print("   - Session limit is maintained at all times (no daily delay)")
-        print("   - Most recently used sessions are preserved based on actual timestamps")
+        print(
+            "   - Most recently used sessions are preserved based on actual timestamps"
+        )
         print("   - LRU correctly removes sessions with older last activity times")
         print("   - LRU provides better UX than FIFO by preserving active sessions!")
         print("✅ Immediate LRU session cleanup lifecycle test PASSED!")