fix: resolve all linting and formatting errors

- Fix unused imports in baselines, benchmarks, and ingest modules
- Fix ambiguous variable names (renamed 'l' to 'loss'/'line')
- Add missing time import in benchmarks/cli.py
- Move warnings import to top of file in benchmarks/cli.py
- Add noqa comments for intentional code patterns
- Fix bare except clause in lambda_labs.py
- Add Episode to TYPE_CHECKING imports in grounding.py
- Rename conflicting local variable in config.py
- Fix undefined _build_nav_links in viewer.py
- Run ruff format to ensure consistent code style

All ruff checks now pass successfully.

Author: abrichr

openadapt_ml/baselines/adapter.py

@@ -8,7 +8,7 @@
 import os
 from typing import TYPE_CHECKING, Any
 
-from openadapt_ml.baselines.config import BaselineConfig, TrackConfig, get_model_spec
+from openadapt_ml.baselines.config import BaselineConfig, TrackConfig
 from openadapt_ml.baselines.parser import ParsedAction, UnifiedResponseParser
 from openadapt_ml.baselines.prompts import PromptBuilder
 from openadapt_ml.config import settings

openadapt_ml/baselines/cli.py

@@ -8,11 +8,10 @@
 import json
 import sys
 from pathlib import Path
-from typing import Any
 
 import click
 
-from openadapt_ml.baselines.config import MODELS, TrackConfig, TrackType
+from openadapt_ml.baselines.config import MODELS
 
 
 @click.group()
@@ -23,35 +22,41 @@ def baselines():
 
 @baselines.command()
 @click.option(
-    "--model", "-m",
+    "--model",
+    "-m",
     required=True,
     type=click.Choice(list(MODELS.keys())),
     help="Model alias to use",
 )
 @click.option(
-    "--track", "-t",
+    "--track",
+    "-t",
     type=click.Choice(["A", "B", "C"]),
     default="A",
     help="Evaluation track (A=coords, B=ReAct, C=SoM)",
 )
 @click.option(
-    "--image", "-i",
+    "--image",
+    "-i",
     type=click.Path(exists=True),
     required=True,
     help="Screenshot image path",
 )
 @click.option(
-    "--goal", "-g",
+    "--goal",
+    "-g",
     required=True,
     help="Task goal/instruction",
 )
 @click.option(
-    "--output", "-o",
+    "--output",
+    "-o",
     type=click.Path(),
     help="Output JSON file path",
 )
 @click.option(
-    "--verbose", "-v",
+    "--verbose",
+    "-v",
     is_flag=True,
     help="Enable verbose output",
 )
@@ -122,7 +127,9 @@ def run(
             click.echo(f"Thought: {action.thought}")
     else:
         click.echo(f"Parse Error: {action.parse_error}")
-        click.echo(f"Raw Response: {action.raw_response[:200] if action.raw_response else 'None'}...")
+        click.echo(
+            f"Raw Response: {action.raw_response[:200] if action.raw_response else 'None'}..."
+        )
 
     # Save output if requested
     if output:
@@ -140,29 +147,34 @@ def run(
 
 @baselines.command()
 @click.option(
-    "--models", "-m",
+    "--models",
+    "-m",
     required=True,
     help="Comma-separated model aliases",
 )
 @click.option(
-    "--track", "-t",
+    "--track",
+    "-t",
     type=click.Choice(["A", "B", "C"]),
     default="A",
     help="Evaluation track",
 )
 @click.option(
-    "--image", "-i",
+    "--image",
+    "-i",
     type=click.Path(exists=True),
     required=True,
     help="Screenshot image path",
 )
 @click.option(
-    "--goal", "-g",
+    "--goal",
+    "-g",
     required=True,
     help="Task goal/instruction",
 )
 @click.option(
-    "--output", "-o",
+    "--output",
+    "-o",
     type=click.Path(),
     help="Output JSON file path",
 )
@@ -221,23 +233,27 @@ def compare(
             adapter = UnifiedBaselineAdapter.from_alias(model, track=track_config)
             action = adapter.predict(screenshot, goal)
 
-            results.append({
-                "model": model,
-                "success": action.is_valid,
-                "action": action.to_dict(),
-                "error": action.parse_error,
-            })
+            results.append(
+                {
+                    "model": model,
+                    "success": action.is_valid,
+                    "action": action.to_dict(),
+                    "error": action.parse_error,
+                }
+            )
 
             status = "OK" if action.is_valid else "FAILED"
             click.echo(f"  {status}: {action.action_type}")
 
         except Exception as e:
-            results.append({
-                "model": model,
-                "success": False,
-                "action": None,
-                "error": str(e),
-            })
+            results.append(
+                {
+                    "model": model,
+                    "success": False,
+                    "action": None,
+                    "error": str(e),
+                }
+            )
             click.echo(f"  ERROR: {e}")
 
     # Summary table

openadapt_ml/baselines/parser.py

@@ -72,9 +72,7 @@ def add_element(
     ) -> None:
         """Add an element to the registry."""
         eid = int(element_id) if isinstance(element_id, str) else element_id
-        self.elements[eid] = UIElement(
-            element_id=eid, role=role, name=name, bbox=bbox
-        )
+        self.elements[eid] = UIElement(element_id=eid, role=role, name=name, bbox=bbox)
 
     def get_element(self, element_id: int) -> UIElement | None:
         """Get element by ID."""
@@ -137,7 +135,9 @@ def process_node(node: dict[str, Any]) -> None:
             node_id = node.get("id", node.get("node_id", node.get("element_id")))
             if node_id is not None:
                 try:
-                    eid = int(str(node_id).replace("e", "").replace("[", "").replace("]", ""))
+                    eid = int(
+                        str(node_id).replace("e", "").replace("[", "").replace("]", "")
+                    )
                     bbox = node.get("bbox", node.get("bounds"))
                     if bbox and len(bbox) >= 4:
                         registry.add_element(
@@ -277,7 +277,9 @@ def to_pyautogui(
                 py = int(self.y * screen_height)
                 return f"pyautogui.click({px}, {py})"
             elif self.element_id is not None:
-                return f"# CLICK element {self.element_id} (needs coordinate conversion)"
+                return (
+                    f"# CLICK element {self.element_id} (needs coordinate conversion)"
+                )
         elif self.action_type == "type":
             text = self.text or ""
             return f"pyautogui.write('{text}')"
@@ -444,10 +446,10 @@ def _try_json_parse(self, response: str) -> ParsedAction:
         """Try to extract and parse JSON from response."""
         # Try to find JSON object in response
         json_patterns = [
-            r'```json\s*(\{[^`]*\})\s*```',  # Markdown code block
-            r'```\s*(\{[^`]*\})\s*```',       # Plain code block
-            r'(\{[^{}]*\})',                  # Simple JSON object
-            r'(\{[^{}]*\{[^{}]*\}[^{}]*\})',  # Nested JSON (max 1 level)
+            r"```json\s*(\{[^`]*\})\s*```",  # Markdown code block
+            r"```\s*(\{[^`]*\})\s*```",  # Plain code block
+            r"(\{[^{}]*\})",  # Simple JSON object
+            r"(\{[^{}]*\{[^{}]*\}[^{}]*\})",  # Nested JSON (max 1 level)
         ]
 
         for pattern in json_patterns:
@@ -621,7 +623,7 @@ def _try_pyautogui_parse(self, response: str) -> ParsedAction:
         """Try to parse PyAutoGUI-style code."""
         # pyautogui.click(x, y)
         click_match = re.search(
-            r'pyautogui\.click\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)',
+            r"pyautogui\.click\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -633,7 +635,7 @@ def _try_pyautogui_parse(self, response: str) -> ParsedAction:
 
         # pyautogui.doubleClick(x, y)
         dclick_match = re.search(
-            r'pyautogui\.doubleClick\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)',
+            r"pyautogui\.doubleClick\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -668,7 +670,7 @@ def _try_pyautogui_parse(self, response: str) -> ParsedAction:
 
         # pyautogui.hotkey('key1', 'key2')
         hotkey_match = re.search(
-            r'pyautogui\.hotkey\s*\(\s*(.+?)\s*\)',
+            r"pyautogui\.hotkey\s*\(\s*(.+?)\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -687,7 +689,7 @@ def _try_pyautogui_parse(self, response: str) -> ParsedAction:
 
         # pyautogui.scroll(amount)
         scroll_match = re.search(
-            r'pyautogui\.scroll\s*\(\s*(-?\d+)\s*\)',
+            r"pyautogui\.scroll\s*\(\s*(-?\d+)\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -700,13 +702,15 @@ def _try_pyautogui_parse(self, response: str) -> ParsedAction:
                 amount=abs(clicks),
             )
 
-        return ParsedAction(action_type="unknown", parse_error="No PyAutoGUI pattern matched")
+        return ParsedAction(
+            action_type="unknown", parse_error="No PyAutoGUI pattern matched"
+        )
 
     def _try_regex_parse(self, response: str) -> ParsedAction:
         """Try regex patterns for function-style actions."""
         # CLICK(x, y) - normalized coordinates
         click_norm = re.search(
-            r'CLICK\s*\(\s*(0?\.\d+)\s*,\s*(0?\.\d+)\s*\)',
+            r"CLICK\s*\(\s*(0?\.\d+)\s*,\s*(0?\.\d+)\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -719,7 +723,7 @@ def _try_regex_parse(self, response: str) -> ParsedAction:
 
         # CLICK(x, y) - larger numbers (pixels)
         click_pixel = re.search(
-            r'CLICK\s*\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*\)',
+            r"CLICK\s*\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -731,7 +735,7 @@ def _try_regex_parse(self, response: str) -> ParsedAction:
 
         # CLICK([id]) - element ID
         click_element = re.search(
-            r'CLICK\s*\(\s*\[\s*(\d+)\s*\]\s*\)',
+            r"CLICK\s*\(\s*\[\s*(\d+)\s*\]\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -743,7 +747,7 @@ def _try_regex_parse(self, response: str) -> ParsedAction:
 
         # CLICK(id) without brackets
         click_id = re.search(
-            r'CLICK\s*\(\s*(\d+)\s*\)',
+            r"CLICK\s*\(\s*(\d+)\s*\)",
             response,
             re.IGNORECASE,
         )
@@ -764,50 +768,65 @@ def _try_regex_parse(self, response: str) -> ParsedAction:
 
         # KEY(key) or KEY(mod+key)
         key_match = re.search(
-            r'KEY\s*\(\s*([a-zA-Z0-9_+]+)\s*\)',
+            r"KEY\s*\(\s*([a-zA-Z0-9_+]+)\s*\)",
             response,
             re.IGNORECASE,
         )
         if key_match:
             key_str = key_match.group(1).lower()
-            if '+' in key_str:
-                parts = key_str.split('+')
+            if "+" in key_str:
+                parts = key_str.split("+")
                 modifiers = parts[:-1]
                 key = parts[-1]
                 return ParsedAction(action_type="key", key=key, modifiers=modifiers)
             return ParsedAction(action_type="key", key=key_str)
 
         # SCROLL(direction) or SCROLL(direction, amount)
         scroll_match = re.search(
-            r'SCROLL\s*\(\s*([a-zA-Z]+)(?:\s*,\s*(\d+))?\s*\)',
+            r"SCROLL\s*\(\s*([a-zA-Z]+)(?:\s*,\s*(\d+))?\s*\)",
             response,
             re.IGNORECASE,
         )
         if scroll_match:
             direction = scroll_match.group(1).lower()
             amount = int(scroll_match.group(2)) if scroll_match.group(2) else 3
-            return ParsedAction(action_type="scroll", direction=direction, amount=amount)
+            return ParsedAction(
+                action_type="scroll", direction=direction, amount=amount
+            )
 
-        return ParsedAction(action_type="unknown", parse_error="No regex pattern matched")
+        return ParsedAction(
+            action_type="unknown", parse_error="No regex pattern matched"
+        )
 
     def _try_keyword_parse(self, response: str) -> ParsedAction:
         """Try special keywords."""
         response_upper = response.upper().strip()
 
         # DONE() or just DONE
-        if re.search(r'\bDONE\s*\(\s*\)\s*$', response, re.IGNORECASE) or response_upper == "DONE":
+        if (
+            re.search(r"\bDONE\s*\(\s*\)\s*$", response, re.IGNORECASE)
+            or response_upper == "DONE"
+        ):
             return ParsedAction(action_type="done")
 
         # WAIT() or WAIT
-        if re.search(r'\bWAIT\s*\(\s*\)\s*$', response, re.IGNORECASE) or response_upper == "WAIT":
+        if (
+            re.search(r"\bWAIT\s*\(\s*\)\s*$", response, re.IGNORECASE)
+            or response_upper == "WAIT"
+        ):
             return ParsedAction(action_type="wait")
 
         # FAIL() or FAIL
-        if re.search(r'\bFAIL\s*\(\s*\)\s*$', response, re.IGNORECASE) or response_upper == "FAIL":
+        if (
+            re.search(r"\bFAIL\s*\(\s*\)\s*$", response, re.IGNORECASE)
+            or response_upper == "FAIL"
+        ):
             return ParsedAction(action_type="fail")
 
         # Look for "task is complete" or similar phrases
-        if re.search(r'task\s+(?:is\s+)?(?:complete|done|finished)', response, re.IGNORECASE):
+        if re.search(
+            r"task\s+(?:is\s+)?(?:complete|done|finished)", response, re.IGNORECASE
+        ):
             return ParsedAction(
                 action_type="done",
                 confidence=0.7,
@@ -842,7 +861,7 @@ def _normalize_element_id(self, element_id: Any) -> int | None:
 
         if isinstance(element_id, str):
             # Extract number from "e17", "[17]", "element_17" etc.
-            match = re.search(r'\d+', element_id)
+            match = re.search(r"\d+", element_id)
             if match:
                 return int(match.group())
 

openadapt_ml/baselines/prompts.py

@@ -758,7 +758,9 @@ def build_verification_prompt(
         """
         content: list[dict[str, Any]] = []
 
-        action_str = self._format_single_action(0, previous_action.get("type", ""), previous_action)
+        action_str = self._format_single_action(
+            0, previous_action.get("type", ""), previous_action
+        )
         action_str = action_str[3:]  # Remove "0. " prefix
 
         text = textwrap.dedent(f"""