Added super basic api endpoint support and made generated package installable

Author: dbanty

openapi_python_client/__init__.py

@@ -39,15 +39,24 @@ def _build_project(openapi: OpenAPI):
     project_dir.mkdir()
     package_dir = project_dir / package_name
     package_dir.mkdir()
+    package_init = package_dir / "__init__.py"
+    package_description = f"A client library for accessing {openapi.title}"
+    package_init.write_text(f'""" {package_description} """')
 
     # Create a pyproject.toml file
     pyproject_template = env.get_template("pyproject.toml")
     pyproject_path = project_dir / "pyproject.toml"
-    pyproject_path.write_text(pyproject_template.render(project_name=project_name, package_name=package_name))
+    pyproject_path.write_text(pyproject_template.render(project_name=project_name, package_name=package_name, description=package_description))
+
+    readme = project_dir / "README.md"
+    readme_template = env.get_template("README.md")
+    readme.write_text(readme_template.render(description=package_description))
 
     # Generate models
     models_dir = package_dir / "models"
     models_dir.mkdir()
+    models_init = models_dir / "__init__.py"
+    models_init.write_text('""" Contains all the data models used in inputs/outputs """')
     model_template = env.get_template("model.pyi")
     for schema in openapi.schemas.values():
         module_path = models_dir / f"{stringcase.snakecase(schema.title)}.py"
@@ -59,3 +68,19 @@ def _build_project(openapi: OpenAPI):
         module_path = models_dir / f"{enum.name}.py"
         module_path.write_text(enum_template.render(enum=enum))
 
+    # Generate Client
+    client_path = package_dir / "client.py"
+    client_template = env.get_template("client.pyi")
+    client_path.write_text(client_template.render())
+
+    # Generate endpoints
+    api_dir = package_dir / "api"
+    api_dir.mkdir()
+    api_init = api_dir / "__init__.py"
+    api_init.write_text('""" Contains all methods for accessing the API """')
+    endpoint_template = env.get_template("endpoint_module.pyi")
+    for tag, endpoints in openapi.endpoints_by_tag.items():
+        module_path = api_dir / f"{tag}.py"
+        module_path.write_text(endpoint_template.render(endpoints=endpoints))
+
+

openapi_python_client/models/openapi.py

@@ -1,20 +1,14 @@
 from __future__ import annotations
 
+from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Dict, List, Optional, Set
 
 import stringcase
 
 from .properties import Property, property_from_dict, ListProperty, RefProperty, EnumProperty
-
-
-class Method(Enum):
-    """ HTTP Methods """
-
-    GET = "get"
-    POST = "post"
-    PATCH = "patch"
+from .responses import Response, response_from_dict
 
 
 class ParameterLocation(Enum):
@@ -47,31 +41,40 @@ class Endpoint:
     """
 
     path: str
-    method: Method
+    method: str
     description: Optional[str]
     name: str
     parameters: List[Parameter]
-    tag: Optional[str] = None
+    responses: List[Response]
 
     @staticmethod
-    def get_list_from_dict(d: Dict[str, Dict[str, Dict]], /) -> List[Endpoint]:
+    def get_by_tags_from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, List[Endpoint]]:
         """ Parse the openapi paths data to get a list of endpoints """
-        endpoints = []
+        # TODO: handle requestBody
+        endpoints_by_tag: Dict[str, List[Endpoint]] = defaultdict(list)
         for path, path_data in d.items():
             for method, method_data in path_data.items():
                 parameters: List[Parameter] = []
+                responses: List[Response] = []
                 for param_dict in method_data.get("parameters", []):
                     parameters.append(Parameter.from_dict(param_dict))
+                tag = method_data.get("tags", ["default"])[0]
+                for code, response_dict in method_data["responses"].items():
+                    response = response_from_dict(
+                        status_code=int(code),
+                        data=response_dict,
+                    )
+                    responses.append(response)
                 endpoint = Endpoint(
                     path=path,
-                    method=Method(method),
+                    method=method,
                     description=method_data.get("description"),
                     name=method_data["operationId"],
                     parameters=parameters,
-                    tag=method_data.get("tags", [None])[0],
+                    responses=responses,
                 )
-                endpoints.append(endpoint)
-        return endpoints
+                endpoints_by_tag[tag].append(endpoint)
+        return endpoints_by_tag
 
 
 @dataclass
@@ -119,7 +122,7 @@ class OpenAPI:
     version: str
     security_schemes: Dict
     schemas: Dict[str, Schema]
-    endpoints: List[Endpoint]
+    endpoints_by_tag: Dict[str, List[Endpoint]]
     enums: Dict[str, EnumProperty]
 
     @staticmethod
@@ -144,7 +147,7 @@ def from_dict(d: Dict, /) -> OpenAPI:
             title=d["info"]["title"],
             description=d["info"]["description"],
             version=d["info"]["version"],
-            endpoints=Endpoint.get_list_from_dict(d["paths"]),
+            endpoints_by_tag=Endpoint.get_by_tags_from_dict(d["paths"]),
             schemas=schemas,
             security_schemes=d["components"]["securitySchemes"],
             enums=enums,

openapi_python_client/models/responses.py

@@ -0,0 +1,112 @@
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Union, ClassVar, TypedDict, Literal, cast
+import stringcase
+
+
+ContentType = Union[Literal["application/json"], Literal["text/html"]]
+
+
+@dataclass
+class Response:
+    """ Describes a single response for an endpoint """
+
+    status_code: int
+    content_type: ContentType
+
+
+@dataclass
+class ListRefResponse(Response):
+    """ Response is a list of some ref schema """
+
+    ref: str
+
+
+@dataclass
+class RefResponse(Response):
+    """ Response is a single ref schema """
+
+    ref: str
+
+
+@dataclass
+class StringResponse(Response):
+    """ Response is a string """
+    pass
+
+
+@dataclass
+class EmptyResponse(Response):
+    """ Response has no payload """
+    pass
+
+
+_openapi_types_to_python_type_strings = {
+    "string": "str",
+    "number": "float",
+    "integer": "int",
+    "boolean": "bool",
+    "object": "Dict",
+}
+
+
+class _ResponseListSchemaDict(TypedDict):
+    title: str
+    type: Literal["array"]
+    items: Dict[Literal["$ref"], str]
+
+
+_ResponseRefSchemaDict = Dict[Literal["$ref"], str]
+_ResponseStringSchemaDict = Dict[Literal["type"], Literal["string"]]
+_ResponseSchemaDict = Union[_ResponseListSchemaDict, _ResponseRefSchemaDict, _ResponseStringSchemaDict]
+
+
+class _ResponseContentDict(TypedDict):
+    schema: _ResponseSchemaDict
+
+
+class _ResponseDict(TypedDict):
+    description: str
+    content: Dict[ContentType, _ResponseContentDict]
+
+
+def response_from_dict(
+    *, status_code: int, data: _ResponseDict
+) -> Response:
+    """ Generate a Response from the OpenAPI dictionary representation of it """
+    if "content" not in data:
+        raise ValueError(f"Cannot parse response data: {data}")
+
+    content = data["content"]
+    content_type: ContentType
+    if "application/json" in content:
+        content_type = "application/json"
+    elif "text/html" in content:
+        content_type = "text/html"
+    else:
+        raise ValueError(f"Cannot parse content type of {data}")
+
+    schema_data: _ResponseSchemaDict = data["content"][content_type]["schema"]
+
+    if "$ref" in schema_data:
+        return RefResponse(
+            status_code=status_code,
+            content_type=content_type,
+            ref=schema_data["$ref"].split("/")[-1],
+        )
+    if "type" not in schema_data:
+        return EmptyResponse(
+            status_code=status_code,
+            content_type=content_type,
+        )
+    if schema_data["type"] == "array":
+        list_data = cast(_ResponseListSchemaDict, schema_data)
+        return ListRefResponse(
+            status_code=status_code,
+            content_type=content_type,
+            ref=list_data["items"]["$ref"].split("/")[-1],
+        )
+    if schema_data["type"] == "string":
+        return StringResponse(
+            status_code=status_code,
+            content_type=content_type,
+        )

openapi_python_client/templates/README.md

@@ -0,0 +1 @@
+{{ description }}

openapi_python_client/templates/client.pyi

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+@dataclass
+class Client:
+    """ A class for keeping track of data related to the API """
+    base_url: str

openapi_python_client/templates/endpoint_module.pyi

@@ -0,0 +1,17 @@
+import requests
+
+from ..client import Client
+
+{% for endpoint in endpoints %}
+def {{ endpoint.name }}(client: Client):
+    """ {{ endpoint.description }} """
+    url = client.base_url + "{{ endpoint.path }}"
+
+    {% if endpoint.method == "get" %}
+    return requests.get(url)
+    {% endif %}
+
+
+{% endfor %}
+
+

openapi_python_client/templates/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "{{ project_name }}"
 version = "0.1.0"
-description = "A client API"
+description = "{{ description }}"
 
 authors = []