openapi-python-client 0.17.3__tar.gz → 0.18.0__tar.gz

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openapi-python-client
-Version: 0.17.3
+Version: 0.18.0
 Summary: Generate modern Python clients from OpenAPI
 Project-URL: repository, https://github.com/openapi-generators/openapi-python-client
 Author-email: Dylan Anthony <contact@dylananthony.com>
@@ -21,12 +21,12 @@ Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.8
 Requires-Dist: attrs>=21.3.0
 Requires-Dist: colorama>=0.4.3; sys_platform == 'win32'
-Requires-Dist: httpx<0.27.0,>=0.20.0
+Requires-Dist: httpx<0.28.0,>=0.20.0
 Requires-Dist: jinja2<4.0.0,>=3.0.0
 Requires-Dist: pydantic<3.0.0,>=2.1.1
 Requires-Dist: python-dateutil<3.0.0,>=2.8.1
 Requires-Dist: pyyaml<7.0,>=6.0
-Requires-Dist: ruff<1.0.0,>=0.1.2
+Requires-Dist: ruff<0.3,>=0.2
 Requires-Dist: shellingham<2.0.0,>=1.3.2
 Requires-Dist: typer<0.10,>0.6
 Requires-Dist: typing-extensions<5.0.0,>=4.8.0

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/parser/openapi.py

@@ -1,5 +1,4 @@
 import re
-from collections import OrderedDict
 from copy import deepcopy
 from dataclasses import dataclass, field
 from http import HTTPStatus
@@ -14,7 +13,6 @@ from ..utils import PythonIdentifier
 from .bodies import Body, body_from_data
 from .errors import GeneratorError, ParseError, PropertyError
 from .properties import (
-    AnyProperty,
     Class,
     EnumProperty,
     ModelProperty,
@@ -134,14 +132,13 @@ class Endpoint:
     tag: str
     summary: Optional[str] = ""
     relative_imports: Set[str] = field(default_factory=set)
-    query_parameters: Dict[str, Property] = field(default_factory=dict)
-    path_parameters: "OrderedDict[str, Property]" = field(default_factory=OrderedDict)
-    header_parameters: Dict[str, Property] = field(default_factory=dict)
-    cookie_parameters: Dict[str, Property] = field(default_factory=dict)
+    query_parameters: List[Property] = field(default_factory=list)
+    path_parameters: List[Property] = field(default_factory=list)
+    header_parameters: List[Property] = field(default_factory=list)
+    cookie_parameters: List[Property] = field(default_factory=list)
     responses: List[Response] = field(default_factory=list)
     bodies: List[Body] = field(default_factory=list)
     errors: List[ParseError] = field(default_factory=list)
-    used_python_identifiers: Set[PythonIdentifier] = field(default_factory=set)
 
     @staticmethod
     def _add_responses(
@@ -191,7 +188,7 @@ class Endpoint:
         return endpoint, schemas
 
     @staticmethod
-    def add_parameters(  # noqa: PLR0911
+    def add_parameters(
         *,
         endpoint: "Endpoint",
         data: Union[oai.Operation, oai.PathItem],
@@ -228,22 +225,11 @@ class Endpoint:
         endpoint = deepcopy(endpoint)
 
         unique_parameters: Set[Tuple[str, oai.ParameterLocation]] = set()
-        parameters_by_location: Dict[str, Dict[str, Property]] = {
+        parameters_by_location: Dict[str, List[Property]] = {
             oai.ParameterLocation.QUERY: endpoint.query_parameters,
             oai.ParameterLocation.PATH: endpoint.path_parameters,
             oai.ParameterLocation.HEADER: endpoint.header_parameters,
             oai.ParameterLocation.COOKIE: endpoint.cookie_parameters,
-            "RESERVED": {  # These can't be param names because codegen needs them as vars, the properties don't matter
-                "client": AnyProperty(
-                    "client",
-                    True,
-                    None,
-                    PythonIdentifier("client", ""),
-                    None,
-                    None,
-                ),
-                "url": AnyProperty("url", True, None, PythonIdentifier("url", ""), None, None),
-            },
         }
 
         for param in data.parameters:
@@ -273,6 +259,12 @@ class Endpoint:
 
             unique_parameters.add(unique_param)
 
+            if any(
+                other_param for other_param in parameters_by_location[param.param_in] if other_param.name == param.name
+            ):
+                # Defined at the operation level, ignore it here
+                continue
+
             prop, new_schemas = property_from_data(
                 name=param.name,
                 required=param.required,
@@ -299,47 +291,69 @@ class Endpoint:
                 location_error.data = param
                 return location_error, schemas, parameters
 
-            if prop.name in parameters_by_location[param.param_in]:
-                # This parameter was defined in the Operation, so ignore the PathItem definition
+            # No reasons to use lazy imports in endpoints, so add lazy imports to relative here.
+            endpoint.relative_imports.update(prop.get_lazy_imports(prefix=models_relative_prefix))
+            endpoint.relative_imports.update(prop.get_imports(prefix=models_relative_prefix))
+            parameters_by_location[param.param_in].append(prop)
+
+        return endpoint._check_parameters_for_conflicts(config=config), schemas, parameters
+
+    def _check_parameters_for_conflicts(
+        self,
+        *,
+        config: Config,
+        previously_modified_params: Optional[Set[Tuple[oai.ParameterLocation, str]]] = None,
+    ) -> Union["Endpoint", ParseError]:
+        """Check for conflicting parameters
+
+        For parameters that have the same python_name but are in different locations, append the location to the
+        python_name. For parameters that have the same name but are in the same location, use their raw name without
+        snake casing instead.
+
+        Function stops when there's a conflict that can't be resolved or all parameters are guaranteed to have a
+        unique python_name.
+        """
+        modified_params = previously_modified_params or set()
+        used_python_names: Dict[PythonIdentifier, Tuple[oai.ParameterLocation, Property]] = {}
+        reserved_names = ["client", "url"]
+        for parameter in self.iter_all_parameters():
+            location, prop = parameter
+
+            if prop.python_name in reserved_names:
+                prop.set_python_name(new_name=f"{prop.python_name}_{location}", config=config)
+                modified_params.add((location, prop.name))
                 continue
 
-            for location, parameters_dict in parameters_by_location.items():
-                if location == param.param_in or prop.name not in parameters_dict:
-                    continue
-                existing_prop: Property = parameters_dict[prop.name]
-                # Existing should be converted too for consistency
-                endpoint.used_python_identifiers.discard(existing_prop.python_name)
-                existing_prop.set_python_name(new_name=f"{existing_prop.name}_{location}", config=config)
-
-                if existing_prop.python_name in endpoint.used_python_identifiers:
-                    return (
-                        ParseError(
-                            detail=f"Parameters with same Python identifier `{existing_prop.python_name}` detected",
-                            data=data,
-                        ),
-                        schemas,
-                        parameters,
-                    )
-                endpoint.used_python_identifiers.add(existing_prop.python_name)
-                prop.set_python_name(new_name=f"{param.name}_{param.param_in}", config=config)
+            conflicting = used_python_names.pop(prop.python_name, None)
+            if conflicting is None:
+                used_python_names[prop.python_name] = parameter
+                continue
+            conflicting_location, conflicting_prop = conflicting
+            if (conflicting_location, conflicting_prop.name) in modified_params or (
+                location,
+                prop.name,
+            ) in modified_params:
+                return ParseError(
+                    detail=f"Parameters with same Python identifier {conflicting_prop.python_name} detected",
+                )
 
-            if prop.python_name in endpoint.used_python_identifiers:
-                return (
-                    ParseError(
-                        detail=f"Parameters with same Python identifier `{prop.python_name}` detected",
-                        data=data,
-                    ),
-                    schemas,
-                    parameters,
+            if location != conflicting_location:
+                conflicting_prop.set_python_name(
+                    new_name=f"{conflicting_prop.python_name}_{conflicting_location}", config=config
                 )
+                prop.set_python_name(new_name=f"{prop.python_name}_{location}", config=config)
+            elif conflicting_prop.name != prop.name:  # Use the name to differentiate
+                conflicting_prop.set_python_name(new_name=conflicting_prop.name, config=config, skip_snake_case=True)
+                prop.set_python_name(new_name=prop.name, config=config, skip_snake_case=True)
 
-            # No reasons to use lazy imports in endpoints, so add lazy imports to relative here.
-            endpoint.relative_imports.update(prop.get_lazy_imports(prefix=models_relative_prefix))
-            endpoint.relative_imports.update(prop.get_imports(prefix=models_relative_prefix))
-            endpoint.used_python_identifiers.add(prop.python_name)
-            parameters_by_location[param.param_in][prop.name] = prop
+            modified_params.add((location, conflicting_prop.name))
+            modified_params.add((conflicting_location, conflicting_prop.name))
+            used_python_names[prop.python_name] = parameter
+            used_python_names[conflicting_prop.python_name] = conflicting
 
-        return endpoint, schemas, parameters
+        if len(modified_params) > 0 and modified_params != previously_modified_params:
+            return self._check_parameters_for_conflicts(config=config, previously_modified_params=modified_params)
+        return self
 
     @staticmethod
     def sort_parameters(*, endpoint: "Endpoint") -> Union["Endpoint", ParseError]:
@@ -356,15 +370,13 @@ class Endpoint:
         endpoint = deepcopy(endpoint)
         parameters_from_path = re.findall(_PATH_PARAM_REGEX, endpoint.path)
         try:
-            sorted_params = sorted(
-                endpoint.path_parameters.values(),
+            endpoint.path_parameters.sort(
                 key=lambda param: parameters_from_path.index(param.name),
             )
-            endpoint.path_parameters = OrderedDict((param.name, param) for param in sorted_params)
         except ValueError:
             pass  # We're going to catch the difference down below
 
-        if parameters_from_path != list(endpoint.path_parameters):
+        if parameters_from_path != [param.name for param in endpoint.path_parameters]:
             return ParseError(
                 detail=f"Incorrect path templating for {endpoint.path} (Path parameters do not match with path)",
             )
@@ -442,17 +454,22 @@ class Endpoint:
             return self.responses[0].prop.get_type_string(quoted=False)
         return f"Union[{', '.join(types)}]"
 
-    def iter_all_parameters(self) -> Iterator[Property]:
+    def iter_all_parameters(self) -> Iterator[Tuple[oai.ParameterLocation, Property]]:
         """Iterate through all the parameters of this endpoint"""
-        yield from self.path_parameters.values()
-        yield from self.query_parameters.values()
-        yield from self.header_parameters.values()
-        yield from self.cookie_parameters.values()
-        yield from (body.prop for body in self.bodies)
+        yield from ((oai.ParameterLocation.PATH, param) for param in self.path_parameters)
+        yield from ((oai.ParameterLocation.QUERY, param) for param in self.query_parameters)
+        yield from ((oai.ParameterLocation.HEADER, param) for param in self.header_parameters)
+        yield from ((oai.ParameterLocation.COOKIE, param) for param in self.cookie_parameters)
 
     def list_all_parameters(self) -> List[Property]:
         """Return a List of all the parameters of this endpoint"""
-        return list(self.iter_all_parameters())
+        return (
+            self.path_parameters
+            + self.query_parameters
+            + self.header_parameters
+            + self.cookie_parameters
+            + [body.prop for body in self.bodies]
+        )
 
 
 @dataclass

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/parser/properties/model_property.py

@@ -267,6 +267,17 @@ def _merge_properties(first: Property, second: Property) -> Property | PropertyE
     )
 
 
+def _resolve_naming_conflict(first: Property, second: Property, config: Config) -> PropertyError | None:
+    first.set_python_name(first.name, config=config, skip_snake_case=True)
+    second.set_python_name(second.name, config=config, skip_snake_case=True)
+    if first.python_name == second.python_name:
+        return PropertyError(
+            header="Conflicting property names",
+            detail=f"Properties {first.name} and {second.name} have the same python_name",
+        )
+    return None
+
+
 class _PropertyData(NamedTuple):
     optional_props: list[Property]
     required_props: list[Property]
@@ -293,13 +304,23 @@ def _process_properties(  # noqa: PLR0912, PLR0911
     def _add_if_no_conflict(new_prop: Property) -> PropertyError | None:
         nonlocal properties
 
-        existing = properties.get(new_prop.name)
-        merged_prop_or_error = _merge_properties(existing, new_prop) if existing else new_prop
+        name_conflict = properties.get(new_prop.name)
+        merged_prop_or_error = _merge_properties(name_conflict, new_prop) if name_conflict else new_prop
         if isinstance(merged_prop_or_error, PropertyError):
             merged_prop_or_error.header = (
                 f"Found conflicting properties named {new_prop.name} when creating {class_name}"
             )
             return merged_prop_or_error
+
+        for other_prop in properties.values():
+            if other_prop.name == merged_prop_or_error.name:
+                continue  # Same property, probably just got merged
+            if other_prop.python_name != merged_prop_or_error.python_name:
+                continue
+            naming_error = _resolve_naming_conflict(merged_prop_or_error, other_prop, config)
+            if naming_error is not None:
+                return naming_error
+
         properties[merged_prop_or_error.name] = merged_prop_or_error
         return None
 

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/parser/properties/protocol.py

@@ -67,14 +67,18 @@ class PropertyProtocol(Protocol):
             return ParseError(detail="Path parameter must be required")
         return None
 
-    def set_python_name(self, new_name: str, config: Config) -> None:
+    def set_python_name(self, new_name: str, config: Config, skip_snake_case: bool = False) -> None:
         """Mutates this Property to set a new python_name.
 
         Required to mutate due to how Properties are stored and the difficulty of updating them in-dict.
         `new_name` will be validated before it is set, so `python_name` is not guaranteed to equal `new_name` after
         calling this.
         """
-        object.__setattr__(self, "python_name", PythonIdentifier(value=new_name, prefix=config.field_prefix))
+        object.__setattr__(
+            self,
+            "python_name",
+            PythonIdentifier(value=new_name, prefix=config.field_prefix, skip_snake_case=skip_snake_case),
+        )
 
     def get_base_type_string(self, *, quoted: bool = False) -> str:
         """Get the string describing the Python type of this property. Base types no require quoting."""

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/templates/endpoint_macros.py.jinja

@@ -5,7 +5,7 @@
 {% if endpoint.header_parameters or endpoint.bodies | length > 0 %}
 headers: Dict[str, Any] = {}
 {% if endpoint.header_parameters %}
-    {% for parameter in endpoint.header_parameters.values() %}
+    {% for parameter in endpoint.header_parameters %}
         {% import "property_templates/" + parameter.template as param_template %}
         {% if param_template.transform_header %}
             {% set expression = param_template.transform_header(parameter.python_name) %}
@@ -22,7 +22,7 @@ headers: Dict[str, Any] = {}
 {% macro cookie_params(endpoint) %}
 {% if endpoint.cookie_parameters %}
 cookies = {}
-    {% for parameter in endpoint.cookie_parameters.values() %}
+    {% for parameter in endpoint.cookie_parameters %}
         {% if parameter.required %}
 cookies["{{ parameter.name}}"] = {{ parameter.python_name }}
         {% else %}
@@ -39,7 +39,7 @@ if {{ parameter.python_name }} is not UNSET:
 {% if endpoint.query_parameters %}
 params: Dict[str, Any] = {}
 
-{% for property in endpoint.query_parameters.values() %}
+{% for property in endpoint.query_parameters %}
     {% set destination = property.python_name %}
     {% import "property_templates/" + property.template as prop_template %}
     {% if prop_template.transform %}
@@ -91,7 +91,7 @@ params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 {# The all the kwargs passed into an endpoint (and variants thereof)) #}
 {% macro arguments(endpoint, include_client=True) %}
 {# path parameters #}
-{% for parameter in endpoint.path_parameters.values() %}
+{% for parameter in endpoint.path_parameters %}
 {{ parameter.to_string() }},
 {% endfor %}
 {% if include_client or ((endpoint.list_all_parameters() | length) > (endpoint.path_parameters | length)) %}
@@ -116,21 +116,21 @@ body: Union[
 ],
 {% endif %}
 {# query parameters #}
-{% for parameter in endpoint.query_parameters.values() %}
+{% for parameter in endpoint.query_parameters %}
 {{ parameter.to_string() }},
 {% endfor %}
-{% for parameter in endpoint.header_parameters.values() %}
+{% for parameter in endpoint.header_parameters %}
 {{ parameter.to_string() }},
 {% endfor %}
 {# cookie parameters #}
-{% for parameter in endpoint.cookie_parameters.values() %}
+{% for parameter in endpoint.cookie_parameters %}
 {{ parameter.to_string() }},
 {% endfor %}
 {% endmacro %}
 
 {# Just lists all kwargs to endpoints as name=name for passing to other functions #}
 {% macro kwargs(endpoint, include_client=True) %}
-{% for parameter in endpoint.path_parameters.values() %}
+{% for parameter in endpoint.path_parameters %}
 {{ parameter.python_name }}={{ parameter.python_name }},
 {% endfor %}
 {% if include_client %}
@@ -139,13 +139,13 @@ client=client,
 {% if endpoint.bodies | length > 0 %}
 body=body,
 {% endif %}
-{% for parameter in endpoint.query_parameters.values() %}
+{% for parameter in endpoint.query_parameters %}
 {{ parameter.python_name }}={{ parameter.python_name }},
 {% endfor %}
-{% for parameter in endpoint.header_parameters.values() %}
+{% for parameter in endpoint.header_parameters %}
 {{ parameter.python_name }}={{ parameter.python_name }},
 {% endfor %}
-{% for parameter in endpoint.cookie_parameters.values() %}
+{% for parameter in endpoint.cookie_parameters %}
 {{ parameter.python_name }}={{ parameter.python_name }},
 {% endfor %}
 {% endmacro %}

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/templates/endpoint_module.py.jinja

@@ -30,7 +30,7 @@ def _get_kwargs(
         "method": "{{ endpoint.method }}",
         {% if endpoint.path_parameters %}
         "url": "{{ endpoint.path }}".format(
-        {%- for parameter in endpoint.path_parameters.values() -%}
+        {%- for parameter in endpoint.path_parameters -%}
         {{parameter.name}}={{parameter.python_name}},
         {%- endfor -%}
         ),

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/templates/pyproject.toml.jinja

@@ -19,7 +19,7 @@ include = ["CHANGELOG.md", "{{ package_name }}/py.typed"]
 
 {% if pdm %}
 dependencies = [
-    "httpx>=0.20.0,<0.27.0",
+    "httpx>=0.20.0,<0.28.0",
     "attrs>=21.3.0",
     "python-dateutil>=2.8.0",
 ]
@@ -31,7 +31,7 @@ package-type = "library"
 
 [tool.poetry.dependencies]
 python = "^3.8"
-httpx = ">=0.20.0,<0.27.0"
+httpx = ">=0.20.0,<0.28.0"
 attrs = ">=21.3.0"
 python-dateutil = "^2.8.0"
 {% endif %}

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/templates/pyproject_ruff.toml.jinja

@@ -1,3 +1,5 @@
 [tool.ruff]
-select = ["F", "I", "UP"]
 line-length = 120
+
+[tool.ruff.lint]
+select = ["F", "I", "UP"]

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/templates/setup.py.jinja

@@ -13,6 +13,6 @@ setup(
     long_description_content_type="text/markdown",
     packages=find_packages(),
     python_requires=">=3.8, <4",
-    install_requires=["httpx >= 0.20.0, < 0.27.0", "attrs >= 21.3.0", "python-dateutil >= 2.8.0, < 3"],
+    install_requires=["httpx >= 0.20.0, < 0.28.0", "attrs >= 21.3.0", "python-dateutil >= 2.8.0, < 3"],
     package_data={"{{ package_name }}": ["py.typed"]},
 )

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/openapi_python_client/utils.py

@@ -12,8 +12,11 @@ DELIMITERS = r"\. _-"
 class PythonIdentifier(str):
     """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)))
+    def __new__(cls, value: str, prefix: str, skip_snake_case: bool = False) -> PythonIdentifier:
+        new_value = sanitize(value)
+        if not skip_snake_case:
+            new_value = snake_case(new_value)
+        new_value = fix_reserved_words(new_value)
 
         if not new_value.isidentifier() or value.startswith("_"):
             new_value = f"{prefix}{new_value}"

{openapi_python_client-0.17.3 → openapi_python_client-0.18.0}/pyproject.toml

@@ -12,13 +12,13 @@ dependencies = [
     "pydantic>=2.1.1,<3.0.0",
     "attrs>=21.3.0",
     "python-dateutil>=2.8.1,<3.0.0",
-    "httpx>=0.20.0,<0.27.0",
+    "httpx>=0.20.0,<0.28.0",
     "PyYAML>=6.0,<7.0",
-    "ruff>=0.1.2,<1.0.0",
+    "ruff>=0.2,<0.3",
     "typing-extensions>=4.8.0,<5.0.0",
 ]
 name = "openapi-python-client"
-version = "0.17.3"
+version = "0.18.0"
 description = "Generate modern Python clients from OpenAPI"
 keywords = [
     "OpenAPI",
@@ -47,7 +47,6 @@ repository = "https://github.com/openapi-generators/openapi-python-client"
 openapi-python-client = "openapi_python_client.cli:app"
 
 [tool.ruff]
-select = ["E", "F", "I", "UP", "B", "PL", "RUF"]
 line-length = 120
 exclude = [
     ".git",
@@ -57,9 +56,12 @@ exclude = [
     "end_to_end_tests/*",
     "tests/test_templates/*",
 ]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "PL", "RUF"]
 ignore = ["E501", "PLR0913"]
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "openapi_python_client/cli.py" = ["B008"]
 
 [tool.coverage.run]