openapi-python-client 0.25.3__tar.gz → 0.26.1__tar.gz

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openapi-python-client
-Version: 0.25.3
+Version: 0.26.1
 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>
@@ -26,9 +26,9 @@ Requires-Dist: jinja2<4.0.0,>=3.0.0
 Requires-Dist: pydantic<3.0.0,>=2.10
 Requires-Dist: python-dateutil<3.0.0,>=2.8.1
 Requires-Dist: ruamel-yaml<0.19.0,>=0.18.6
-Requires-Dist: ruff<0.13,>=0.2
+Requires-Dist: ruff<0.14,>=0.2
 Requires-Dist: shellingham<2.0.0,>=1.3.2
-Requires-Dist: typer<0.17,>0.6
+Requires-Dist: typer<0.18,>0.6
 Requires-Dist: typing-extensions<5.0.0,>=4.8.0
 Description-Content-Type: text/markdown
 

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/openapi_python_client/parser/openapi.py

@@ -2,7 +2,6 @@ import re
 from collections.abc import Iterator
 from copy import deepcopy
 from dataclasses import dataclass, field
-from http import HTTPStatus
 from typing import Any, Optional, Protocol, Union
 
 from pydantic import ValidationError
@@ -26,7 +25,7 @@ from .properties import (
     property_from_data,
 )
 from .properties.schemas import parameter_from_reference
-from .responses import Response, response_from_data
+from .responses import HTTPStatusPattern, Responses, response_from_data
 
 _PATH_PARAM_REGEX = re.compile("{([a-zA-Z_-][a-zA-Z0-9_-]*)}")
 
@@ -147,7 +146,7 @@ class Endpoint:
     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)
+    responses: Responses = field(default_factory=lambda: Responses(patterns=[], default=None))
     bodies: list[Body] = field(default_factory=list)
     errors: list[ParseError] = field(default_factory=list)
 
@@ -162,19 +161,9 @@ class Endpoint:
     ) -> tuple["Endpoint", Schemas]:
         endpoint = deepcopy(endpoint)
         for code, response_data in data.items():
-            status_code: HTTPStatus
-            try:
-                status_code = HTTPStatus(int(code))
-            except ValueError:
-                endpoint.errors.append(
-                    ParseError(
-                        detail=(
-                            f"Invalid response status code {code} (not a valid HTTP "
-                            f"status code), response will be omitted from generated "
-                            f"client"
-                        )
-                    )
-                )
+            status_code = HTTPStatusPattern.parse(code)
+            if isinstance(status_code, ParseError):
+                endpoint.errors.append(status_code)
                 continue
 
             response, schemas = response_from_data(
@@ -190,7 +179,7 @@ class Endpoint:
                 endpoint.errors.append(
                     ParseError(
                         detail=(
-                            f"Cannot parse response for status code {status_code}{detail_suffix}, "
+                            f"Cannot parse response for status code {code}{detail_suffix}, "
                             f"response will be omitted from generated client"
                         ),
                         data=response.data,
@@ -201,7 +190,11 @@ class Endpoint:
             # No reasons to use lazy imports in endpoints, so add lazy imports to relative here.
             endpoint.relative_imports |= response.prop.get_lazy_imports(prefix=models_relative_prefix)
             endpoint.relative_imports |= response.prop.get_imports(prefix=models_relative_prefix)
-            endpoint.responses.append(response)
+            if response.is_default():
+                endpoint.responses.default = response
+            else:
+                endpoint.responses.patterns.append(response)
+        endpoint.responses.patterns.sort()
         return endpoint, schemas
 
     @staticmethod
@@ -480,7 +473,7 @@ class Endpoint:
         if len(types) == 0:
             return "Any"
         if len(types) == 1:
-            return self.responses[0].prop.get_type_string(quoted=False)
+            return types[0]
         return f"Union[{', '.join(types)}]"
 
     def iter_all_parameters(self) -> Iterator[tuple[oai.ParameterLocation, Property]]:

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/openapi_python_client/parser/properties/__init__.py

@@ -40,6 +40,7 @@ from .schemas import (
     Parameters,
     ReferencePath,
     Schemas,
+    get_reference_simple_name,
     parse_reference_path,
     update_parameters_with_data,
     update_schemas_with_data,
@@ -324,17 +325,30 @@ def _create_schemas(
     while still_making_progress:
         still_making_progress = False
         errors = []
-        next_round = []
+        next_round: list[tuple[str, oai.Reference | oai.Schema]] = []
         # Only accumulate errors from the last round, since we might fix some along the way
         for name, data in to_process:
-            if isinstance(data, oai.Reference):
-                schemas.errors.append(PropertyError(data=data, detail="Reference schemas are not supported."))
-                continue
+            schema_data: oai.Reference | oai.Schema | None = data
             ref_path = parse_reference_path(f"#/components/schemas/{name}")
             if isinstance(ref_path, ParseError):
                 schemas.errors.append(PropertyError(detail=ref_path.detail, data=data))
                 continue
-            schemas_or_err = update_schemas_with_data(ref_path=ref_path, data=data, schemas=schemas, config=config)
+            if isinstance(data, oai.Reference):
+                # Fully dereference reference schemas
+                seen = [name]
+                while isinstance(schema_data, oai.Reference):
+                    data_ref_schema = get_reference_simple_name(schema_data.ref)
+                    if data_ref_schema in seen:
+                        schemas.errors.append(PropertyError(detail="Circular schema references found", data=data))
+                        break
+                    # use derefenced schema definition for this schema
+                    schema_data = components.get(data_ref_schema)
+            if isinstance(schema_data, oai.Schema):
+                schemas_or_err = update_schemas_with_data(
+                    ref_path=ref_path, data=schema_data, schemas=schemas, config=config
+                )
+            else:
+                schemas.errors.append(PropertyError(detail="Referent schema not found", data=data))
             if isinstance(schemas_or_err, PropertyError):
                 next_round.append((name, data))
                 errors.append(schemas_or_err)

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/openapi_python_client/parser/properties/union.py

@@ -28,7 +28,14 @@ class UnionProperty(PropertyProtocol):
 
     @classmethod
     def build(
-        cls, *, data: oai.Schema, name: str, required: bool, schemas: Schemas, parent_name: str, config: Config
+        cls,
+        *,
+        data: oai.Schema,
+        name: str,
+        required: bool,
+        schemas: Schemas,
+        parent_name: str,
+        config: Config,
     ) -> tuple[UnionProperty | PropertyError, Schemas]:
         """
         Create a `UnionProperty` the right way.
@@ -55,8 +62,19 @@ class UnionProperty(PropertyProtocol):
                 type_list_data.append(data.model_copy(update={"type": _type, "default": None}))
 
         for i, sub_prop_data in enumerate(chain(data.anyOf, data.oneOf, type_list_data)):
+            # If a schema has a unique title property, we can use that to carry forward a descriptive name instead of "type_0"
+            subscript: str
+            if (
+                isinstance(sub_prop_data, oai.Schema)
+                and sub_prop_data.title is not None
+                and sub_prop_data.title != data.title
+            ):
+                subscript = sub_prop_data.title
+            else:
+                subscript = f"type_{i}"
+
             sub_prop, schemas = property_from_data(
-                name=f"{name}_type_{i}",
+                name=f"{name}_{subscript}",
                 required=True,
                 data=sub_prop_data,
                 schemas=schemas,
@@ -64,7 +82,10 @@ class UnionProperty(PropertyProtocol):
                 config=config,
             )
             if isinstance(sub_prop, PropertyError):
-                return PropertyError(detail=f"Invalid property in union {name}", data=sub_prop_data), schemas
+                return (
+                    PropertyError(detail=f"Invalid property in union {name}", data=sub_prop_data),
+                    schemas,
+                )
             sub_properties.append(sub_prop)
 
         def flatten_union_properties(sub_properties: list[PropertyProtocol]) -> list[PropertyProtocol]:
@@ -108,7 +129,12 @@ class UnionProperty(PropertyProtocol):
 
     def _get_inner_type_strings(self, json: bool) -> set[str]:
         return {
-            p.get_type_string(no_optional=True, json=json, quoted=not p.is_base_type) for p in self.inner_properties
+            p.get_type_string(
+                no_optional=True,
+                json=json,
+                quoted=not p.is_base_type,
+            )
+            for p in self.inner_properties
         }
 
     @staticmethod

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/openapi_python_client/parser/responses.py

@@ -1,6 +1,6 @@
-__all__ = ["Response", "response_from_data"]
+__all__ = ["HTTPStatusPattern", "Response", "Responses", "response_from_data"]
 
-from http import HTTPStatus
+from collections.abc import Iterator
 from typing import Optional, TypedDict, Union
 
 from attrs import define
@@ -15,6 +15,20 @@ from .errors import ParseError, PropertyError
 from .properties import AnyProperty, Property, Schemas, property_from_data
 
 
+@define
+class Responses:
+    patterns: list["Response"]
+    default: Optional["Response"]
+
+    def __iter__(self) -> Iterator["Response"]:
+        yield from self.patterns
+        if self.default:
+            yield self.default
+
+    def __len__(self) -> int:
+        return len(self.patterns) + (1 if self.default else 0)
+
+
 class _ResponseSource(TypedDict):
     """What data should be pulled from the httpx Response object"""
 
@@ -28,15 +42,91 @@ TEXT_SOURCE = _ResponseSource(attribute="response.text", return_type="str")
 NONE_SOURCE = _ResponseSource(attribute="None", return_type="None")
 
 
-@define
+class HTTPStatusPattern:
+    """Status code patterns come in three flavors, in order of precedence:
+    1. Specific status codes, such as 200. This is represented by `min` and `max` being the same.
+    2. Ranges of status codes, such as 2XX. This is represented by `min` and `max` being different.
+    3. The special `default` status code, which is used when no other status codes match. `range` is `None` in this case.
+
+    https://github.com/openapi-generators/openapi-python-client/blob/61b6c54994e2a6285bb422ee3b864c45b5d88c15/openapi_python_client/schema/3.1.0.md#responses-object
+    """
+
+    pattern: str
+    range: Optional[tuple[int, int]]
+
+    def __init__(self, *, pattern: str, code_range: Optional[tuple[int, int]]):
+        """Initialize with a range of status codes or None for the default case."""
+        self.pattern = pattern
+        self.range = code_range
+
+    @staticmethod
+    def parse(pattern: str) -> Union["HTTPStatusPattern", ParseError]:
+        """Parse a status code pattern such as 2XX or 404"""
+        if pattern == "default":
+            return HTTPStatusPattern(pattern=pattern, code_range=None)
+
+        if pattern.endswith("XX") and pattern[0].isdigit():
+            first_digit = int(pattern[0])
+            return HTTPStatusPattern(pattern=pattern, code_range=(first_digit * 100, first_digit * 100 + 99))
+
+        try:
+            code = int(pattern)
+            return HTTPStatusPattern(pattern=pattern, code_range=(code, code))
+        except ValueError:
+            return ParseError(
+                detail=(
+                    f"Invalid response status code pattern: {pattern}, response will be omitted from generated client"
+                )
+            )
+
+    def is_range(self) -> bool:
+        """Check if this is a range of status codes, such as 2XX"""
+        return self.range is not None and self.range[0] != self.range[1]
+
+    def __lt__(self, other: "HTTPStatusPattern") -> bool:
+        """Compare two HTTPStatusPattern objects based on the order they should be applied in"""
+        if self.range is None:
+            return False  # Default gets applied last
+        if other.range is None:
+            return True  # Other is default, so this one gets applied first
+
+        # Specific codes appear before ranges
+        if self.is_range() and not other.is_range():
+            return False
+        if not self.is_range() and other.is_range():
+            return True
+
+        # Order specific codes numerically
+        return self.range[0] < other.range[0]
+
+    def __eq__(self, other: object) -> bool:  # pragma: no cover
+        if not isinstance(other, HTTPStatusPattern):
+            return False
+        return self.range == other.range
+
+    def __hash__(self) -> int:  # pragma: no cover
+        return hash(self.range)
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"<HTTPStatusPattern {self.pattern}>"
+
+
+@define(order=False)
 class Response:
     """Describes a single response for an endpoint"""
 
-    status_code: HTTPStatus
+    status_code: HTTPStatusPattern
     prop: Property
     source: _ResponseSource
     data: Union[oai.Response, oai.Reference]  # Original data which created this response, useful for custom templates
 
+    def is_default(self) -> bool:
+        return self.status_code.range is None
+
+    def __lt__(self, other: "Response") -> bool:
+        """Compare two responses based on the order in which they should be applied in"""
+        return self.status_code < other.status_code
+
 
 def _source_by_content_type(content_type: str, config: Config) -> Optional[_ResponseSource]:
     parsed_content_type = utils.get_content_type(content_type, config)
@@ -59,7 +149,7 @@ def _source_by_content_type(content_type: str, config: Config) -> Optional[_Resp
 
 def empty_response(
     *,
-    status_code: HTTPStatus,
+    status_code: HTTPStatusPattern,
     response_name: str,
     config: Config,
     data: Union[oai.Response, oai.Reference],
@@ -82,7 +172,7 @@ def empty_response(
 
 def response_from_data(  # noqa: PLR0911
     *,
-    status_code: HTTPStatus,
+    status_code: HTTPStatusPattern,
     data: Union[oai.Response, oai.Reference],
     schemas: Schemas,
     responses: dict[str, Union[oai.Response, oai.Reference]],
@@ -91,7 +181,7 @@ def response_from_data(  # noqa: PLR0911
 ) -> tuple[Union[Response, ParseError], Schemas]:
     """Generate a Response from the OpenAPI dictionary representation of it"""
 
-    response_name = f"response_{status_code}"
+    response_name = f"response_{status_code.pattern}"
     if isinstance(data, oai.Reference):
         ref_path = parse_reference_path(data.ref)
         if isinstance(ref_path, ParseError):

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/openapi_python_client/templates/endpoint_macros.py.jinja

@@ -184,3 +184,18 @@ Returns:
 {% macro docstring(endpoint, return_string, is_detailed) %}
 {{ safe_docstring(docstring_content(endpoint, return_string, is_detailed)) }}
 {% endmacro %}
+
+{% macro parse_response(parsed_responses, response) %}
+{% if parsed_responses %}{% import "property_templates/" + response.prop.template as prop_template %}
+{% if prop_template.construct %}
+{{ prop_template.construct(response.prop, response.source.attribute) }}
+{% elif response.source.return_type == response.prop.get_type_string()  %}
+{{ response.prop.python_name }} = {{ response.source.attribute }}
+{% else %}
+{{ response.prop.python_name }} = cast({{ response.prop.get_type_string() }}, {{ response.source.attribute }})
+{% endif %}
+return {{ response.prop.python_name }}
+{% else %}
+return None
+{% endif %}
+{% endmacro %}

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/openapi_python_client/templates/endpoint_module.py.jinja

@@ -64,27 +64,31 @@ def _get_kwargs(
 {% endif %}
     return _kwargs
 
+{% if endpoint.responses.default %}
+    {% set return_type = return_string %}
+{% else %}
+    {% set return_type = "Optional[" + return_string + "]" %}
+{% endif %}
 
-def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[{{ return_string }}]:
-    {% for response in endpoint.responses %}
-    if response.status_code == {{ response.status_code.value }}:
-        {% if parsed_responses %}{% import "property_templates/" + response.prop.template as prop_template %}
-        {% if prop_template.construct %}
-        {{ prop_template.construct(response.prop, response.source.attribute) | indent(8) }}
-        {% elif response.source.return_type == response.prop.get_type_string()  %}
-        {{ response.prop.python_name }} = {{ response.source.attribute }}
-        {% else %}
-        {{ response.prop.python_name }} = cast({{ response.prop.get_type_string() }}, {{ response.source.attribute }})
-        {% endif %}
-        return {{ response.prop.python_name }}
-        {% else %}
-        return None
-        {% endif %}
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> {{return_type}}:
+    {% for response in endpoint.responses.patterns %}
+    {% set code_range = response.status_code.range %}
+    {% if code_range[0] == code_range[1] %}
+    if response.status_code == {{ code_range[0] }}:
+    {% else %}
+    if {{ code_range[0] }} <= response.status_code <= {{ code_range[1] }}:
+    {% endif %}
+        {{ parse_response(parsed_responses, response) | indent(8) }}
     {% endfor %}
+    {% if endpoint.responses.default %}
+    {{ parse_response(parsed_responses, endpoint.responses.default) | indent(4) }}
+    {% else %}
     if client.raise_on_unexpected_status:
         raise errors.UnexpectedStatus(response.status_code, response.content)
     else:
         return None
+    {% endif %}
 
 
 def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[{{ return_string }}]:

{openapi_python_client-0.25.3 → openapi_python_client-0.26.1}/pyproject.toml

@@ -6,7 +6,7 @@ license = { text = "MIT" }
 requires-python = ">=3.9,<4.0"
 dependencies = [
     "jinja2>=3.0.0,<4.0.0",
-    "typer>0.6,<0.17",
+    "typer>0.6,<0.18",
     "colorama>=0.4.3; sys_platform == \"win32\"",
     "shellingham>=1.3.2,<2.0.0",
     "pydantic>=2.10,<3.0.0",
@@ -14,11 +14,11 @@ dependencies = [
     "python-dateutil>=2.8.1,<3.0.0",
     "httpx>=0.23.0,<0.29.0",
     "ruamel.yaml>=0.18.6,<0.19.0",
-    "ruff>=0.2,<0.13",
+    "ruff>=0.2,<0.14",
     "typing-extensions>=4.8.0,<5.0.0",
 ]
 name = "openapi-python-client"
-version = "0.25.3"
+version = "0.26.1"
 description = "Generate modern Python clients from OpenAPI"
 keywords = [
     "OpenAPI",