universal-mcp 0.1.15rc7__py3-none-any.whl → 0.1.16__py3-none-any.whl

universal_mcp/tools/manager.py

@@ -115,9 +115,7 @@ class ToolManager:
                         f"Tool name '{tool.name}' conflicts with an existing tool. Skipping addition of new function."
                     )
                 else:
-                    logger.debug(
-                        f"Tool '{tool.name}' with the same function already exists."
-                    )
+                    logger.debug(f"Tool '{tool.name}' with the same function already exists.")
             return existing
 
         logger.debug(f"Adding tool: {tool.name}")
@@ -170,9 +168,7 @@ class ToolManager:
             return
 
         if not isinstance(functions, list):
-            logger.error(
-                f"App '{app.name}' list_tools() did not return a list. Skipping registration."
-            )
+            logger.error(f"App '{app.name}' list_tools() did not return a list. Skipping registration.")
             return
 
         tools = []
@@ -183,18 +179,12 @@ class ToolManager:
 
             try:
                 tool_instance = Tool.from_function(function)
-                tool_instance.name = (
-                    f"{app.name}{TOOL_NAME_SEPARATOR}{tool_instance.name}"
-                )
-                tool_instance.tags.append(
-                    app.name
-                ) if app.name not in tool_instance.tags else None
+                tool_instance.name = f"{app.name}{TOOL_NAME_SEPARATOR}{tool_instance.name}"
+                tool_instance.tags.append(app.name) if app.name not in tool_instance.tags else None
                 tools.append(tool_instance)
             except Exception as e:
                 tool_name = getattr(function, "__name__", "unknown")
-                logger.error(
-                    f"Failed to create Tool from '{tool_name}' in {app.name}: {e}"
-                )
+                logger.error(f"Failed to create Tool from '{tool_name}' in {app.name}: {e}")
 
         tools = _filter_by_name(tools, tool_names)
         tools = _filter_by_tags(tools, tags)

universal_mcp/tools/tools.py

@@ -20,20 +20,15 @@ class Tool(BaseModel):
     args_description: dict[str, str] = Field(
         default_factory=dict, description="Descriptions of arguments from the docstring"
     )
-    returns_description: str = Field(
-        default="", description="Description of the return value from the docstring"
-    )
+    returns_description: str = Field(default="", description="Description of the return value from the docstring")
     raises_description: dict[str, str] = Field(
         default_factory=dict,
         description="Descriptions of exceptions raised from the docstring",
     )
-    tags: list[str] = Field(
-        default_factory=list, description="Tags for categorizing the tool"
-    )
+    tags: list[str] = Field(default_factory=list, description="Tags for categorizing the tool")
     parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
     fn_metadata: FuncMetadata = Field(
-        description="Metadata about the function including a pydantic model for tool"
-        " arguments"
+        description="Metadata about the function including a pydantic model for tool arguments"
     )
     is_async: bool = Field(description="Whether the tool is async")
 
@@ -55,9 +50,7 @@ class Tool(BaseModel):
 
         is_async = inspect.iscoroutinefunction(fn)
 
-        func_arg_metadata = FuncMetadata.func_metadata(
-            fn, arg_description=parsed_doc["args"]
-        )
+        func_arg_metadata = FuncMetadata.func_metadata(fn, arg_description=parsed_doc["args"])
         parameters = func_arg_metadata.arg_model.model_json_schema()
 
         return cls(

universal_mcp/utils/agentr.py

@@ -26,9 +26,7 @@ class AgentrClient(metaclass=Singleton):
                 "API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable."
             )
             raise ValueError("AgentR API key required - get one at https://agentr.dev")
-        self.base_url = (
-            base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
-        ).rstrip("/")
+        self.base_url = (base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")).rstrip("/")
 
     def get_credentials(self, integration_name: str) -> dict:
         """Get credentials for an integration from the AgentR API.
@@ -48,9 +46,7 @@ class AgentrClient(metaclass=Singleton):
             headers={"accept": "application/json", "X-API-KEY": self.api_key},
         )
         if response.status_code == 404:
-            logger.warning(
-                f"No credentials found for {integration_name}. Requesting authorization..."
-            )
+            logger.warning(f"No credentials found for {integration_name}. Requesting authorization...")
             action = self.get_authorization_url(integration_name)
             raise NotAuthorizedError(action)
         response.raise_for_status()

universal_mcp/utils/common.py

@@ -3,7 +3,7 @@ def get_default_repository_path(slug: str) -> str:
     Convert a repository slug to a repository URL.
     """
     slug = slug.strip().lower()
-    return f"git+https://github.com/universal-mcp/{slug}"
+    return f"universal-mcp-{slug}"
 
 
 def get_default_package_name(slug: str) -> str:

universal_mcp/utils/docstring_parser.py

@@ -81,17 +81,13 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
         elif stripped_lower.startswith(("raises ", "errors ", "exceptions ")):
             section_type = "raises"
             # Capture content after header word and potential colon/space
-            parts = re.split(
-                r"[:\s]+", line.strip(), maxsplit=1
-            )  # B034: Use keyword maxsplit
+            parts = re.split(r"[:\s]+", line.strip(), maxsplit=1)  # B034: Use keyword maxsplit
             if len(parts) > 1:
                 header_content = parts[1].strip()
         elif stripped_lower.startswith(("tags",)):
             section_type = "tags"
             # Capture content after header word and potential colon/space
-            parts = re.split(
-                r"[:\s]+", line.strip(), maxsplit=1
-            )  # B034: Use keyword maxsplit
+            parts = re.split(r"[:\s]+", line.strip(), maxsplit=1)  # B034: Use keyword maxsplit
             if len(parts) > 1:
                 header_content = parts[1].strip()
 
@@ -117,9 +113,7 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
         stripped_line = line.strip()
         original_indentation = len(line) - len(line.lstrip(" "))
 
-        is_new_section_header, new_section_type_this_line, header_content_this_line = (
-            check_for_section_header(line)
-        )
+        is_new_section_header, new_section_type_this_line, header_content_this_line = check_for_section_header(line)
 
         should_finalize_previous = False
 
@@ -156,10 +150,7 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
             or (
                 current_section in ["args", "raises"]
                 and current_key is not None
-                and (
-                    key_pattern.match(line)
-                    or (original_indentation == 0 and stripped_line)
-                )
+                and (key_pattern.match(line) or (original_indentation == 0 and stripped_line))
             )
             or (
                 current_section in ["returns", "tags", "other"]

universal_mcp/utils/installation.py

@@ -7,19 +7,30 @@ from loguru import logger
 from rich import print
 
 
-def get_uvx_path() -> str:
+def get_uvx_path() -> Path:
     """Get the full path to the uv executable."""
     uvx_path = shutil.which("uvx")
-    if not uvx_path:
-        logger.error(
-            "uvx executable not found in PATH, falling back to 'uvx'. "
-            "Please ensure uvx is installed and in your PATH"
-        )
-        return "uvx"  # Fall back to just "uvx" if not found
-    return uvx_path
-
-
-def create_file_if_not_exists(path: Path) -> None:
+    if uvx_path:
+        return Path(uvx_path)
+
+    # Check if
+    common_uv_paths = [
+        Path.home() / ".local/bin/uvx",  # Linux/macOS
+        Path.home() / ".cargo/bin/uvx",  # Linux/macOS
+        Path.home() / "AppData/Local/Programs/uvx/uvx.exe",  # Windows
+        Path.home() / "AppData/Roaming/uvx/uvx.exe",  # Windows
+    ]
+    for path in common_uv_paths:
+        logger.info(f"Checking {path}")
+        if path.exists():
+            return path
+    logger.error(
+        "uvx executable not found in PATH, falling back to 'uvx'. Please ensure uvx is installed and in your PATH"
+    )
+    return None  # Fall back to just "uvx" if not found
+
+
+def _create_file_if_not_exists(path: Path) -> None:
     """Create a file if it doesn't exist"""
     if not path.exists():
         print(f"[yellow]Creating config file at {path}[/yellow]")
@@ -27,6 +38,34 @@ def create_file_if_not_exists(path: Path) -> None:
             json.dump({}, f)
 
 
+def _generate_mcp_config(api_key: str) -> None:
+    uvx_path = get_uvx_path()
+    if not uvx_path:
+        raise ValueError("uvx executable not found in PATH")
+    return {
+        "command": str(uvx_path),
+        "args": ["universal_mcp@latest", "run"],
+        "env": {
+            "AGENTR_API_KEY": api_key,
+            "PATH": str(uvx_path.parent),
+        },
+    }
+
+
+def _install_config(config_path: Path, mcp_config: dict):
+    _create_file_if_not_exists(config_path)
+    try:
+        config = json.loads(config_path.read_text())
+    except json.JSONDecodeError:
+        print("[yellow]Config file was empty or invalid, creating new configuration[/yellow]")
+        config = {}
+    if "mcpServers" not in config:
+        config["mcpServers"] = {}
+    config["mcpServers"]["universal_mcp"] = mcp_config
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=4)
+
+
 def get_supported_apps() -> list[str]:
     """Get list of supported apps"""
     return ["claude", "cursor", "cline", "continue", "goose", "windsurf", "zed"]
@@ -37,35 +76,17 @@ def install_claude(api_key: str) -> None:
     print("[bold blue]Installing Claude configuration...[/bold blue]")
     # Determine platform-specific config path
     if sys.platform == "darwin":  # macOS
-        config_path = (
-            Path.home()
-            / "Library/Application Support/Claude/claude_desktop_config.json"
-        )
+        config_path = Path.home() / "Library/Application Support/Claude/claude_desktop_config.json"
     elif sys.platform == "win32":  # Windows
         config_path = Path.home() / "AppData/Roaming/Claude/claude_desktop_config.json"
     else:
         raise ValueError(
             "Unsupported platform. Only macOS and Windows are currently supported.",
         )
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    logger.info(f"Installing Claude configuration at {config_path}")
+    logger.info(f"Config: {mcp_config}")
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Claude configuration installed successfully")
 
 
@@ -74,28 +95,8 @@ def install_cursor(api_key: str) -> None:
     print("[bold blue]Installing Cursor configuration...[/bold blue]")
     # Set up Cursor config path
     config_path = Path.home() / ".cursor/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Cursor configuration installed successfully")
 
 
@@ -104,28 +105,8 @@ def install_cline(api_key: str) -> None:
     print("[bold blue]Installing Cline configuration...[/bold blue]")
     # Set up Cline config path
     config_path = Path.home() / ".config/cline/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Cline configuration installed successfully")
 
 
@@ -140,28 +121,8 @@ def install_continue(api_key: str) -> None:
         config_path = Path.home() / "AppData/Roaming/Continue/mcp.json"
     else:  # Linux and others
         config_path = Path.home() / ".config/continue/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Continue configuration installed successfully")
 
 
@@ -177,27 +138,8 @@ def install_goose(api_key: str) -> None:
     else:  # Linux and others
         config_path = Path.home() / ".config/goose/mcp-config.json"
 
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Goose configuration installed successfully")
 
 
@@ -212,28 +154,8 @@ def install_windsurf(api_key: str) -> None:
         config_path = Path.home() / "AppData/Roaming/Windsurf/mcp.json"
     else:  # Linux and others
         config_path = Path.home() / ".config/windsurf/mcp.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if "mcpServers" not in config:
-        config["mcpServers"] = {}
-    config["mcpServers"]["universal_mcp"] = {
-        "command": get_uvx_path(),
-        "args": ["universal_mcp@latest", "run"],
-        "env": {"AGENTR_API_KEY": api_key},
-    }
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Windsurf configuration installed successfully")
 
 
@@ -244,47 +166,8 @@ def install_zed(api_key: str) -> None:
     # Set up Zed config path
     config_dir = Path.home() / ".config/zed"
     config_path = config_dir / "mcp_servers.json"
-
-    # Create config directory if it doesn't exist
-    create_file_if_not_exists(config_path)
-
-    try:
-        config = json.loads(config_path.read_text())
-    except json.JSONDecodeError:
-        print(
-            "[yellow]Config file was empty or invalid, creating new configuration[/yellow]"
-        )
-        config = {}
-
-    if not isinstance(config, list):
-        config = []
-
-    # Check if universal_mcp is already in the config
-    existing_config = False
-    for server in config:
-        if server.get("name") == "universal_mcp":
-            existing_config = True
-            server.update(
-                {
-                    "command": get_uvx_path(),
-                    "args": ["universal_mcp@latest", "run"],
-                    "env": {"AGENTR_API_KEY": api_key},
-                }
-            )
-            break
-
-    if not existing_config:
-        config.append(
-            {
-                "name": "universal_mcp",
-                "command": get_uvx_path(),
-                "args": ["universal_mcp@latest", "run"],
-                "env": {"AGENTR_API_KEY": api_key},
-            }
-        )
-
-    with open(config_path, "w") as f:
-        json.dump(config, f, indent=4)
+    mcp_config = _generate_mcp_config(api_key=api_key)
+    _install_config(config_path=config_path, mcp_config=mcp_config)
     print("[green]✓[/green] Zed configuration installed successfully")
 
 

universal_mcp/utils/openapi/api_generator.py

@@ -109,9 +109,7 @@ def generate_api_from_schema(
         f.write(code)
 
     if not test_correct_output(gen_file):
-        logger.error(
-            "Generated code validation failed for '%s'. Aborting generation.", gen_file
-        )
+        logger.error("Generated code validation failed for '%s'. Aborting generation.", gen_file)
         logger.info("Next steps:")
         logger.info(" 1) Review your OpenAPI schema for potential mismatches.")
         logger.info(

universal_mcp/utils/openapi/docgen.py

@@ -19,12 +19,8 @@ from pydantic import BaseModel, Field
 class DocstringOutput(BaseModel):
     """Structure for the generated docstring output."""
 
-    summary: str = Field(
-        description="A clear, concise summary of what the function does"
-    )
-    args: dict[str, str] = Field(
-        description="Dictionary mapping parameter names to their descriptions"
-    )
+    summary: str = Field(description="A clear, concise summary of what the function does")
+    args: dict[str, str] = Field(description="Dictionary mapping parameter names to their descriptions")
     returns: str = Field(description="Description of what the function returns")
     raises: dict[str, str] = Field(
         default_factory=dict,
@@ -44,9 +40,7 @@ class FunctionExtractor(ast.NodeVisitor):
 
     def __init__(self, source_code: str):
         self.source_lines = source_code.splitlines(keepends=True)
-        self.functions: list[
-            tuple[str, str]
-        ] = []  # Store tuples of (function_name, function_source)
+        self.functions: list[tuple[str, str]] = []  # Store tuples of (function_name, function_source)
 
     def _get_source_segment(self, node: ast.AST) -> str | None:
         """Safely extracts the source segment for a node using ast.get_source_segment."""
@@ -110,9 +104,7 @@ def extract_functions_from_script(file_path: str) -> list[tuple[str, str]]:
     try:
         tree = ast.parse(source_code, filename=file_path)
     except SyntaxError as e:
-        print(
-            f"Error: Invalid Python syntax in {file_path} at line {e.lineno}, offset {e.offset}: {e.msg}"
-        )
+        print(f"Error: Invalid Python syntax in {file_path} at line {e.lineno}, offset {e.offset}: {e.msg}")
         raise
     except Exception as e:
         print(f"Error parsing {file_path} into AST: {e}")
@@ -175,9 +167,7 @@ def extract_json_from_text(text):
         raise ValueError("Could not extract valid JSON from the response") from e
 
 
-def generate_docstring(
-    function_code: str, model: str = "perplexity/sonar"
-) -> DocstringOutput:
+def generate_docstring(function_code: str, model: str = "perplexity/sonar") -> DocstringOutput:
     """
     Generate a docstring for a Python function using litellm with structured output.
 
@@ -239,9 +229,7 @@ def generate_docstring(
             parsed_data = extract_json_from_text(response_text)
         except ValueError as e:
             print(f"JSON extraction failed: {e}")
-            print(
-                f"Raw response: {response_text[:100]}..."
-            )  # Log first 100 chars for debugging
+            print(f"Raw response: {response_text[:100]}...")  # Log first 100 chars for debugging
             # Return a default structure if extraction fails
             return DocstringOutput(
                 summary="Failed to extract docstring information",
@@ -291,20 +279,14 @@ def format_docstring(docstring: DocstringOutput) -> str:
     if summary:
         parts.append(summary)
 
-    filtered_args = {
-        name: desc
-        for name, desc in docstring.args.items()
-        if name not in ("self", "cls")
-    }
+    filtered_args = {name: desc for name, desc in docstring.args.items() if name not in ("self", "cls")}
     args_lines = []
     if filtered_args:
         args_lines.append("Args:")
         for arg_name, arg_desc in filtered_args.items():
             arg_desc_cleaned = arg_desc.strip()
             args_lines.append(f"    {arg_name}: {arg_desc_cleaned}")
-    elif docstring.args.get(
-        "None"
-    ):  # Include the 'None' placeholder if it was generated
+    elif docstring.args.get("None"):  # Include the 'None' placeholder if it was generated
         args_lines.append("Args:")
         none_desc_cleaned = docstring.args["None"].strip()
         args_lines.append(f"    None: {none_desc_cleaned}")
@@ -321,12 +303,8 @@ def format_docstring(docstring: DocstringOutput) -> str:
         raises_lines.append("Raises:")
         for exception_type, exception_desc in docstring.raises.items():
             exception_desc_cleaned = exception_desc.strip()
-            if (
-                exception_type.strip() and exception_desc_cleaned
-            ):  # Ensure type and desc are not empty
-                raises_lines.append(
-                    f"    {exception_type.strip()}: {exception_desc_cleaned}"
-                )
+            if exception_type.strip() and exception_desc_cleaned:  # Ensure type and desc are not empty
+                raises_lines.append(f"    {exception_type.strip()}: {exception_desc_cleaned}")
     if raises_lines:
         parts.append("\n".join(raises_lines))
 
@@ -363,9 +341,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
         lines = function_code.splitlines(keepends=True)
 
         tree = ast.parse(function_code)
-        if not tree.body or not isinstance(
-            tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef
-        ):
+        if not tree.body or not isinstance(tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef):
             print(
                 "Warning: Could not parse function definition from code snippet. Returning original code.",
                 file=sys.stderr,
@@ -399,15 +375,11 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
             if func_node.lineno - 1 < len(lines):  # Ensure def line exists
                 def_line = lines[func_node.lineno - 1]
                 def_line_indent = def_line[: len(def_line) - len(def_line.lstrip())]
-                body_indent = (
-                    def_line_indent + "    "
-                )  # Standard 4 spaces relative indent
+                body_indent = def_line_indent + "    "  # Standard 4 spaces relative indent
 
         # Format the new docstring lines with the calculated indentation
         new_docstring_lines_formatted = [f'{body_indent}"""\n']
-        new_docstring_lines_formatted.extend(
-            [f"{body_indent}{line}\n" for line in docstring.splitlines()]
-        )
+        new_docstring_lines_formatted.extend([f"{body_indent}{line}\n" for line in docstring.splitlines()])
         new_docstring_lines_formatted.append(f'{body_indent}"""\n')
 
         output_lines = []
@@ -425,10 +397,7 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
                 dummy_tree = ast.parse(dummy_code)
                 dummy_body_statements = (
                     dummy_tree.body[0].body
-                    if dummy_tree.body
-                    and isinstance(
-                        dummy_tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef
-                    )
+                    if dummy_tree.body and isinstance(dummy_tree.body[0], ast.FunctionDef | ast.AsyncFunctionDef)
                     else []
                 )
                 cleaned_body_parts = []
@@ -455,13 +424,9 @@ def insert_docstring_into_function(function_code: str, docstring: str) -> str:
 
                     if not is_just_string_stmt:
                         stmt_start_idx = stmt_node.lineno - 1
-                        stmt_end_idx = (
-                            stmt_node.end_lineno - 1
-                        )  # Inclusive end line index
+                        stmt_end_idx = stmt_node.end_lineno - 1  # Inclusive end line index
 
-                        cleaned_body_parts.extend(
-                            lines[stmt_start_idx : stmt_end_idx + 1]
-                        )
+                        cleaned_body_parts.extend(lines[stmt_start_idx : stmt_end_idx + 1])
 
                 if func_node.body:
                     last_stmt_end_idx = func_node.body[-1].end_lineno - 1
@@ -545,9 +510,7 @@ def process_file(file_path: str, model: str = "perplexity/sonar") -> int:
         formatted_docstring = format_docstring(docstring_output)
 
         # Insert docstring into function
-        updated_function = insert_docstring_into_function(
-            function_code, formatted_docstring
-        )
+        updated_function = insert_docstring_into_function(function_code, formatted_docstring)
 
         # Replace the function in the file content
         if updated_function != function_code: