refactor(types): Phase 4 type hint sweep — core modules

api_hook_client.py

@@ -1,14 +1,16 @@
+from __future__ import annotations
 import requests
 import json
 import time
+from typing import Any
 
 class ApiHookClient:
- def __init__(self, base_url="http://127.0.0.1:8999", max_retries=5, retry_delay=0.2):
+ def __init__(self, base_url: str = "http://127.0.0.1:8999", max_retries: int = 5, retry_delay: float = 0.2) -> None:
   self.base_url = base_url
   self.max_retries = max_retries
   self.retry_delay = retry_delay
 
- def wait_for_server(self, timeout=3):
+ def wait_for_server(self, timeout: float = 3) -> bool:
   """
         Polls the /status endpoint until the server is ready or timeout is reached.
         """
@@ -21,7 +23,7 @@ class ApiHookClient:
     time.sleep(0.1)
   return False
 
- def _make_request(self, method, endpoint, data=None, timeout=None):
+ def _make_request(self, method: str, endpoint: str, data: dict | None = None, timeout: float | None = None) -> dict | None:
   url = f"{self.base_url}{endpoint}"
   headers = {'Content-Type': 'application/json'}
   last_exception = None
@@ -54,7 +56,7 @@ class ApiHookClient:
   if last_exception:
    raise last_exception
 
- def get_status(self):
+ def get_status(self) -> dict:
   """Checks the health of the hook server."""
   url = f"{self.base_url}/status"
   try:
@@ -64,37 +66,37 @@ class ApiHookClient:
   except Exception:
    raise requests.exceptions.ConnectionError(f"Could not reach /status at {self.base_url}")
 
- def get_project(self):
+ def get_project(self) -> dict | None:
   return self._make_request('GET', '/api/project')
 
- def post_project(self, project_data):
+ def post_project(self, project_data: dict) -> dict | None:
   return self._make_request('POST', '/api/project', data={'project': project_data})
 
- def get_session(self):
+ def get_session(self) -> dict | None:
   return self._make_request('GET', '/api/session')
 
- def get_mma_status(self):
+ def get_mma_status(self) -> dict | None:
   """Retrieves current MMA status (track, tickets, tier, etc.)"""
   return self._make_request('GET', '/api/gui/mma_status')
 
- def push_event(self, event_type, payload):
+ def push_event(self, event_type: str, payload: dict) -> dict | None:
   """Pushes an event to the GUI's AsyncEventQueue via the /api/gui endpoint."""
   return self.post_gui({
     "action": event_type,
     "payload": payload
    })
 
- def get_performance(self):
+ def get_performance(self) -> dict | None:
   """Retrieves UI performance metrics."""
   return self._make_request('GET', '/api/performance')
 
- def post_session(self, session_entries):
+ def post_session(self, session_entries: list) -> dict | None:
   return self._make_request('POST', '/api/session', data={'session': {'entries': session_entries}})
 
- def post_gui(self, gui_data):
+ def post_gui(self, gui_data: dict) -> dict | None:
   return self._make_request('POST', '/api/gui', data=gui_data)
 
- def select_tab(self, tab_bar, tab):
+ def select_tab(self, tab_bar: str, tab: str) -> dict | None:
   """Tells the GUI to switch to a specific tab in a tab bar."""
   return self.post_gui({
     "action": "select_tab",
@@ -102,7 +104,7 @@ class ApiHookClient:
     "tab": tab
    })
 
- def select_list_item(self, listbox, item_value):
+ def select_list_item(self, listbox: str, item_value: str) -> dict | None:
   """Tells the GUI to select an item in a listbox by its value."""
   return self.post_gui({
     "action": "select_list_item",
@@ -110,7 +112,7 @@ class ApiHookClient:
     "item_value": item_value
    })
 
- def set_value(self, item, value):
+ def set_value(self, item: str, value: Any) -> dict | None:
   """Sets the value of a GUI item."""
   return self.post_gui({
     "action": "set_value",
@@ -118,7 +120,7 @@ class ApiHookClient:
     "value": value
    })
 
- def get_value(self, item):
+ def get_value(self, item: str) -> Any:
   """Gets the value of a GUI item via its mapped field."""
   try:
   # First try direct field querying via POST
@@ -156,12 +158,12 @@ class ApiHookClient:
    pass
   return None
 
- def get_text_value(self, item_tag):
+ def get_text_value(self, item_tag: str) -> str | None:
   """Wraps get_value and returns its string representation, or None."""
   val = self.get_value(item_tag)
   return str(val) if val is not None else None
 
- def get_node_status(self, node_tag):
+ def get_node_status(self, node_tag: str) -> Any:
   """Wraps get_value for a DAG node or queries the diagnostic endpoint for its status."""
   val = self.get_value(node_tag)
   if val is not None:
@@ -176,7 +178,7 @@ class ApiHookClient:
    pass
   return None
 
- def click(self, item, *args, **kwargs):
+ def click(self, item: str, *args: Any, **kwargs: Any) -> dict | None:
   """Simulates a click on a GUI button or item."""
   user_data = kwargs.pop('user_data', None)
   return self.post_gui({
@@ -187,7 +189,7 @@ class ApiHookClient:
     "user_data": user_data
    })
 
- def get_indicator_state(self, tag):
+ def get_indicator_state(self, tag: str) -> dict:
   """Checks if an indicator is shown using the diagnostics endpoint."""
   # Mapping tag to the keys used in diagnostics endpoint
   mapping = {
@@ -202,14 +204,14 @@ class ApiHookClient:
   except Exception as e:
    return {"tag": tag, "shown": False, "error": str(e)}
 
- def get_events(self):
+ def get_events(self) -> list:
   """Fetches and clears the event queue from the server."""
   try:
    return self._make_request('GET', '/api/events').get("events", [])
   except Exception:
    return []
 
- def wait_for_event(self, event_type, timeout=5):
+ def wait_for_event(self, event_type: str, timeout: float = 5) -> dict | None:
   """Polls for a specific event type."""
   start = time.time()
   while time.time() - start < timeout:
@@ -220,7 +222,7 @@ class ApiHookClient:
    time.sleep(0.1) # Fast poll
   return None
 
- def wait_for_value(self, item, expected, timeout=5):
+ def wait_for_value(self, item: str, expected: Any, timeout: float = 5) -> bool:
   """Polls until get_value(item) == expected."""
   start = time.time()
   while time.time() - start < timeout:
@@ -229,11 +231,11 @@ class ApiHookClient:
    time.sleep(0.1) # Fast poll
   return False
 
- def reset_session(self):
+ def reset_session(self) -> dict | None:
   """Simulates clicking the 'Reset Session' button in the GUI."""
   return self.click("btn_reset")
 
- def request_confirmation(self, tool_name, args):
+ def request_confirmation(self, tool_name: str, args: dict) -> Any:
   """Asks the user for confirmation via the GUI (blocking call)."""
   # Using a long timeout as this waits for human input (60 seconds)
   res = self._make_request('POST', '/api/ask',