ruff fmt

Author: luke-beamcloud

examples/workflows.py

@@ -23,7 +23,7 @@ class Progress(LoopEvent):
     step: int
 
 
-def on_block_done(ctx: LoopContext, block: WorkflowBlock, payload: dict | None):
+def on_block_done(_ctx: LoopContext, block: WorkflowBlock, _payload: dict | None):
     print(f"  ✓ Block complete: {block.type}")
 
 
@@ -44,7 +44,7 @@ def on_error(ctx: LoopContext, block: WorkflowBlock, error: Exception):
 )
 async def onboarding_workflow(
     ctx: LoopContext,
-    blocks: list[WorkflowBlock],
+    _blocks: list[WorkflowBlock],
     current_block: WorkflowBlock,
 ):
     await ctx.emit(Progress(message=current_block.text, step=ctx.block_index + 1))
@@ -92,19 +92,19 @@ async def on_stop(self, ctx: LoopContext) -> None:
         print(f"[{ctx.loop_id}] Survey completed")
 
     async def on_block_complete(
-        self, ctx: LoopContext, block: WorkflowBlock, payload: dict | None
+        self, _ctx: LoopContext, block: WorkflowBlock, _payload: dict | None
     ) -> None:
         print(f"  ✓ Survey step complete: {block.type}")
 
     async def on_error(
-        self, ctx: LoopContext, block: WorkflowBlock, error: Exception
+        self, _ctx: LoopContext, _block: WorkflowBlock, error: Exception
     ) -> None:
         print(f"  ✗ Survey error: {error}")
 
     async def execute(
         self,
         ctx: LoopContext,
-        blocks: list[WorkflowBlock],
+        _blocks: list[WorkflowBlock],
         current_block: WorkflowBlock,
     ) -> None:
         print(f"[{ctx.block_index + 1}/{ctx.block_count}] {current_block.type}")

fastloop/loop.py

@@ -49,7 +49,7 @@ async def on_start(self, ctx: "LoopContext") -> None:
     async def on_stop(self, ctx: "LoopContext") -> None:
         pass
 
-    async def on_app_start(self, ctx: "LoopContext") -> bool:
+    async def on_app_start(self, _ctx: "LoopContext") -> bool:
         return True
 
     async def on_event(self, ctx: "LoopContext", event: "LoopEvent") -> None:

tests/test_class_based_loops.py

@@ -15,7 +15,7 @@
 
 import pytest
 
-from fastloop import FastLoop, Loop, LoopContext
+from fastloop import FastLoop, Loop
 from fastloop.loop import LoopEvent
 
 
@@ -327,7 +327,7 @@ async def loop(self, ctx):
 
     def test_function_loop_can_be_imported(self):
         """Function-based loop paths should be importable."""
-        from fastloop.utils import get_func_import_path, import_func_from_path
+        from fastloop.utils import get_func_import_path
 
         app = FastLoop(name="test-app")
         app.register_event(SampleEvent)

tests/test_workflow_integration.py

@@ -27,7 +27,7 @@ def mock_state():
     workflows = {}
 
     @asynccontextmanager
-    async def mock_claim(wid):
+    async def mock_claim(_wid):
         yield
 
     async def get_workflow(wid):
@@ -57,7 +57,7 @@ class Start(LoopEvent):
         pass
 
     @app.workflow(name="test", start_event=Start)
-    async def test_workflow(ctx, blocks, block):
+    async def test_workflow(ctx, _blocks, _block):
         ctx.next()
 
     return app
@@ -121,7 +121,7 @@ async def test_next_advances_blocks(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, block):
             executed.append(block.type)
             ctx.next()
 
@@ -145,7 +145,7 @@ async def test_repeat_stays_on_block(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, _block):
             count[0] += 1
             if count[0] < 3:
                 ctx.repeat()
@@ -171,7 +171,7 @@ async def test_normal_return_stops(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        async def func(ctx, blocks, block):
+        async def func(_ctx, _blocks, block):
             executed.append(block.type)
 
         wm = WorkflowManager(mock_state)
@@ -191,7 +191,7 @@ async def test_next_passes_payload(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, _block):
             ctx.next({"key": "value"})
 
         ctx = MagicMock()
@@ -219,10 +219,10 @@ async def test_on_block_complete_called(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        def on_complete(ctx, block, payload):
+        def on_complete(_ctx, block, _payload):
             completed.append(block.type)
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, _block):
             ctx.next()
 
         ctx = MagicMock()
@@ -245,10 +245,10 @@ async def test_on_block_complete_on_normal_return(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        def on_complete(ctx, block, payload):
+        def on_complete(_ctx, block, _payload):
             completed.append(block.type)
 
-        async def func(ctx, blocks, block):
+        async def func(_ctx, _blocks, _block):
             pass
 
         wm = WorkflowManager(mock_state)
@@ -267,10 +267,10 @@ async def test_on_error_called(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        def on_error(ctx, block, error):
+        def on_error(_ctx, block, error):
             errors.append((block.type, str(error)))
 
-        async def func(ctx, blocks, block):
+        async def func(_ctx, _blocks, _block):
             raise ValueError("boom")
 
         wm = WorkflowManager(mock_state)
@@ -298,11 +298,11 @@ async def test_on_error_can_retry(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        def on_error(ctx, block, error):
+        def on_error(ctx, _block, _error):
             if attempts[0] < 3:
                 ctx.repeat()
 
-        async def func(ctx, blocks, block):
+        async def func(_ctx, _blocks, _block):
             attempts[0] += 1
             if attempts[0] < 3:
                 raise ValueError("transient error")
@@ -339,7 +339,7 @@ async def test_block_position(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, _block):
             captured.append(
                 {
                     "index": ctx.block_index,
@@ -379,7 +379,7 @@ async def test_resumes_from_block_index(self, mock_state):
         )
         mock_state._workflows["test"] = workflow
 
-        async def func(ctx, blocks, block):
+        async def func(_ctx, _blocks, block):
             executed.append(block.type)
 
         wm = WorkflowManager(mock_state)
@@ -392,10 +392,10 @@ async def test_ctx_state_persists(self, mock_state):
         """ctx.set/get persists state."""
         stored = {}
 
-        async def set_val(wid, key, val):
+        async def set_val(_wid, key, val):
             stored[key] = val
 
-        async def get_val(wid, key):
+        async def get_val(_wid, key):
             return stored.get(key)
 
         mock_state.set_context_value = set_val
@@ -533,7 +533,7 @@ async def test_workflow_resumes_from_persisted_state(self, state_manager):
         workflow.status = LoopStatus.RUNNING
         await state_manager.update_workflow(workflow.workflow_id, workflow)
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, block):
             executed.append(block.type)
             ctx.next()
 
@@ -587,7 +587,7 @@ def mock_state_with_persistence(self):
         workflows = {}
 
         @asynccontextmanager
-        async def mock_claim(wid):
+        async def mock_claim(_wid):
             yield
 
         async def get_workflow(wid):
@@ -614,7 +614,7 @@ async def test_retry_with_backoff(self, mock_state_with_persistence):
 
         attempts = []
 
-        async def failing_func(ctx, blocks, block):
+        async def failing_func(ctx, _blocks, _block):
             attempts.append(time.time())
             if len(attempts) < 3:
                 raise ValueError("Transient error")
@@ -650,7 +650,7 @@ async def failing_func(ctx, blocks, block):
     async def test_workflow_fails_after_max_retries(self, mock_state_with_persistence):
         """Workflow status set to FAILED after max retries."""
 
-        async def always_fails(ctx, blocks, block):
+        async def always_fails(_ctx, _blocks, _block):
             raise ValueError("Always fails")
 
         workflow = WorkflowState(

tests/test_workflows.py

@@ -43,7 +43,7 @@ def mock_state():
     workflows = {}
 
     @asynccontextmanager
-    async def mock_claim(wid):
+    async def mock_claim(_wid):
         yield
 
     async def get_workflow(wid):
@@ -234,7 +234,7 @@ def test_class_based_workflow(self):
 
         @app.workflow("myworkflow", start_event=StartEvent)
         class MyWorkflow(Workflow):
-            async def execute(self, ctx, blocks, block):
+            async def execute(self, ctx, _blocks, _block):
                 ctx.next()
 
         assert "myworkflow" in app._workflow_metadata
@@ -267,7 +267,7 @@ class TestWorkflowManager:
     async def test_normal_return_stops(self, mock_state):
         called = []
 
-        async def func(ctx, blocks, block):
+        async def func(_ctx, _blocks, block):
             called.append(block.type)
 
         workflow = WorkflowState(
@@ -295,7 +295,7 @@ async def test_next_advances(self, mock_state):
 
         executed = []
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, block):
             executed.append(block.type)
             ctx.next()
 
@@ -311,7 +311,7 @@ async def func(ctx, blocks, block):
     async def test_repeat_stays(self, mock_state):
         count = [0]
 
-        async def func(ctx, blocks, block):
+        async def func(ctx, _blocks, _block):
             count[0] += 1
             if count[0] < 3:
                 ctx.repeat()
@@ -363,7 +363,7 @@ def mock_state_with_update(self):
         workflows = {}
 
         @asynccontextmanager
-        async def mock_claim(wid):
+        async def mock_claim(_wid):
             yield
 
         async def get_workflow(wid):
@@ -384,7 +384,7 @@ async def update_workflow(wid, w):
     async def test_retry_on_error(self, mock_state_with_update):
         attempts = [0]
 
-        async def failing_func(ctx, blocks, block):
+        async def failing_func(ctx, _blocks, _block):
             attempts[0] += 1
             if attempts[0] < 3:
                 raise ValueError("Test error")
@@ -416,11 +416,11 @@ async def test_max_retries_exhausted(self, mock_state_with_update):
         error_callback_called = [False]
         max_retries_error_received = [None]
 
-        async def always_failing(ctx, blocks, block):
+        async def always_failing(_ctx, _blocks, _block):
             attempts[0] += 1
             raise ValueError("Always fails")
 
-        async def on_error(ctx, block, error):
+        async def on_error(_ctx, _block, error):
             if isinstance(error, WorkflowMaxRetriesError):
                 error_callback_called[0] = True
                 max_retries_error_received[0] = error
@@ -452,7 +452,7 @@ async def on_error(ctx, block, error):
     async def test_skips_completed_blocks(self, mock_state_with_update):
         executed_blocks = []
 
-        async def track_blocks(ctx, blocks, block):
+        async def track_blocks(ctx, _blocks, block):
             executed_blocks.append(block.type)
             ctx.next()