hatch fmt --check --fix

Author: kevinbackhouse

release_tools/copy_files.py

@@ -3,15 +3,16 @@
 
 import os
 import shutil
-import sys
 import subprocess
+import sys
+
 
 def read_file_list(list_path):
     """
     Reads a file containing file paths, ignoring empty lines and lines starting with '#'.
     Returns a list of relative file paths.
     """
-    with open(list_path, "r") as f:
+    with open(list_path) as f:
         lines = [line.strip() for line in f]
     return [line for line in lines if line and not line.startswith("#")]
 

release_tools/publish_docker.py

@@ -7,12 +7,13 @@
 import sys
 import tempfile
 
+
 def read_file_list(list_path):
     """
     Reads a file containing file paths, ignoring empty lines and lines starting with '#'.
     Returns a list of relative file paths.
     """
-    with open(list_path, "r") as f:
+    with open(list_path) as f:
         lines = [line.strip() for line in f]
     return [line for line in lines if line and not line.startswith("#")]
 

src/seclab_taskflow_agent/__main__.py

@@ -1,38 +1,45 @@
 # SPDX-FileCopyrightText: 2025 GitHub
 # SPDX-License-Identifier: MIT
 
-import asyncio
-from threading import Thread
 import argparse
-import os
-import sys
-from dotenv import load_dotenv
+import asyncio
+import json
 import logging
-from logging.handlers import RotatingFileHandler
-from pprint import pprint, pformat
+import os
+import pathlib
 import re
-import json
+import sys
 import uuid
-import pathlib
+from logging.handlers import RotatingFileHandler
+from pprint import pformat
+from typing import Callable
 
-from .agent import DEFAULT_MODEL, TaskRunHooks, TaskAgentHooks
-#from agents.run import DEFAULT_MAX_TURNS # XXX: this is 10, we need more than that
-from agents.exceptions import MaxTurnsExceeded, AgentsException
+from agents import Agent, RunContextWrapper, TContext, Tool
 from agents.agent import ModelSettings
-from agents.mcp import MCPServer, MCPServerStdio, MCPServerSse, MCPServerStreamableHttp, create_static_tool_filter
+
+#from agents.run import DEFAULT_MAX_TURNS # XXX: this is 10, we need more than that
+from agents.exceptions import AgentsException, MaxTurnsExceeded
 from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
-from agents import Tool, RunContextWrapper, TContext, Agent
-from openai import BadRequestError, APITimeoutError, RateLimitError
+from agents.mcp import MCPServerSse, MCPServerStdio, MCPServerStreamableHttp, create_static_tool_filter
+from dotenv import load_dotenv
+from openai import APITimeoutError, BadRequestError, RateLimitError
 from openai.types.responses import ResponseTextDeltaEvent
-from typing import Callable
 
-from .shell_utils import shell_tool_call
-from .mcp_utils import DEFAULT_MCP_CLIENT_SESSION_TIMEOUT, ReconnectingMCPServerStdio, AsyncDebugMCPServerStdio, MCPNamespaceWrap, mcp_client_params, mcp_system_prompt, StreamableMCPThread, compress_name
-from .render_utils import render_model_output, flush_async_output
-from .env_utils import TmpEnv
-from .agent import TaskAgent
-from .capi import list_tool_call_models
+from .agent import DEFAULT_MODEL, TaskAgent, TaskAgentHooks, TaskRunHooks
 from .available_tools import AvailableTools
+from .capi import list_tool_call_models
+from .env_utils import TmpEnv
+from .mcp_utils import (
+    DEFAULT_MCP_CLIENT_SESSION_TIMEOUT,
+    MCPNamespaceWrap,
+    ReconnectingMCPServerStdio,
+    StreamableMCPThread,
+    compress_name,
+    mcp_client_params,
+    mcp_system_prompt,
+)
+from .render_utils import flush_async_output, render_model_output
+from .shell_utils import shell_tool_call
 
 load_dotenv()
 
@@ -74,7 +81,7 @@ def parse_prompt_args(available_tools: AvailableTools,
         args = parser.parse_known_args(user_prompt.split(' ') if user_prompt else None)
     except SystemExit as e:
         if e.code == 2:
-            logging.error(f"User provided incomplete prompt: {user_prompt}")
+            logging.exception(f"User provided incomplete prompt: {user_prompt}")
             return None, None, None, help_msg
     p = args[0].p.strip() if args[0].p else None
     t = args[0].t.strip() if args[0].t else None
@@ -218,14 +225,13 @@ async def mcp_session_task(
                         except Exception as e:
                             print(f"Streamable mcp server process exception: {e}")
                 except asyncio.CancelledError:
-                    logging.error(f"Timeout on cleanup for mcp server: {server._name}")
+                    logging.exception(f"Timeout on cleanup for mcp server: {server._name}")
                 finally:
                     mcp_servers.remove(s)
         except RuntimeError as e:
-            logging.error(f"RuntimeError in mcp session task: {e}")
+            logging.exception(f"RuntimeError in mcp session task: {e}")
         except asyncio.CancelledError as e:
-            logging.error(f"Timeout on main session task: {e}")
-            pass
+            logging.exception(f"Timeout on main session task: {e}")
         finally:
             mcp_servers.clear()
 
@@ -318,17 +324,17 @@ async def _run_streamed():
                         return
                     except APITimeoutError:
                         if not max_retry:
-                            logging.error(f"Max retries for APITimeoutError reached")
+                            logging.exception("Max retries for APITimeoutError reached")
                             raise
                         max_retry -= 1
                     except RateLimitError:
                         if rate_limit_backoff == MAX_RATE_LIMIT_BACKOFF:
-                            raise APITimeoutError(f"Max rate limit backoff reached")
+                            raise APITimeoutError("Max rate limit backoff reached")
                         if rate_limit_backoff > MAX_RATE_LIMIT_BACKOFF:
                             rate_limit_backoff = MAX_RATE_LIMIT_BACKOFF
                         else:
                             rate_limit_backoff += rate_limit_backoff
-                        logging.error(f"Hit rate limit ... holding for {rate_limit_backoff}")
+                        logging.exception(f"Hit rate limit ... holding for {rate_limit_backoff}")
                         await asyncio.sleep(rate_limit_backoff)
             await _run_streamed()
             complete = True
@@ -338,22 +344,22 @@ async def _run_streamed():
             await render_model_output(f"** 🤖❗ Max Turns Reached: {e}\n",
                                 async_task=async_task,
                                 task_id=task_id)
-            logging.error(f"Exceeded max_turns: {max_turns}")
+            logging.exception(f"Exceeded max_turns: {max_turns}")
         except AgentsException as e:
             await render_model_output(f"** 🤖❗ Agent Exception: {e}\n",
                                 async_task=async_task,
                                 task_id=task_id)
-            logging.error(f"Agent Exception: {e}")
+            logging.exception(f"Agent Exception: {e}")
         except BadRequestError as e:
             await render_model_output(f"** 🤖❗ Request Error: {e}\n",
                                 async_task=async_task,
                                 task_id=task_id)
-            logging.error(f"Bad Request: {e}")
+            logging.exception(f"Bad Request: {e}")
         except APITimeoutError as e:
             await render_model_output(f"** 🤖❗ Timeout Error: {e}\n",
                                 async_task=async_task,
                                 task_id=task_id)
-            logging.error(f"Bad Request: {e}")
+            logging.exception(f"Bad Request: {e}")
 
         if async_task:
             await flush_async_output(task_id)
@@ -369,10 +375,10 @@ async def _run_streamed():
             try:
                 cleanup_attempts_left -= 1
                 await asyncio.wait_for(mcp_sessions, timeout=MCP_CLEANUP_TIMEOUT)
-            except asyncio.TimeoutError as e:
+            except asyncio.TimeoutError:
                 continue
             except Exception as e:
-                logging.error(f"Exception in mcp server cleanup task: {e}")
+                logging.exception(f"Exception in mcp server cleanup task: {e}")
 
 
 async def main(available_tools: AvailableTools,
@@ -425,7 +431,7 @@ async def on_handoff_hook(
             if model_dict:
                 if not isinstance(model_dict, dict):
                     raise ValueError(f"Models section of the model_config file {model_config} must be a dictionary")
-            model_keys = model_dict.keys() 
+            model_keys = model_dict.keys()
 
         for task in taskflow['taskflow']:
 
@@ -557,15 +563,15 @@ async def run_prompts(async_task=False, max_concurrent_tasks=5):
 
                     # if this is a shell task, execute that and append the results
                     if run:
-                        await render_model_output(f"** 🤖🐚 Executing Shell Task\n")
+                        await render_model_output("** 🤖🐚 Executing Shell Task\n")
                         # this allows e.g. shell based jq output to become available for repeat prompts
                         try:
                             result = shell_tool_call(run).content[0].model_dump_json()
                             last_mcp_tool_results.append(result)
                             return True
                         except RuntimeError as e:
                             await render_model_output(f"** 🤖❗ Shell Task Exception: {e}\n")
-                            logging.error(f"Shell task error: {e}")
+                            logging.exception(f"Shell task error: {e}")
                             return False
 
                     tasks = []

src/seclab_taskflow_agent/agent.py

@@ -2,20 +2,32 @@
 # SPDX-License-Identifier: MIT
 
 # https://openai.github.io/openai-agents-python/agents/
-import os
 import logging
-from dotenv import load_dotenv
+import os
 from collections.abc import Callable
 from typing import Any
 from urllib.parse import urlparse
 
+from agents import (
+    Agent,
+    AgentHooks,
+    OpenAIChatCompletionsModel,
+    RunContextWrapper,
+    RunHooks,
+    Runner,
+    TContext,
+    Tool,
+    result,
+    set_default_openai_api,
+    set_default_openai_client,
+    set_tracing_disabled,
+)
+from agents.agent import FunctionToolResult, ModelSettings, ToolsToFinalOutputResult
+from agents.run import DEFAULT_MAX_TURNS, RunHooks
+from dotenv import load_dotenv
 from openai import AsyncOpenAI
-from agents.agent import ModelSettings, ToolsToFinalOutputResult, FunctionToolResult
-from agents.run import DEFAULT_MAX_TURNS
-from agents.run import RunHooks
-from agents import Agent, Runner, AgentHooks, RunHooks, result, function_tool, Tool, RunContextWrapper, TContext, OpenAIChatCompletionsModel, set_default_openai_client, set_default_openai_api, set_tracing_disabled
 
-from .capi import COPILOT_INTEGRATION_ID, COPILOT_API_ENDPOINT
+from .capi import COPILOT_API_ENDPOINT, COPILOT_INTEGRATION_ID
 
 # grab our secrets from .env, this must be in .gitignore
 load_dotenv()

src/seclab_taskflow_agent/available_tools.py

@@ -1,11 +1,12 @@
 # SPDX-FileCopyrightText: 2025 GitHub
 # SPDX-License-Identifier: MIT
 
-from enum import Enum
-import logging
 import importlib.resources
+from enum import Enum
+
 import yaml
 
+
 class BadToolNameError(Exception):
     pass
 
@@ -74,7 +75,7 @@ def get_tool(self, tooltype: AvailableToolType, toolname: str):
                 version = header['version']
                 if version != 1:
                     raise VersionException(str(version))
-                filetype = header['filetype'] 
+                filetype = header['filetype']
                 if filetype != tooltype.value:
                     raise FileTypeException(
                         f'Error in {f}: expected filetype to be {tooltype}, but it\'s {filetype}.')

src/seclab_taskflow_agent/capi.py

@@ -2,12 +2,13 @@
 # SPDX-License-Identifier: MIT
 
 # CAPI specific interactions
-import httpx
 import json
 import logging
 import os
 from urllib.parse import urlparse
 
+import httpx
+
 # you can also set https://models.github.ai/inference if you prefer
 # but beware that your taskflows need to reference the correct model id
 # since the Modeld API uses it's own id schema, use -l with your desired
@@ -43,11 +44,11 @@ def list_capi_models(token: str) -> dict[str, dict]:
         for model in models_list:
             models[model.get('id')] = dict(model)
     except httpx.RequestError as e:
-        logging.error(f"Request error: {e}")
+        logging.exception(f"Request error: {e}")
     except json.JSONDecodeError as e:
-        logging.error(f"JSON error: {e}")
+        logging.exception(f"JSON error: {e}")
     except httpx.HTTPStatusError as e:
-        logging.error(f"HTTP error: {e}")
+        logging.exception(f"HTTP error: {e}")
     return models
 
 def supports_tool_calls(model: str, models: dict) -> bool:

src/seclab_taskflow_agent/env_utils.py

@@ -1,8 +1,9 @@
 # SPDX-FileCopyrightText: 2025 GitHub
 # SPDX-License-Identifier: MIT
 
-import re
 import os
+import re
+
 
 def swap_env(s):
     match = re.search(r"{{\s*(env)\s+([A-Z0-9_]+)\s*}}", s)

src/seclab_taskflow_agent/mcp_servers/codeql/client.py

@@ -2,15 +2,16 @@
 # SPDX-License-Identifier: MIT
 
 # a query-server2 codeql client
-import subprocess
-import re
 import json
-from pathlib import Path
+import os
+import re
+import subprocess
 import tempfile
 import time
-from urllib.parse import urlparse, unquote
-import os
 import zipfile
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
 import yaml
 
 # this is a local fork of https://github.com/riga/jsonrpyc modified for our purposes
@@ -46,7 +47,7 @@ def __init__(self,
         self.server_options = server_options.copy()
         if log_stderr:
             os.makedirs("logs", exist_ok=True)
-            self.stderr_log = f"logs/codeql_stderr_log.log"
+            self.stderr_log = "logs/codeql_stderr_log.log"
             self.server_options.append("--log-to-stderr")
         else:
             self.stderr_log = os.devnull
@@ -271,7 +272,7 @@ def _search_path(self):
 
     def _search_paths_from_codeql_config(self, config="~/.config/codeql/config"):
         try:
-            with open(config, 'r') as f:
+            with open(config) as f:
                 match = re.search(r"^--search-path(\s+|=)\s*(.*)", f.read())
                 if match and match.group(2):
                     return match.group(2).split(':')
@@ -530,7 +531,7 @@ def _file_from_src_archive(relative_path: str | Path, database_path: str | Path,
     # fall back to relative path if resolved_path does not exist (might be a build dep file)
     if str(resolved_path) not in files:
         resolved_path = Path(relative_path)
-    file_data = shell_command_to_string(["unzip", "-p", src_path, f"{str(resolved_path)}"])
+    file_data = shell_command_to_string(["unzip", "-p", src_path, f"{resolved_path!s}"])
     if region:
         def region_from_file():
             # regions are 1+ based and look like 1:2:3:4