Merge branch 'master' into pr/31

Author: dbanty

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.3.0 - Unreleased
+### Additions
+- Link to the GitHub repository from PyPI (#26). Thanks @theY4Kman!
+
+### Fixes
+- Fixed some typing issues in generated clients and incorporate mypy into end to end tests (#32). Thanks @acgray!
+- Properly handle camelCase endpoint names and properties (#29, #36). Thanks @acgray!
+
 ## 0.2.1 - 2020-03-22
 ### Fixes
 - Fixed import of errors.py in generated api modules

README.md

@@ -67,16 +67,17 @@ You can pass a YAML (or JSON) file to openapi-python-client in order to change s
 are supported:
 
 ### class_overrides
-Used to change the name of generated model classes, especially useful if you have a name like ABCModel which, when 
-converted to snake case for module naming will be a_b_c_model.  This param should be a mapping of existing class name 
-(usually a key in the "schemas" section of your OpenAPI document) to class_name and module_name.
+Used to change the name of generated model classes.  This param should be a mapping of existing class name 
+(usually a key in the "schemas" section of your OpenAPI document) to class_name and module_name. As an example, if the 
+name of the a model in OpenAPI (and therefore the generated class name) was something like "_PrivateInternalLongName" 
+and you want the generated client's model to be called "ShortName" in a module called "short_name" you could do this:
 
 Example:
 ```yaml
 class_overrides:
-    ABCModel:
-      class_name: ABCModel
-      module_name: abc_model
+    _PrivateInternalLongName:
+      class_name: ShortName
+      module_name: short_name
 ```
 
 The easiest way to find what needs to be overridden is probably to generate your client and go look at everything in the

openapi_python_client/__init__.py

@@ -12,6 +12,8 @@
 import yaml
 from jinja2 import Environment, PackageLoader
 
+from openapi_python_client import utils
+
 from .openapi_parser import OpenAPI, import_string_from_reference
 
 __version__ = version(__package__)
@@ -61,6 +63,8 @@ def _get_json(*, url: Optional[str], path: Optional[Path]) -> Dict[str, Any]:
 
 
 class _Project:
+    TEMPLATE_FILTERS = {"snakecase": utils.snake_case}
+
     def __init__(self, *, openapi: OpenAPI) -> None:
         self.openapi: OpenAPI = openapi
         self.env: Environment = Environment(loader=PackageLoader(__package__), trim_blocks=True, lstrip_blocks=True)
@@ -72,6 +76,8 @@ def __init__(self, *, openapi: OpenAPI) -> None:
         self.package_dir: Path = self.project_dir / self.package_name
         self.package_description = f"A client library for accessing {self.openapi.title}"
 
+        self.env.filters.update(self.TEMPLATE_FILTERS)
+
     def build(self) -> None:
         """ Create the project from templates """
 

openapi_python_client/openapi_parser/openapi.py

@@ -199,10 +199,10 @@ def dict(d: Dict[str, Dict[str, Any]], /) -> Dict[str, Schema]:
 
 @dataclass
 class OpenAPI:
-    """ Top level OpenAPI spec """
+    """ Top level OpenAPI document """
 
     title: str
-    description: str
+    description: Optional[str]
     version: str
     schemas: Dict[str, Schema]
     endpoint_collections_by_tag: Dict[str, EndpointCollection]
@@ -251,7 +251,7 @@ def from_dict(d: Dict[str, Dict[str, Any]], /) -> OpenAPI:
 
         return OpenAPI(
             title=d["info"]["title"],
-            description=d["info"]["description"],
+            description=d["info"].get("description"),
             version=d["info"]["version"],
             endpoint_collections_by_tag=endpoint_collections_by_tag,
             schemas=schemas,

openapi_python_client/openapi_parser/properties.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass, field
 from typing import Any, ClassVar, Dict, List, Optional
 
+from openapi_python_client import utils
+
 from .reference import Reference
 
 
@@ -15,6 +17,11 @@ class Property:
     constructor_template: ClassVar[Optional[str]] = None
     _type_string: ClassVar[str]
 
+    python_name: str = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.python_name = utils.snake_case(self.name)
+
     def get_type_string(self) -> str:
         """ Get a string representation of type that should be used when declaring this property """
         if self.required:
@@ -31,13 +38,13 @@ def to_string(self) -> str:
             default = None
 
         if default is not None:
-            return f"{self.name}: {self.get_type_string()} = {self.default}"
+            return f"{self.python_name}: {self.get_type_string()} = {self.default}"
         else:
-            return f"{self.name}: {self.get_type_string()}"
+            return f"{self.python_name}: {self.get_type_string()}"
 
     def transform(self) -> str:
         """ What it takes to turn this object into a native python type """
-        return self.name
+        return self.python_name
 
     def constructor_from_dict(self, dict_name: str) -> str:
         """ How to load this property from a dict (used in generated model from_dict function """
@@ -57,6 +64,7 @@ class StringProperty(Property):
     _type_string: ClassVar[str] = "str"
 
     def __post_init__(self) -> None:
+        super().__post_init__()
         if self.default is not None:
             self.default = f'"{self.default}"'
 
@@ -132,6 +140,7 @@ class EnumListProperty(Property):
     constructor_template: ClassVar[str] = "enum_list_property.pyi"
 
     def __post_init__(self) -> None:
+        super().__post_init__()
         self.reference = Reference.from_ref(self.name)
 
     def get_type_string(self) -> str:
@@ -149,6 +158,7 @@ class EnumProperty(Property):
     reference: Reference
 
     def __post_init__(self) -> None:
+        super().__post_init__()
         inverse_values = {v: k for k, v in self.values.items()}
         if self.default is not None:
             self.default = f"{self.reference.class_name}.{inverse_values[self.default]}"
@@ -162,11 +172,14 @@ def get_type_string(self) -> str:
 
     def transform(self) -> str:
         """ Output to the template, convert this Enum into a JSONable value """
-        return f"{self.name}.value"
+        return f"{self.python_name}.value"
 
     def constructor_from_dict(self, dict_name: str) -> str:
         """ How to load this property from a dict (used in generated model from_dict function """
-        return f'{self.reference.class_name}({dict_name}["{self.name}"]) if "{self.name}" in {dict_name} else None'
+        constructor = f'{self.reference.class_name}({dict_name}["{self.name}"])'
+        if not self.required:
+            constructor += f' if "{self.name}" in {dict_name} else None'
+        return constructor
 
     @staticmethod
     def values_from_list(l: List[str], /) -> Dict[str, str]:
@@ -200,22 +213,22 @@ def get_type_string(self) -> str:
 
     def transform(self) -> str:
         """ Convert this into a JSONable value """
-        return f"{self.name}.to_dict()"
+        return f"{self.python_name}.to_dict()"
 
 
 @dataclass
 class DictProperty(Property):
     """ Property that is a general Dict """
 
-    _type_string: ClassVar[str] = "Dict"
+    _type_string: ClassVar[str] = "Dict[Any, Any]"
 
 
 _openapi_types_to_python_type_strings = {
     "string": "str",
     "number": "float",
     "integer": "int",
     "boolean": "bool",
-    "object": "Dict",
+    "object": "Dict[Any, Any]",
 }
 
 

openapi_python_client/openapi_parser/reference.py

@@ -5,7 +5,7 @@
 from dataclasses import dataclass
 from typing import Dict
 
-import stringcase
+from .. import utils
 
 class_overrides: Dict[str, Reference] = {}
 
@@ -22,9 +22,9 @@ def from_ref(ref: str) -> Reference:
         """ Get a Reference from the openapi #/schemas/blahblah string """
         ref_value = ref.split("/")[-1]
         # ugly hack to avoid stringcase ugly pascalcase output when ref_value isn't snake case
-        class_name = stringcase.pascalcase(ref_value.replace(" ", ""))
+        class_name = utils.pascal_case(ref_value.replace(" ", ""))
 
         if class_name in class_overrides:
             return class_overrides[class_name]
 
-        return Reference(class_name=class_name, module_name=stringcase.snakecase(class_name),)
+        return Reference(class_name=class_name, module_name=utils.snake_case(class_name))

openapi_python_client/openapi_parser/responses.py

@@ -33,7 +33,7 @@ def return_string(self) -> str:
 
     def constructor(self) -> str:
         """ How the return value of this response should be constructed """
-        return f"[{self.reference.class_name}.from_dict(item) for item in response.json()]"
+        return f"[{self.reference.class_name}.from_dict(item) for item in cast(List[Dict[str, Any]], response.json())]"
 
 
 @dataclass
@@ -48,7 +48,7 @@ def return_string(self) -> str:
 
     def constructor(self) -> str:
         """ How the return value of this response should be constructed """
-        return f"{self.reference.class_name}.from_dict(response.json())"
+        return f"{self.reference.class_name}.from_dict(cast(Dict[str, Any], response.json()))"
 
 
 @dataclass

openapi_python_client/templates/async_endpoint_module.pyi

@@ -1,5 +1,5 @@
 from dataclasses import asdict
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, cast
 
 import httpx
 
@@ -12,7 +12,7 @@ from ..errors import ApiResponseError
 {% for endpoint in collection.endpoints %}
 
 
-async def {{ endpoint.name }}(
+async def {{ endpoint.name | snakecase }}(
     *,
     {# Proper client based on whether or not the endpoint requires authentication #}
     {% if endpoint.requires_security %}
@@ -42,7 +42,12 @@ async def {{ endpoint.name }}(
     {% endfor %}
 ]:
     """ {{ endpoint.description }} """
-    url = f"{client.base_url}{{ endpoint.path }}"
+    url = "{}{{ endpoint.path }}".format(
+        client.base_url
+        {%- for parameter in endpoint.path_parameters -%}
+        ,{{parameter.name}}={{parameter.python_name}}
+        {%- endfor -%}
+    )
 
     {% if endpoint.query_parameters %}
     params = {
@@ -54,14 +59,14 @@ async def {{ endpoint.name }}(
     }
     {% for parameter in endpoint.query_parameters %}
     {% if not parameter.required %}
-    if {{ parameter.name }} is not None:
-        params["{{ parameter.name }}"] = {{ parameter.transform() }}
+    if {{ parameter.python_name }} is not None:
+        params["{{ parameter.name }}"] = str({{ parameter.transform() }})
     {% endif %}
     {% endfor %}
     {% endif %}
 
-    with httpx.AsyncClient() as client:
-        response = await client.{{ endpoint.method }}(
+    async with httpx.AsyncClient() as _client:
+        response = await _client.{{ endpoint.method }}(
             url=url,
             headers=client.get_headers(),
             {% if endpoint.form_body_reference %}

openapi_python_client/templates/datetime_property.pyi

@@ -1,7 +1,7 @@
 {% if property.required %}
-        {{ property.name }} = datetime.fromisoformat(d["{{ property.name }}"])
+        {{ property.python_name }} = datetime.fromisoformat(d["{{ property.name }}"])
 {% else %}
-        {{ property.name }} = None
-        if ({{ property.name }}_string := d.get("{{ property.name }}")) is not None:
-            {{ property.name }} = datetime.fromisoformat(cast(str, {{ property.name }}_string))
+        {{ property.python_name }} = None
+        if ({{ property.python_name }}_string := d.get("{{ property.name }}")) is not None:
+            {{ property.python_name }} = datetime.fromisoformat(cast(str, {{ property.python_name }}_string))
 {% endif %}

openapi_python_client/templates/endpoint_module.pyi

@@ -1,5 +1,5 @@
 from dataclasses import asdict
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, cast
 
 import httpx
 
@@ -12,7 +12,7 @@ from ..errors import ApiResponseError
 {% for endpoint in collection.endpoints %}
 
 
-def {{ endpoint.name }}(
+def {{ endpoint.name | snakecase }}(
     *,
     {# Proper client based on whether or not the endpoint requires authentication #}
     {% if endpoint.requires_security %}
@@ -42,7 +42,12 @@ def {{ endpoint.name }}(
     {% endfor %}
 ]:
     """ {{ endpoint.description }} """
-    url = f"{client.base_url}{{ endpoint.path }}"
+    url = "{}{{ endpoint.path }}".format(
+        client.base_url
+        {%- for parameter in endpoint.path_parameters -%}
+        ,{{parameter.name}}={{parameter.python_name}}
+        {%- endfor -%}
+    )
 
     {% if endpoint.query_parameters %}
     params = {
@@ -54,8 +59,8 @@ def {{ endpoint.name }}(
     }
     {% for parameter in endpoint.query_parameters %}
     {% if not parameter.required %}
-    if {{ parameter.name }} is not None:
-        params["{{ parameter.name }}"] = {{ parameter.transform() }}
+    if {{ parameter.python_name }} is not None:
+        params["{{ parameter.name }}"] = str({{ parameter.transform() }})
     {% endif %}
     {% endfor %}
     {% endif %}