Add support for query parameters

Closes #5

Author: dbanty

openapi_python_client/__init__.py

@@ -5,10 +5,9 @@
 
 import orjson
 import requests
-import stringcase
 from jinja2 import Environment, PackageLoader
 
-from .models import OpenAPI
+from .models import OpenAPI, import_string_from_reference
 
 
 def main():
@@ -57,17 +56,23 @@ def _build_project(openapi: OpenAPI):
     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 """')
+    imports = []
+
     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 = models_dir / f"{schema.reference.module_name}.py"
         module_path.write_text(model_template.render(schema=schema))
+        imports.append(import_string_from_reference(schema.reference))
 
     # Generate enums
     enum_template = env.get_template("enum.pyi")
     for enum in openapi.enums.values():
         module_path = models_dir / f"{enum.name}.py"
         module_path.write_text(enum_template.render(enum=enum))
+        imports.append(import_string_from_reference(enum.reference))
+
+    models_init_template = env.get_template("models_init.pyi")
+    models_init.write_text(models_init_template.render(imports=imports))
 
     # Generate Client
     client_path = package_dir / "client.py"

openapi_python_client/models/__init__.py

@@ -1,4 +1,3 @@
 """ Classes representing the data in the OpenAPI schema """
 
-from .api_info import APIInfo
-from .openapi import OpenAPI
+from .openapi import OpenAPI, import_string_from_reference

openapi_python_client/models/api_info.py

@@ -2,39 +2,22 @@
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Dict, List, Optional, Set
-
-import stringcase
+from typing import Dict, List, Optional, Set, Iterable, Generator
 
 from .properties import Property, property_from_dict, ListProperty, RefProperty, EnumProperty
-from .responses import Response, response_from_dict
 from .reference import Reference
+from .responses import Response, response_from_dict
 
 
-class ParameterLocation(Enum):
+class ParameterLocation(str, Enum):
     """ The places Parameters can be put when calling an Endpoint """
 
     QUERY = "query"
     PATH = "path"
 
 
-@dataclass
-class Parameter:
-    """ A parameter in an Endpoint """
-
-    location: ParameterLocation
-    property: Property
-
-    @staticmethod
-    def from_dict(d: Dict, /) -> Parameter:
-        """ Construct a parameter from it's OpenAPI dict form """
-        return Parameter(
-            location=ParameterLocation(d["in"]),
-            property=property_from_dict(name=d["name"], required=d["required"], data=d["schema"]),
-        )
-
-
-def _import_string_from_reference(reference: Reference, prefix: str = "") -> str:
+def import_string_from_reference(reference: Reference, prefix: str = "") -> str:
+    """ Create a string which is used to import a reference """
     return f"from {prefix}.{reference.module_name} import {reference.class_name}"
 
 
@@ -52,11 +35,24 @@ def from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, EndpointCollection]
         endpoints_by_tag: Dict[str, EndpointCollection] = {}
         for path, path_data in d.items():
             for method, method_data in path_data.items():
-                parameters: List[Parameter] = []
+                query_parameters: List[Property] = []
+                path_parameters: List[Property] = []
                 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]
+                collection = endpoints_by_tag.setdefault(tag, EndpointCollection(tag=tag))
+                for param_dict in method_data.get("parameters", []):
+                    prop = property_from_dict(
+                        name=param_dict["name"], required=param_dict["required"], data=param_dict["schema"]
+                    )
+                    if isinstance(prop, (ListProperty, RefProperty, EnumProperty)) and prop.reference:
+                        collection.relative_imports.add(import_string_from_reference(prop.reference, prefix="..models"))
+                    if param_dict["in"] == ParameterLocation.QUERY:
+                        query_parameters.append(prop)
+                    elif param_dict["in"] == ParameterLocation.PATH:
+                        path_parameters.append(prop)
+                    else:
+                        raise ValueError(f"Don't know where to put this parameter: {param_dict}")
+
                 for code, response_dict in method_data["responses"].items():
                     response = response_from_dict(status_code=int(code), data=response_dict)
                     responses.append(response)
@@ -69,17 +65,17 @@ def from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, EndpointCollection]
                     method=method,
                     description=method_data.get("description"),
                     name=method_data["operationId"],
-                    parameters=parameters,
+                    query_parameters=query_parameters,
+                    path_parameters=path_parameters,
                     responses=responses,
                     form_body_reference=form_body_reference,
                     requires_security=method_data.get("security"),
                 )
 
-                collection = endpoints_by_tag.setdefault(tag, EndpointCollection(tag=tag))
                 collection.endpoints.append(endpoint)
                 if form_body_reference:
                     collection.relative_imports.add(
-                        _import_string_from_reference(form_body_reference, prefix="..models")
+                        import_string_from_reference(form_body_reference, prefix="..models")
                     )
         return endpoints_by_tag
 
@@ -94,7 +90,8 @@ class Endpoint:
     method: str
     description: Optional[str]
     name: str
-    parameters: List[Parameter]
+    query_parameters: List[Property]
+    path_parameters: List[Property]
     responses: List[Response]
     requires_security: bool
     form_body_reference: Optional[Reference]
@@ -118,7 +115,7 @@ class Schema:
     These will all be converted to dataclasses in the client
     """
 
-    title: str
+    reference: Reference
     required_properties: List[Property]
     optional_properties: List[Property]
     description: str
@@ -139,10 +136,10 @@ def from_dict(d: Dict, /) -> Schema:
                 required_properties.append(p)
             else:
                 optional_properties.append(p)
-            if isinstance(p, (ListProperty, RefProperty)) and p.reference:
-                relative_imports.add(_import_string_from_reference(p.reference))
+            if isinstance(p, (ListProperty, RefProperty, EnumProperty)) and p.reference:
+                relative_imports.add(import_string_from_reference(p.reference))
         schema = Schema(
-            title=stringcase.pascalcase(d["title"]),
+            reference=Reference(d["title"]),
             required_properties=required_properties,
             optional_properties=optional_properties,
             relative_imports=relative_imports,
@@ -156,7 +153,7 @@ def dict(d: Dict, /) -> Dict[str, Schema]:
         result = {}
         for data in d.values():
             s = Schema.from_dict(data)
-            result[s.title] = s
+            result[s.reference.class_name] = s
         return result
 
 
@@ -172,29 +169,44 @@ class OpenAPI:
     endpoint_collections_by_tag: Dict[str, EndpointCollection]
     enums: Dict[str, EnumProperty]
 
+    @staticmethod
+    def check_enums(schemas: Iterable[Schema], collections: Iterable[EndpointCollection]) -> Dict[str, EnumProperty]:
+        enums: Dict[str, EnumProperty] = {}
+
+        def _iterate_properties() -> Generator[Property]:
+            for schema in schemas:
+                yield from schema.required_properties
+                yield from schema.optional_properties
+            for collection in collections:
+                for endpoint in collection.endpoints:
+                    yield from endpoint.path_parameters
+                    yield from endpoint.query_parameters
+
+        for prop in _iterate_properties():
+            if not isinstance(prop, EnumProperty):
+                continue
+
+            if prop.reference.class_name in enums:
+                # We already have an enum with this name, make sure the values match
+                assert (
+                    prop.values == enums[prop.reference.class_name].values
+                ), f"Encountered conflicting enum named {prop.reference.class_name}"
+
+            enums[prop.reference.class_name] = prop
+        return enums
+
     @staticmethod
     def from_dict(d: Dict, /) -> OpenAPI:
         """ Create an OpenAPI from dict """
         schemas = Schema.dict(d["components"]["schemas"])
-        enums: Dict[str, EnumProperty] = {}
-        for schema in schemas.values():
-            for prop in schema.required_properties + schema.optional_properties:
-                if not isinstance(prop, EnumProperty):
-                    continue
-                schema.relative_imports.add(f"from .{prop.name} import {prop.class_name}")
-                if prop.class_name in enums:
-                    # We already have an enum with this name, make sure the values match
-                    assert (
-                        prop.values == enums[prop.class_name].values
-                    ), f"Encountered conflicting enum named {prop.class_name}"
-
-                enums[prop.class_name] = prop
+        endpoint_collections_by_tag = EndpointCollection.from_dict(d["paths"])
+        enums = OpenAPI.check_enums(schemas.values(), endpoint_collections_by_tag.values())
 
         return OpenAPI(
             title=d["info"]["title"],
             description=d["info"]["description"],
             version=d["info"]["version"],
-            endpoint_collections_by_tag=EndpointCollection.from_dict(d["paths"]),
+            endpoint_collections_by_tag=endpoint_collections_by_tag,
             schemas=schemas,
             security_schemes=d["components"]["securitySchemes"],
             enums=enums,

openapi_python_client/models/openapi.py

@@ -1,8 +1,6 @@
 from dataclasses import dataclass, field
 from typing import Optional, List, Dict, Union, ClassVar
 
-import stringcase
-
 from .reference import Reference
 
 
@@ -36,6 +34,10 @@ def to_string(self) -> str:
         else:
             return f"{self.name}: {self.get_type_string()}"
 
+    def transform(self) -> str:
+        """ What it takes to turn this object into a native python type """
+        return self.name
+
 
 @dataclass
 class StringProperty(Property):
@@ -100,17 +102,25 @@ class EnumProperty(Property):
     """ A property that should use an enum """
 
     values: Dict[str, str]
-    class_name: str = field(init=False)
+    inverse_values: Dict[str, str] = field(init=False)
+    reference: Reference = field(init=False)
 
     def __post_init__(self):
-        self.class_name = stringcase.pascalcase(self.name)
+        self.reference = Reference(self.name)
+        self.inverse_values = {v: k for k, v in self.values.items()}
+        if self.default is not None:
+            self.default = f"{self.reference.class_name}.{self.inverse_values[self.default]}"
 
     def get_type_string(self):
         """ Get a string representation of type that should be used when declaring this property """
 
         if self.required:
-            return self.class_name
-        return f"Optional[{self.class_name}]"
+            return self.reference.class_name
+        return f"Optional[{self.reference.class_name}]"
+
+    def transform(self) -> str:
+        """ Output to the template, convert this Enum into a JSONable value """
+        return f"{self.name}.value"
 
     @staticmethod
     def values_from_list(l: List[str], /) -> Dict[str, str]:
@@ -140,21 +150,13 @@ def get_type_string(self):
             return self.reference.class_name
         return f"Optional[{self.reference.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 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",

openapi_python_client/models/properties.py

@@ -1,4 +1,5 @@
 from dataclasses import asdict
+from typing import Optional
 
 import requests
 
@@ -11,43 +12,42 @@ from ..client import AuthenticatedClient, Client
 
 def {{ endpoint.name }}(
     *,
+    {# Proper client based on whether or not the endpoint requires authentication #}
     {% if endpoint.requires_security %}
     client: AuthenticatedClient,
     {% else %}
     client: Client,
     {% endif %}
+    {# Form data if any #}
     {% if endpoint.form_body_reference %}
     form_data: {{ endpoint.form_body_reference.class_name }},
     {% endif %}
+    {# query parameters #}
+    {% if endpoint.query_parameters %}
+    {% for parameter in endpoint.query_parameters %}
+    {{ parameter.to_string() }},
+    {% endfor %}
+    {% endif %}
 ):
     """ {{ endpoint.description }} """
     url = client.base_url + "{{ endpoint.path }}"
 
-    {% if endpoint.method == "get" %}
-    return requests.get(url=url, headers=client.get_headers())
-    {% elif endpoint.method == "post" %}
-    return requests.post(
+    {% if endpoint.query_parameters %}
+    params = {
+        {% for parameter in endpoint.query_parameters %}
+        "{{ parameter.name }}": {{ parameter.transform() }},
+        {% endfor %}
+    }
+    {% endif %}
+
+    return requests.{{ endpoint.method }}(
         url=url,
         headers=client.get_headers(),
         {% if endpoint.form_body_reference %}
         data=asdict(form_data),
         {% endif %}
-    )
-    {% elif endpoint.method == "patch" %}
-    return requests.patch(
-        url=url,
-        headers=client.get_headers()
-        {% if endpoint.form_body_reference %}
-        data=asdict(form_data),
+        {% if endpoint.query_parameters %}
+        params=params,
         {% endif %}
     )
-    {% elif endpoint.method == "put" %}
-    return requests.put(
-        url=url,
-        headers=client.get_headers()
-        {% if endpoint.form_body_reference %}
-        data=asdict(form_data),
-        {% endif %}
-    )
-    {% endif %}
 {% endfor %}

openapi_python_client/templates/endpoint_module.pyi

@@ -1,6 +1,6 @@
 from enum import Enum
 
-class {{ enum.class_name }}(Enum):
+class {{ enum.reference.class_name }}(Enum):
     {% for key, value in enum.values.items() %}
     {{ key }} = "{{ value }}"
     {% endfor %}