fix: Properly replace reserved words in class and module names [#475, #476]. Thanks @mtovts!

Author: dbanty

end_to_end_tests/custom-templates-golden-record/my_test_api_client/api/__init__.py

@@ -4,6 +4,7 @@
 
 from .default import DefaultEndpoints
 from .location import LocationEndpoints
+from .naming import NamingEndpoints
 from .parameters import ParametersEndpoints
 from .tag1 import Tag1Endpoints
 from .tests import TestsEndpoints
@@ -29,3 +30,7 @@ def tag1(cls) -> Type[Tag1Endpoints]:
     @classmethod
     def location(cls) -> Type[LocationEndpoints]:
         return LocationEndpoints
+
+    @classmethod
+    def naming(cls) -> Type[NamingEndpoints]:
+        return NamingEndpoints

end_to_end_tests/custom-templates-golden-record/my_test_api_client/api/naming/__init__.py

@@ -0,0 +1,11 @@
+""" Contains methods for accessing the API Endpoints """
+
+import types
+
+from . import get_naming_keywords
+
+
+class NamingEndpoints:
+    @classmethod
+    def get_naming_keywords(cls) -> types.ModuleType:
+        return get_naming_keywords

end_to_end_tests/golden-record/my_test_api_client/api/naming/__init__.py

@@ -0,0 +1,72 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    import_: str,
+) -> Dict[str, Any]:
+    url = "{}/naming/keywords".format(client.base_url)
+
+    headers: Dict[str, Any] = client.get_headers()
+    cookies: Dict[str, Any] = client.get_cookies()
+
+    params: Dict[str, Any] = {
+        "import": import_,
+    }
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    return {
+        "url": url,
+        "headers": headers,
+        "cookies": cookies,
+        "timeout": client.get_timeout(),
+        "params": params,
+    }
+
+
+def _build_response(*, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=None,
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    import_: str,
+) -> Response[Any]:
+    kwargs = _get_kwargs(
+        client=client,
+        import_=import_,
+    )
+
+    response = httpx.get(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    import_: str,
+) -> Response[Any]:
+    kwargs = _get_kwargs(
+        client=client,
+        import_=import_,
+    )
+
+    async with httpx.AsyncClient() as _client:
+        response = await _client.get(**kwargs)
+
+    return _build_response(response=response)

end_to_end_tests/golden-record/my_test_api_client/api/naming/get_naming_keywords.py

@@ -19,6 +19,7 @@
 from .different_enum import DifferentEnum
 from .free_form_model import FreeFormModel
 from .http_validation_error import HTTPValidationError
+from .import_ import Import
 from .model_from_all_of import ModelFromAllOf
 from .model_name import ModelName
 from .model_with_additional_properties_inlined import ModelWithAdditionalPropertiesInlined
@@ -35,6 +36,7 @@
 from .model_with_union_property_inlined import ModelWithUnionPropertyInlined
 from .model_with_union_property_inlined_fruit_type_0 import ModelWithUnionPropertyInlinedFruitType0
 from .model_with_union_property_inlined_fruit_type_1 import ModelWithUnionPropertyInlinedFruitType1
+from .none import None_
 from .test_inline_objects_json_body import TestInlineObjectsJsonBody
 from .test_inline_objects_response_200 import TestInlineObjectsResponse200
 from .validation_error import ValidationError

end_to_end_tests/golden-record/my_test_api_client/models/__init__.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="Import")
+
+
+@attr.s(auto_attribs=True)
+class Import:
+    """ """
+
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        import_ = cls()
+
+        import_.additional_properties = d
+        return import_
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/golden-record/my_test_api_client/models/import_.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+T = TypeVar("T", bound="None_")
+
+
+@attr.s(auto_attribs=True)
+class None_:
+    """ """
+
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        none = cls()
+
+        none.additional_properties = d
+        return none
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

end_to_end_tests/golden-record/my_test_api_client/models/none.py

@@ -933,6 +933,26 @@
         ],
         "responses": {}
       }
+    },
+    "/naming/keywords": {
+      "description": "Ensure that Python keywords are renamed properly.",
+      "get": {
+        "tags": [
+          "naming"
+        ],
+        "parameters": [
+          {
+            "name": "import",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "nullable": false
+            },
+            "in": "query"
+          }
+        ],
+        "responses": {}
+      }
     }
   },
   "components": {
@@ -1761,6 +1781,12 @@
       "AByteStream": {
         "type": "string",
         "format": "byte"
+      },
+      "import":  {
+        "type": "object"
+      },
+      "None":  {
+        "type": "object"
       }
     }
   }

end_to_end_tests/openapi.json

@@ -7,7 +7,7 @@
 
 from ... import Config
 from ... import schema as oai
-from ... import utils
+from ...utils import ClassName, PythonIdentifier
 from ..errors import ParseError, PropertyError
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -17,7 +17,6 @@
 
 
 _ReferencePath = NewType("_ReferencePath", str)
-_ClassName = NewType("_ClassName", str)
 
 
 def parse_reference_path(ref_path_raw: str) -> Union[_ReferencePath, ParseError]:
@@ -38,33 +37,34 @@ def parse_reference_path(ref_path_raw: str) -> Union[_ReferencePath, ParseError]
 class Class:
     """Represents Python class which will be generated from an OpenAPI schema"""
 
-    name: _ClassName
-    module_name: str
+    name: ClassName
+    module_name: PythonIdentifier
 
     @staticmethod
     def from_string(*, string: str, config: Config) -> "Class":
         """Get a Class from an arbitrary string"""
         class_name = string.split("/")[-1]  # Get rid of ref path stuff
-        class_name = utils.pascal_case(class_name)
+        class_name = ClassName(class_name, config.field_prefix)
         override = config.class_overrides.get(class_name)
 
         if override is not None and override.class_name is not None:
-            class_name = override.class_name
+            class_name = ClassName(override.class_name, config.field_prefix)
 
         if override is not None and override.module_name is not None:
             module_name = override.module_name
         else:
-            module_name = utils.snake_case(class_name)
+            module_name = class_name
+        module_name = PythonIdentifier(module_name, config.field_prefix)
 
-        return Class(name=cast(_ClassName, class_name), module_name=module_name)
+        return Class(name=class_name, module_name=module_name)
 
 
 @attr.s(auto_attribs=True, frozen=True)
 class Schemas:
     """Structure for containing all defined, shareable, and reusable schemas (attr classes and Enums)"""
 
     classes_by_reference: Dict[_ReferencePath, Property] = attr.ib(factory=dict)
-    classes_by_name: Dict[_ClassName, Property] = attr.ib(factory=dict)
+    classes_by_name: Dict[ClassName, Property] = attr.ib(factory=dict)
     errors: List[ParseError] = attr.ib(factory=list)
 
 

openapi_python_client/parser/properties/schemas.py

@@ -7,7 +7,7 @@
 
 
 class PythonIdentifier(str):
-    """A string which has been validated / transformed into a valid identifier for Python"""
+    """A snake_case string which has been validated / transformed into a valid identifier for Python"""
 
     def __new__(cls, value: str, prefix: str) -> "PythonIdentifier":
         new_value = fix_reserved_words(snake_case(sanitize(value)))
@@ -20,6 +20,20 @@ def __deepcopy__(self, _: Any) -> "PythonIdentifier":
         return self
 
 
+class ClassName(str):
+    """A PascalCase string which has been validated / transformed into a valid class name for Python"""
+
+    def __new__(cls, value: str, prefix: str) -> "ClassName":
+        new_value = fix_reserved_words(pascal_case(sanitize(value)))
+
+        if not new_value.isidentifier():
+            new_value = f"{prefix}{new_value}"
+        return str.__new__(cls, new_value)
+
+    def __deepcopy__(self, _: Any) -> "ClassName":
+        return self
+
+
 def sanitize(value: str) -> str:
     """Removes every character that isn't 0-9, A-Z, a-z, or a known delimiter"""
     return re.sub(rf"[^\w{DELIMITERS}]+", "", value)

openapi_python_client/utils.py

@@ -73,7 +73,7 @@ def test_additional_schemas(self, additional_properties_schema, expected_additio
         )
 
         model, _ = build_model_property(
-            data=data, name="prop", schemas=Schemas(), required=True, parent_name="parent", config=MagicMock()
+            data=data, name="prop", schemas=Schemas(), required=True, parent_name="parent", config=Config()
         )
 
         assert model.additional_properties == expected_additional_properties
@@ -151,7 +151,7 @@ def test_bad_props_return_error(self):
         schemas = Schemas()
 
         err, new_schemas = build_model_property(
-            data=data, name="prop", schemas=schemas, required=True, parent_name=None, config=MagicMock()
+            data=data, name="prop", schemas=schemas, required=True, parent_name=None, config=Config()
         )
 
         assert new_schemas == schemas