universal-mcp 0.1.13rc7__py3-none-any.whl → 0.1.14__py3-none-any.whl

universal_mcp/utils/openapi.py

@@ -1,12 +1,65 @@
 import json
 import re
-from dataclasses import dataclass
+from functools import cache
 from pathlib import Path
 from typing import Any, Literal
 
 import yaml
-from jinja2 import Environment, FileSystemLoader, select_autoescape
-from loguru import logger
+from pydantic import BaseModel
+
+
+class Parameters(BaseModel):
+    name: str
+    identifier: str
+    description: str = ""
+    type: str = "string"
+    where: Literal["path", "query", "header", "body"]
+    required: bool
+    example: str | None = None
+
+    def __str__(self):
+        return f"{self.name}: ({self.type})"
+
+
+class Method(BaseModel):
+    name: str
+    summary: str
+    tags: list[str]
+    path: str
+    method: str
+    path_params: list[Parameters]
+    query_params: list[Parameters]
+    body_params: list[Parameters]
+    return_type: str
+
+    def deduplicate_params(self):
+        """
+        Deduplicate parameters by name.
+        Sometimes the same parameter is defined in multiple places, we only want to include it once.
+        """
+        # TODO: Implement this
+        pass
+
+    def render(self, template_dir: str, template_name: str = "method.jinja2") -> str:
+        """
+        Render this Method instance into source code using a Jinja2 template.
+
+        Args:
+            template_dir (str): Directory where the Jinja2 templates are located.
+            template_name (str): Filename of the method template.
+
+        Returns:
+            str: The rendered method source code.
+        """
+        from jinja2 import Environment, FileSystemLoader
+
+        env = Environment(
+            loader=FileSystemLoader(template_dir),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+        template = env.get_template(template_name)
+        return template.render(method=self)
 
 
 def convert_to_snake_case(identifier: str) -> str:
@@ -27,16 +80,68 @@ def convert_to_snake_case(identifier: str) -> str:
     return result.lower()
 
 
-def load_schema(path: Path):
+@cache
+def _resolve_schema_reference(reference, schema):
+    """
+    Resolve a JSON schema reference to its target schema.
+
+    Args:
+        reference (str): The reference string (e.g., '#/components/schemas/User')
+        schema (dict): The complete OpenAPI schema that contains the reference
+
+    Returns:
+        dict: The resolved schema, or None if not found
+    """
+    if not reference.startswith("#/"):
+        return None
+
+    # Split the reference path and navigate through the schema
+    parts = reference[2:].split("/")
+    current = schema
+
+    for part in parts:
+        if part in current:
+            current = current[part]
+        else:
+            return None
+
+    return current
+
+
+def _resolve_references(schema: dict[str, Any]):
+    """
+    Recursively walk the OpenAPI schema and inline all JSON Schema $ref references.
+    """
+
+    def _resolve(node):
+        if isinstance(node, dict):
+            # If this dict is a reference, replace it with the resolved schema
+            if "$ref" in node:
+                ref = node["$ref"]
+                resolved = _resolve_schema_reference(ref, schema)
+                # If resolution fails, leave the ref dict as-is
+                return _resolve(resolved) if resolved is not None else node
+            # Otherwise, recurse into each key/value
+            return {key: _resolve(value) for key, value in node.items()}
+        elif isinstance(node, list):
+            # Recurse into list elements
+            return [_resolve(item) for item in node]
+        # Primitive value, return as-is
+        return node
+
+    return _resolve(schema)
+
+
+def _load_and_resolve_references(path: Path):
+    # Load the schema
     type = "yaml" if path.suffix == ".yaml" else "json"
     with open(path) as f:
-        if type == "yaml":
-            return yaml.safe_load(f)
-        else:
-            return json.load(f)
+        schema = yaml.safe_load(f) if type == "yaml" else json.load(f)
+    # Resolve references
+    return _resolve_references(schema)
 
 
-def determine_return_type(operation: dict[str, Any]) -> str:
+def _determine_return_type(operation: dict[str, Any]) -> str:
     """
     Determine the return type from the response schema.
 
@@ -73,339 +178,460 @@ def determine_return_type(operation: dict[str, Any]) -> str:
     return "Any"
 
 
-def resolve_schema_reference(reference, schema):
+def _determine_function_name(operation: dict[str, Any], path: str, method: str) -> str:
     """
-    Resolve a JSON schema reference to its target schema.
-
-    Args:
-        reference (str): The reference string (e.g., '#/components/schemas/User')
-        schema (dict): The complete OpenAPI schema that contains the reference
-
-    Returns:
-        dict: The resolved schema, or None if not found
+    Determine the function name from the operation.
     """
-    if not reference.startswith("#/"):
-        return None
+    # Determine function name
+    if "operationId" in operation:
+        raw_name = operation["operationId"]
+        cleaned_name = raw_name.replace(".", "_").replace("-", "_")
+        func_name = convert_to_snake_case(cleaned_name)
+    else:
+        # Generate name from path and method
+        path_parts = path.strip("/").split("/")
+        name_parts = [method]
+        for part in path_parts:
+            if part.startswith("{") and part.endswith("}"):
+                name_parts.append("by_" + part[1:-1])
+            else:
+                name_parts.append(part)
+        func_name = "_".join(name_parts).replace("-", "_").lower()
+
+    # Only fix isolated 'a' and 'an' as articles, not when they're part of words
+    func_name = re.sub(
+        r"_a([^_a-z])", r"_a_\1", func_name
+    )  # Fix for patterns like retrieve_ablock -> retrieve_a_block
+    func_name = re.sub(
+        r"_a$", r"_a", func_name
+    )  # Don't change if 'a' is at the end of the name
+    func_name = re.sub(
+        r"_an([^_a-z])", r"_an_\1", func_name
+    )  # Fix for patterns like create_anitem -> create_an_item
+    func_name = re.sub(
+        r"_an$", r"_an", func_name
+    )  # Don't change if 'an' is at the end of the name
+    return func_name
+
+
+def _generate_path_params(path: str) -> list[Parameters]:
+    path_params_in_url = re.findall(r"{([^}]+)}", path)
+    parameters = []
+    for param in path_params_in_url:
+        try:
+            parameters.append(
+                Parameters(
+                    name=param.replace("-", "_"),
+                    identifier=param,
+                    description=param,
+                    type="string",
+                    where="path",
+                    required=True,
+                )
+            )
+        except Exception as e:
+            print(f"Error generating path parameters {param}: {e}")
+            raise e
+    return parameters
 
-    # Split the reference path and navigate through the schema
-    parts = reference[2:].split("/")
-    current = schema
 
-    for part in parts:
-        if part in current:
-            current = current[part]
-        else:
-            return None
+def _generate_url(path: str, path_params: list[Parameters]):
+    formatted_path = path
+    for param in path_params:
+        formatted_path = formatted_path.replace(
+            f"{{{param.identifier}}}", f"{{{param.name}}}"
+        )
+    return formatted_path
 
-    return current
 
+def _generate_query_params(operation: dict[str, Any]) -> list[Parameters]:
+    query_params = []
+    for param in operation.get("parameters", []):
+        name = param.get("name")
+        description = param.get("description", "")
+        type = param.get("type")
+        where = param.get("in")
+        required = param.get("required")
+        if where == "query":
+            parameter = Parameters(
+                name=name.replace("-", "_"),
+                identifier=name,
+                description=description,
+                type=type,
+                where=where,
+                required=required,
+            )
+            query_params.append(parameter)
+    return query_params
+
+
+def _generate_body_params(operation: dict[str, Any]) -> list[Parameters]:
+    body_params = []
+    request_body = operation.get("requestBody", {})
+    required = request_body.get("required", False)
+    content = request_body.get("content", {})
+    json_content = content.get("application/json", {})
+    schema = json_content.get("schema", {})
+    properties = schema.get("properties", {})
+    for param in properties:
+        body_params.append(
+            Parameters(
+                name=param,
+                identifier=param,
+                description=param,
+                type="string",
+                where="body",
+                required=required,
+            )
+        )
+    return body_params
 
-def generate_api_client(schema):
+
+def _generate_method_code(path, method, operation):
     """
-    Generate a Python API client class from an OpenAPI schema.
+    Generate the code for a single API method.
 
     Args:
-        schema (dict): The OpenAPI schema as a dictionary.
+        path (str): The API path (e.g., '/users/{user_id}').
+        method (str): The HTTP method (e.g., 'get').
+        operation (dict): The operation details from the schema.
+        full_schema (dict): The complete OpenAPI schema, used for reference resolution.
+        tool_name (str, optional): The name of the tool/app to prefix the function name with.
 
     Returns:
-        str: A string containing the Python code for the API client class.
+        tuple: (method_code, func_name) - The Python code for the method and its name.
     """
-    # Extract API info for naming and base URL
-    info = schema.get("info", {})
-    api_title = info.get("title", "API")
 
-    # Get base URL from servers array if available
-    base_url = ""
-    servers = schema.get("servers", [])
-    if servers and isinstance(servers, list) and "url" in servers[0]:
-        base_url = servers[0]["url"].rstrip("/")
+    func_name = _determine_function_name(operation, path, method)
+    operation.get("summary", "")
+    operation.get("tags", [])
+    # Extract path parameters from the URL path
+    path_params = _generate_path_params(path)
+    query_params = _generate_query_params(operation)
+    _generate_body_params(operation)
+    return_type = _determine_return_type(operation)
+    # gen_method   = Method(name=func_name, summary=summary, tags=tags, path=path, method=method, path_params=path_params, query_params=query_params, body_params=body_params, return_type=return_type)
+    # logger.info(f"Generated method: {gen_method.model_dump()}")
+    # return method.render(template_dir="templates", template_name="method.jinja2")
 
-    # Create a clean class name from API title
-    if api_title:
-        # Convert API title to a clean class name
-        base_name = "".join(word.capitalize() for word in api_title.split())
-        clean_name = "".join(c for c in base_name if c.isalnum())
-        class_name = f"{clean_name}App"
-    else:
-        class_name = "APIClient"
-
-    # Collect all methods
-    methods = []
-    for path, path_info in schema.get("paths", {}).items():
-        for method in path_info:
-            if method in ["get", "post", "put", "delete", "patch", "options", "head"]:
-                operation = path_info[method]
-                function = generate_method_code(path, method, operation, schema)
-                methods.append(function)
-
-    # Set up Jinja2 environment
-    env = Environment(
-        loader=FileSystemLoader(Path(__file__).parent.parent / "templates"),
-        autoescape=select_autoescape(),
-    )
-    template = env.get_template("api_client.py.j2")
-
-    # Render the template
-    class_code = template.render(
-        class_name=class_name, base_url=base_url, methods=methods
-    )
-
-    return class_code
+    has_body = "requestBody" in operation
+    body_required = has_body and operation["requestBody"].get("required", False)
 
+    # Check if the requestBody has actual content or is empty
+    has_empty_body = False
+    if has_body:
+        request_body_content = operation["requestBody"].get("content", {})
+        if not request_body_content or all(
+            not content for content_type, content in request_body_content.items()
+        ):
+            has_empty_body = True
+        else:
+            # Handle empty properties with additionalProperties:true
+            for content_type, content in request_body_content.items():
+                if content_type.startswith("application/json") and "schema" in content:
+                    schema = content["schema"]
+
+                    # Check if properties is empty and additionalProperties is true
+                    if (
+                        schema.get("type") == "object"
+                        and schema.get("additionalProperties", False) is True
+                    ):
+                        properties = schema.get("properties", {})
+                        if not properties or len(properties) == 0:
+                            has_empty_body = True
+
+    # Extract request body schema properties and required fields
+    required_fields = []
+    request_body_properties = {}
+    is_array_body = False
 
-@dataclass
-class Function:
-    name: str
-    type: Literal["get", "post", "put", "delete", "patch", "options", "head"]
-    args: dict[str, str]
-    return_type: str
-    description: str
-    tags: list[str]
-    implementation: str
+    if has_body:
+        for content_type, content in (
+            operation["requestBody"].get("content", {}).items()
+        ):
+            if content_type.startswith("application/json") and "schema" in content:
+                schema = content["schema"]
 
-    @property
-    def args_str(self) -> str:
-        """Convert args dictionary to a string representation."""
-        return ", ".join(f"{arg}: {typ}" for arg, typ in self.args.items())
+                # Check if the schema is an array type
+                if schema.get("type") == "array":
+                    is_array_body = True
+                    schema.get("items", {})
 
+                else:
+                    # Extract required fields from schema
+                    if "required" in schema:
+                        required_fields = schema["required"]
+                    # Extract properties from schema
+                    if "properties" in schema:
+                        request_body_properties = schema["properties"]
+
+                # Handle schemas with empty properties but additionalProperties: true
+                # by treating them similar to empty bodies
+                if (
+                    not request_body_properties or len(request_body_properties) == 0
+                ) and schema.get("additionalProperties") is True:
+                    has_empty_body = True
+
+    # Build function arguments
+    required_args = []
+    optional_args = []
+
+    # Add path parameters
+    for param in path_params:
+        if param.name not in required_args:
+            required_args.append(param.name)
+
+    for param in query_params:
+        param_name = param["name"]
+        # Handle parameters with square brackets and hyphens by converting to valid Python identifiers
+        param_identifier = (
+            param_name.replace("[", "_").replace("]", "").replace("-", "_")
+        )
+        if param_identifier not in required_args and param_identifier not in [
+            p.split("=")[0] for p in optional_args
+        ]:
+            if param.get("required", False):
+                required_args.append(param_identifier)
+            else:
+                optional_args.append(f"{param_identifier}=None")
 
-def generate_method_code(
-    path: str, method: str, operation: dict[str, Any], full_schema: dict[str, Any]
-) -> Function:
-    """
-    Generate a Function object for a single API method.
+    # Handle array type request body differently
+    request_body_params = []
+    if has_body:
+        if is_array_body:
+            # For array request bodies, add a single parameter for the entire array
+            array_param_name = "items"
+            # Try to get a better name from the operation or path
+            if func_name.endswith("_list_input"):
+                array_param_name = func_name.replace("_list_input", "")
+            elif "List" in func_name:
+                array_param_name = func_name.split("List")[0].lower() + "_list"
+
+            # Make the array parameter required if the request body is required
+            if body_required:
+                required_args.append(array_param_name)
+            else:
+                optional_args.append(f"{array_param_name}=None")
+
+            # Remember this is an array param
+            request_body_params = [array_param_name]
+        elif request_body_properties:
+            # For object request bodies, add individual properties as parameters
+            for prop_name in request_body_properties:
+                if prop_name in required_fields:
+                    request_body_params.append(prop_name)
+                    if prop_name not in required_args:
+                        required_args.append(prop_name)
+                else:
+                    request_body_params.append(prop_name)
+                    if f"{prop_name}=None" not in optional_args:
+                        optional_args.append(f"{prop_name}=None")
 
-    Args:
-        path: The API path (e.g., '/users/{user_id}').
-        method: The HTTP method (e.g., 'get').
-        operation: The operation details from the schema.
-        full_schema: The complete OpenAPI schema, used for reference resolution.
+    # If request body is present but empty (content: {}), add a generic request_body parameter
+    if has_empty_body and "request_body=None" not in optional_args:
+        optional_args.append("request_body=None")
 
-    Returns:
-        A Function object with metadata: name, args, return_type, description, tags.
-    """
-    logger.debug(f"Generating function for {method.upper()} {path}")
-
-    # Helper to map JSON schema types to Python types
-    def map_type(sch: dict[str, Any]) -> str:
-        t = sch.get("type")
-        if t == "integer":
-            return "int"
-        if t == "number":
-            return "float"
-        if t == "boolean":
-            return "bool"
-        if t == "array":
-            return "list[Any]"
-        if t == "object":
-            return "dict[str, Any]"
-        return "Any"
+    # Combine required and optional arguments
+    args = required_args + optional_args
 
-    # Determine function name
-    if op_id := operation.get("operationId"):
-        cleaned_id = op_id.replace(".", "_").replace("-", "_")
-        method_name = convert_to_snake_case(cleaned_id)
+    # Determine return type
+    return_type = _determine_return_type(operation)
+    if args:
+        signature = f"    def {func_name}(self, {', '.join(args)}) -> {return_type}:"
     else:
-        segments = [seg.replace("-", "_") for seg in path.strip("/").split("/")]
-        parts = [method.lower()]
-        for seg in segments:
-            if seg.startswith("{") and seg.endswith("}"):
-                parts.append(f"by_{seg[1:-1]}")
-            else:
-                parts.append(seg)
-        method_name = "_".join(parts)
-    logger.debug(f"Resolved function name={method_name}")
+        signature = f"    def {func_name}(self) -> {return_type}:"
 
-    # Resolve references and filter out header params
-    resolved_params = []
-    for param in operation.get("parameters", []):
-        if ref := param.get("$ref"):
-            target = resolve_schema_reference(ref, full_schema)
-            if target:
-                resolved_params.append(target)
-            else:
-                logger.warning(f"Unresolved parameter reference: {ref}")
-        else:
-            resolved_params.append(param)
+    # Build method body
+    body_lines = []
 
-    # Separate params by location
-    path_params = [p for p in resolved_params if p.get("in") == "path"]
-    query_params = [p for p in resolved_params if p.get("in") == "query"]
+    for param in path_params:
+        body_lines.append(f"        if {param.name} is None:")
+        body_lines.append(
+            f"            raise ValueError(\"Missing required parameter '{param.identifier}'\")"  # Use original name in error
+        )
 
-    # Analyze requestBody
-    has_body = "requestBody" in operation
-    body_required = bool(has_body and operation["requestBody"].get("required"))
-    content = (
-        (operation.get("requestBody", {}) or {}).get("content", {}) if has_body else {}
-    )
-    is_array_body = False
-    request_props: dict[str, Any] = {}
-    required_fields: list[str] = []
-    if has_body and content:
-        for mime, info in content.items():
-            if not mime.startswith("application/json") or "schema" not in info:
-                continue
-            schema = info["schema"]
-            if ref := schema.get("$ref"):
-                schema = resolve_schema_reference(ref, full_schema) or schema
-            if schema.get("type") == "array":
-                is_array_body = True
-            else:
-                required_fields = schema.get("required", []) or []
-                request_props = schema.get("properties", {}) or {}
-                for name, prop_schema in list(request_props.items()):
-                    if pre := prop_schema.get("$ref"):
-                        request_props[name] = (
-                            resolve_schema_reference(pre, full_schema) or prop_schema
-                        )
-
-    # Build function arguments with Annotated[type, description]
-    arg_defs: dict[str, str] = {}
-    for p in path_params:
-        name = p["name"]
-        ty = map_type(p.get("schema", {}))
-        desc = p.get("description", "")
-        arg_defs[name] = f"Annotated[{ty}, {desc!r}]"
-    for p in query_params:
-        name = p["name"]
-        ty = map_type(p.get("schema", {}))
-        desc = p.get("description", "")
-        if p.get("required"):
-            arg_defs[name] = f"Annotated[{ty}, {desc!r}]"
-        else:
-            arg_defs[name] = f"Annotated[{ty}, {desc!r}] = None"
+    # Build request body (handle array and object types differently)
     if has_body:
         if is_array_body:
-            desc = operation["requestBody"].get("description", "")
-            if body_required:
-                arg_defs["items"] = f"Annotated[list[Any], {desc!r}]"
-            else:
-                arg_defs["items"] = f"Annotated[list[Any], {desc!r}] = None"
-        elif request_props:
-            for prop, schema in request_props.items():
-                ty = map_type(schema)
-                desc = schema.get("description", "")
-                if prop in required_fields:
-                    arg_defs[prop] = f"Annotated[{ty}, {desc!r}]"
-                else:
-                    arg_defs[prop] = f"Annotated[{ty}, {desc!r}] = None"
-        else:
-            desc = operation["requestBody"].get("description", "")
-            arg_defs["request_body"] = f"Annotated[Any, {desc!r}] = None"
-
-    # Sort and order arguments
-    required_keys = sorted(k for k, v in arg_defs.items() if "=" not in v)
-    optional_keys = sorted(k for k, v in arg_defs.items() if "=" in v)
-    ordered_args = {k: arg_defs[k] for k in required_keys + optional_keys}
-
-    return_type = determine_return_type(operation)
-
-    # Assemble description
-    summary = operation.get("summary", "")
-    operation_desc = operation.get("description", "")
-    desc_parts: list[str] = []
-    if summary:
-        desc_parts.append(summary)
-    if operation_desc:
-        desc_parts.append(operation_desc)
-    description_text = ". ".join(desc_parts)
-
-    tags = operation.get("tags", []) or []
-
-    # Generate implementation code
-    implementation_lines = []
-
-    # Add parameter validation for required fields
-    for param in path_params + query_params:
-        if param.get("required"):
-            name = param["name"]
-            implementation_lines.append(f"if {name} is None:")
-            implementation_lines.append(
-                f"    raise ValueError(\"Missing required parameter '{name}'\")"
-            )
+            # For array request bodies, use the array parameter directly
+            body_lines.append("        # Use items array directly as request body")
+            body_lines.append(f"        request_body = {request_body_params[0]}")
+        elif request_body_properties:
+            # For object request bodies, build the request body from individual parameters
 
-    if has_body and body_required:
-        if is_array_body:
-            implementation_lines.append("if items is None:")
-            implementation_lines.append(
-                "    raise ValueError(\"Missing required parameter 'items'\")"
-            )
-        elif request_props:
-            for prop in required_fields:
-                implementation_lines.append(f"if {prop} is None:")
-                implementation_lines.append(
-                    f"    raise ValueError(\"Missing required parameter '{prop}'\")"
-                )
-        else:
-            implementation_lines.append("if request_body is None:")
-            implementation_lines.append(
-                "    raise ValueError(\"Missing required parameter 'request_body'\")"
-            )
+            body_lines.append("        request_body = {")
 
-    # Build request body
-    if has_body:
-        if is_array_body:
-            implementation_lines.append("request_body = items")
-        elif request_props:
-            implementation_lines.append("request_body = {")
-            for prop in request_props:
-                implementation_lines.append(f'    "{prop}": {prop},')
-            implementation_lines.append("}")
-            implementation_lines.append(
-                "request_body = {k: v for k, v in request_body.items() if v is not None}"
+            for prop_name in request_body_params:
+                # Only include non-None values in the request body
+                body_lines.append(f"            '{prop_name}': {prop_name},")
+
+            body_lines.append("        }")
+
+            body_lines.append(
+                "        request_body = {k: v for k, v in request_body.items() if v is not None}"
             )
-        else:
-            implementation_lines.append("request_body = request_body")
 
-    # Build URL with path parameters
-    path = "/".join([path_params["name"] for path_params in path_params]) or '""'
-    url = '"{self.base_url}{path}"'
-    implementation_lines.append(f"path = {path}")
-    implementation_lines.append(f"url = f{url}")
+    # Format URL directly with path parameters
+    url = _generate_url(path, path_params)
+    url_line = f'        url = f"{{self.base_url}}{url}"'
+    body_lines.append(url_line)
 
-    # Build query parameters
+    # Build query parameters, handling square brackets in parameter names
     if query_params:
-        implementation_lines.append("query_params = {")
+        query_params_items = []
         for param in query_params:
-            name = param["name"]
-            implementation_lines.append(f'        "{name}": {name},')
-        implementation_lines.append("    }")
-        implementation_lines.append(
-            "query_params = {k: v for k, v in query_params.items() if v is not None}"
+            param_name = param.name
+            param_identifier = (
+                param_name.replace("[", "_").replace("]", "").replace("-", "_")
+            )
+            query_params_items.append(f"('{param_name}', {param_identifier})")
+        body_lines.append(
+            f"        query_params = {{k: v for k, v in [{', '.join(query_params_items)}] if v is not None}}"
         )
     else:
-        implementation_lines.append("query_params = {}")
+        body_lines.append("        query_params = {}")
 
-    # Make the request using the appropriate method
-    http_method = method.lower()
-    if has_body:
-        implementation_lines.append(
-            f"response = self._{http_method}(url, data=request_body, params=query_params)"
+    # Make HTTP request using the proper method
+    method_lower = method.lower()
+
+    # Determine what to use as the request body argument
+    if has_empty_body:
+        request_body_arg = "request_body"
+    elif not has_body:
+        request_body_arg = "{}"
+    else:
+        request_body_arg = "request_body"
+
+    if method_lower == "get":
+        body_lines.append("        response = self._get(url, params=query_params)")
+    elif method_lower == "post":
+        body_lines.append(
+            f"        response = self._post(url, data={request_body_arg}, params=query_params)"
+        )
+    elif method_lower == "put":
+        body_lines.append(
+            f"        response = self._put(url, data={request_body_arg}, params=query_params)"
         )
+    elif method_lower == "patch":
+        body_lines.append(
+            f"        response = self._patch(url, data={request_body_arg}, params=query_params)"
+        )
+    elif method_lower == "delete":
+        body_lines.append("        response = self._delete(url, params=query_params)")
     else:
-        implementation_lines.append(
-            f"response = self._{http_method}(url, params=query_params)"
+        body_lines.append(
+            f"        response = self._{method_lower}(url, data={request_body_arg}, params=query_params)"
         )
 
     # Handle response
-    implementation_lines.append("response.raise_for_status()")
-    implementation_lines.append("return response.json()")
-
-    implementation = "\n".join(implementation_lines)
-
-    # Build Function object
-    function = Function(
-        name=method_name,
-        type=http_method,
-        args=ordered_args,
-        return_type=return_type,
-        description=description_text,
-        tags=tags,
-        implementation=implementation,
-    )
+    body_lines.append("        response.raise_for_status()")
+    body_lines.append("        return response.json()")
+
+    method_code = signature + "\n" + "\n".join(body_lines)
+    return method_code, func_name
+
+
+def load_schema(path: Path):
+    return _load_and_resolve_references(path)
+
+
+def generate_api_client(schema, class_name: str | None = None):
+    """
+    Generate a Python API client class from an OpenAPI schema.
+
+    Args:
+        schema (dict): The OpenAPI schema as a dictionary.
+
+    Returns:
+        str: A string containing the Python code for the API client class.
+    """
+    methods = []
+    method_names = []
 
-    logger.debug(f"Generated function: {function}")
-    return function
+    # Extract API info for naming and base URL
+    info = schema.get("info", {})
+    api_title = info.get("title", "API")
+
+    # Get base URL from servers array if available
+    base_url = ""
+    servers = schema.get("servers", [])
+    if servers and isinstance(servers, list) and "url" in servers[0]:
+        base_url = servers[0]["url"].rstrip("/")
+
+    # Create a clean class name from API title
+    if api_title:
+        # Convert API title to a clean class name
+        if class_name:
+            clean_name = (
+                class_name.capitalize()[:-3]
+                if class_name.endswith("App")
+                else class_name.capitalize()
+            )
+        else:
+            base_name = "".join(word.capitalize() for word in api_title.split())
+            clean_name = "".join(c for c in base_name if c.isalnum())
+        class_name = f"{clean_name}App"
+
+        # Extract tool name - remove spaces and convert to lowercase
+        tool_name = api_title.lower()
+
+        # Remove version numbers (like 3.0, v1, etc.)
+        tool_name = re.sub(r"\s*v?\d+(\.\d+)*", "", tool_name)
+
+        # Remove common words that aren't needed
+        common_words = ["api", "openapi", "open", "swagger", "spec", "specification"]
+        for word in common_words:
+            tool_name = tool_name.replace(word, "")
+
+        # Remove spaces, hyphens, underscores
+        tool_name = tool_name.replace(" ", "").replace("-", "").replace("_", "")
+
+        # Remove any non-alphanumeric characters
+        tool_name = "".join(c for c in tool_name if c.isalnum())
+
+        # If empty (after cleaning), use generic name
+        if not tool_name:
+            tool_name = "api"
+    else:
+        class_name = "APIClient"
+        tool_name = "api"
+
+    # Iterate over paths and their operations
+    for path, path_info in schema.get("paths", {}).items():
+        for method in path_info:
+            if method in ["get", "post", "put", "delete", "patch", "options", "head"]:
+                operation = path_info[method]
+                method_code, func_name = _generate_method_code(path, method, operation)
+                methods.append(method_code)
+                method_names.append(func_name)
+
+    # Generate list_tools method with all the function names
+    tools_list = ",\n            ".join([f"self.{name}" for name in method_names])
+    list_tools_method = f"""    def list_tools(self):
+        return [
+            {tools_list}
+        ]"""
+
+    # Generate class imports
+    imports = [
+        "from typing import Any",
+        "from universal_mcp.applications import APIApplication",
+        "from universal_mcp.integrations import Integration",
+    ]
+
+    # Construct the class code
+    class_code = (
+        "\n".join(imports) + "\n\n"
+        f"class {class_name}(APIApplication):\n"
+        f"    def __init__(self, integration: Integration = None, **kwargs) -> None:\n"
+        f"        super().__init__(name='{class_name.lower()}', integration=integration, **kwargs)\n"
+        f'        self.base_url = "{base_url}"\n\n'
+        + "\n\n".join(methods)
+        + "\n\n"
+        + list_tools_method
+        + "\n"
+    )
+    return class_code
 
 
 # Example usage