Finished code for generating dataclasses from schemas

Author: dbanty

openapi_python_client/__init__.py

@@ -1,9 +1,12 @@
 """ Generate modern Python clients from OpenAPI """
 import sys
+from pathlib import Path
 from typing import Dict
 
 import orjson
 import requests
+import stringcase
+from jinja2 import Environment, PackageLoader
 
 from .models import OpenAPI
 
@@ -14,7 +17,7 @@ def main():
     json = _get_json(url)
     data_dict = _parse_json(json)
     openapi = OpenAPI.from_dict(data_dict)
-    print(openapi)
+    _build_project(openapi)
 
 
 def _get_json(url) -> bytes:
@@ -24,3 +27,29 @@ def _get_json(url) -> bytes:
 
 def _parse_json(json: bytes) -> Dict:
     return orjson.loads(json)
+
+
+def _build_project(openapi: OpenAPI):
+    env = Environment(loader=PackageLoader(__package__), trim_blocks=True, lstrip_blocks=True)
+
+    # Create output directories
+    project_name = f"{openapi.title.replace(' ', '-').lower()}-client"
+    package_name = f"{openapi.title.replace(' ', '_').lower()}_client"
+    project_dir = Path.cwd() / project_name
+    project_dir.mkdir()
+    package_dir = project_dir / package_name
+    package_dir.mkdir()
+
+    # 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))
+
+    # Generate models
+    models_dir = package_dir / "models"
+    models_dir.mkdir()
+    model_template = env.get_template("model.pyi")
+    for schema in openapi.schemas.values():
+        module_path = models_dir / f"{stringcase.snakecase(schema.title)}.py"
+        module_path.write_text(model_template.render(schema=schema))
+

openapi_python_client/models/openapi.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Set
 
-from .properties import Property, property_from_dict
+import stringcase
+
+from .properties import Property, property_from_dict, DateTimeProperty, ListProperty, RefProperty, EnumProperty
 
 
 class Method(Enum):
@@ -83,15 +85,20 @@ class Schema:
     title: str
     properties: List[Property]
     description: str
+    relative_imports: Set[str] = field(default_factory=set)
 
     @staticmethod
     def from_dict(d: Dict, /) -> Schema:
         """ A single Schema from its dict representation """
         required = set(d.get("required", []))
         properties: List[Property] = []
+        schema = Schema(title=d["title"], properties=properties, description=d.get("description", ""))
         for key, value in d["properties"].items():
-            properties.append(property_from_dict(name=key, required=key in required, data=value,))
-        return Schema(title=d["title"], properties=properties, description=d.get("description", ""),)
+            p = property_from_dict(name=key, required=key in required, data=value)
+            properties.append(p)
+            if isinstance(p, (ListProperty, RefProperty)) and p.ref:
+                schema.relative_imports.add(f"from .{stringcase.snakecase(p.ref)} import {p.ref}")
+        return schema
 
     @staticmethod
     def dict(d: Dict, /) -> Dict[str, Schema]:
@@ -113,15 +120,26 @@ class OpenAPI:
     security_schemes: Dict
     schemas: Dict[str, Schema]
     endpoints: List[Endpoint]
+    enums: Dict[str, List[str]]
 
     @staticmethod
     def from_dict(d: Dict, /) -> OpenAPI:
         """ Create an OpenAPI from dict """
+        schemas = Schema.dict(d["components"]["schemas"])
+        enums = {}
+        for schema in schemas.values():
+            for prop in schema.properties:
+                if isinstance(prop, EnumProperty):
+                    enum_class_name = stringcase.pascalcase(prop.name)
+                    enums[enum_class_name] = prop.values
+                    schema.relative_imports.add(f"from .{prop.name} import {enum_class_name}")
+
         return OpenAPI(
             title=d["info"]["title"],
             description=d["info"]["description"],
             version=d["info"]["version"],
             endpoints=Endpoint.get_list_from_dict(d["paths"]),
-            schemas=Schema.dict(d["components"]["schemas"]),
+            schemas=schemas,
             security_schemes=d["components"]["securitySchemes"],
+            enums=enums,
         )

openapi_python_client/models/properties.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
-from typing import Optional, List, Dict, Union
+from typing import Optional, List, Dict, Union, ClassVar
+import stringcase
 
 
 @dataclass
@@ -9,6 +10,14 @@ class Property:
     name: str
     required: bool
 
+    _type_string: ClassVar[str]
+
+    def get_type_string(self):
+        """ Get a string representation of type that should be used when declaring this property """
+        if self.required:
+            return self._type_string
+        return f"Optional[{self._type_string}]"
+
 
 @dataclass
 class StringProperty(Property):
@@ -18,41 +27,82 @@ class StringProperty(Property):
     default: Optional[str] = None
     pattern: Optional[str] = None
 
+    _type_string: ClassVar[str] = "str"
+
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        if self.default:
+            return f"{self.name}: {self.get_type_string()} = {self.default}"
+        else:
+            return f"{self.name}: {self.get_type_string()}"
+
 
 @dataclass
 class DateTimeProperty(Property):
     """ A property of type datetime.datetime """
+    _type_string: ClassVar[str] = "datetime"
 
-    pass
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        return f"{self.name}: {self.get_type_string()}"
 
 
 @dataclass
 class FloatProperty(Property):
     """ A property of type float """
 
     default: Optional[float] = None
+    _type_string: ClassVar[str] = "float"
+
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        if self.default:
+            return f"{self.name}: {self.get_type_string()} = {self.default}"
+        else:
+            return f"{self.name}: {self.get_type_string()}"
 
 
 @dataclass
 class IntProperty(Property):
     """ A property of type int """
 
     default: Optional[int] = None
+    _type_string: ClassVar[str] = "int"
+
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        if self.default:
+            return f"{self.name}: {self.get_type_string()} = {self.default}"
+        else:
+            return f"{self.name}: {self.get_type_string()}"
 
 
 @dataclass
 class BooleanProperty(Property):
     """ Property for bool """
+    _type_string: ClassVar[str] = "bool"
 
-    pass
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        return f"{self.name}: {self.get_type_string()}"
 
 
 @dataclass
 class ListProperty(Property):
     """ Property for list """
 
-    type: Optional[str] = None
-    ref: Optional[str] = None
+    type: Optional[str]
+    ref: Optional[str]
+
+    def get_type_string(self):
+        """ Get a string representation of type that should be used when declaring this property """
+        if self.required:
+            return f"List[{self.type}]"
+        return f"Optional[List[{self.type}]]"
+
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        return f"{self.name}: {self.get_type_string()}"
 
 
 @dataclass
@@ -61,22 +111,59 @@ class EnumProperty(Property):
 
     values: List[str]
 
+    def get_type_string(self):
+        """ Get a string representation of type that should be used when declaring this property """
+        class_name = stringcase.pascalcase(self.name)
+        if self.required:
+            return class_name
+        return f"Optional[{class_name}]"
+
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        return f"{self.name}: {self.get_type_string()}"
+
 
 @dataclass
 class RefProperty(Property):
     """ A property which refers to another Schema """
 
     ref: str
 
+    def get_type_string(self):
+        """ Get a string representation of type that should be used when declaring this property """
+        if self.required:
+            return self.ref
+        return f"Optional[{self.ref}]"
+
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        return f"{self.name}: {self.get_type_string()}"
+
 
 @dataclass
 class DictProperty(Property):
     """ Property that is a general Dict """
 
+    _type_string: ClassVar[str] = "Dict"
+
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        return f"{self.name}: {self.get_type_string()}"
+
+
+_openapi_types_to_python_type_strings = {
+    "string": "str",
+    "number": "float",
+    "integer": "int",
+    "boolean": "bool",
+    "object": "Dict",
+}
+
 
 def property_from_dict(
     name: str, required: bool, data: Dict[str, Union[float, int, str, List[str], Dict[str, str]]]
 ) -> Property:
+    """ Generate a Property from the OpenAPI dictionary representation of it """
     if "enum" in data:
         return EnumProperty(name=name, required=required, values=data["enum"],)
     if "$ref" in data:
@@ -99,7 +186,10 @@ def property_from_dict(
         ref = None
         if "$ref" in data["items"]:
             ref = data["items"]["$ref"].split("/")[-1]
-        return ListProperty(name=name, required=required, type=data["items"].get("type"), ref=ref,)
+        _type = None
+        if "type" in data["items"]:
+            _type = _openapi_types_to_python_type_strings[data["items"]["type"]]
+        return ListProperty(name=name, required=required, type=_type, ref=ref)
     elif data["type"] == "object":
         return DictProperty(name=name, required=required,)
     raise ValueError(f"Did not recognize type of {data}")

openapi_python_client/templates/model.pyi

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Dict, Optional, List
+
+{% for relative in schema.relative_imports %}
+{{ relative }}
+{% endfor %}
+
+
+@dataclass
+class {{ schema.title }}:
+    {% for property in schema.properties %}
+    {{ property.to_string() }}
+    {% endfor %}

openapi_python_client/templates/pyproject.toml

@@ -0,0 +1,17 @@
+[tool.poetry]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "A client API"
+
+authors = []
+
+readme = "README.md"
+packages = [
+    {include = "{{ package_name }}"},
+]
+include = ["CHANGELOG.md", "{{ package_name }}/py.typed"]
+
+
+[tool.poetry.dependencies]
+python = "^3.8"
+requests = "^2.22.0"