openapi-python-client 0.21.5__tar.gz → 0.21.6__tar.gz

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openapi-python-client
-Version: 0.21.5
+Version: 0.21.6
 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>
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.8.1
@@ -26,7 +27,7 @@ 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: ruamel-yaml<0.19.0,>=0.18.6
-Requires-Dist: ruff<0.7,>=0.2
+Requires-Dist: ruff<0.8,>=0.2
 Requires-Dist: shellingham<2.0.0,>=1.3.2
 Requires-Dist: typer<0.13,>0.6
 Requires-Dist: typing-extensions<5.0.0,>=4.8.0
@@ -131,6 +132,17 @@ class_overrides:
 
 The easiest way to find what needs to be overridden is probably to generate your client and go look at everything in the `models` folder.
 
+### literal_enums
+
+By default, `openapi-python-client` generates classes inheriting for `Enum` for enums. It can instead use `Literal` 
+values for enums by setting this to `true`:
+
+```yaml
+literal_enums: true
+```
+
+This is especially useful if enum values, when transformed to their Python names, end up conflicting due to case sensitivity or special symbols.
+
 ### project_name_override and package_name_override
 
 Used to change the name of generated client library project/package. If the project name is changed but an override for the package name

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/README.md

@@ -97,6 +97,17 @@ class_overrides:
 
 The easiest way to find what needs to be overridden is probably to generate your client and go look at everything in the `models` folder.
 
+### literal_enums
+
+By default, `openapi-python-client` generates classes inheriting for `Enum` for enums. It can instead use `Literal` 
+values for enums by setting this to `true`:
+
+```yaml
+literal_enums: true
+```
+
+This is especially useful if enum values, when transformed to their Python names, end up conflicting due to case sensitivity or special symbols.
+
 ### project_name_override and package_name_override
 
 Used to change the name of generated client library project/package. If the project name is changed but an override for the package name

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/__init__.py

@@ -20,6 +20,7 @@ from openapi_python_client import utils
 from .config import Config, MetaType
 from .parser import GeneratorData, import_string_from_class
 from .parser.errors import ErrorLevel, GeneratorError
+from .parser.properties import LiteralEnumProperty
 
 __version__ = version(__package__)
 
@@ -227,9 +228,12 @@ class Project:
         # Generate enums
         str_enum_template = self.env.get_template("str_enum.py.jinja")
         int_enum_template = self.env.get_template("int_enum.py.jinja")
+        literal_enum_template = self.env.get_template("literal_enum.py.jinja")
         for enum in self.openapi.enums:
             module_path = models_dir / f"{enum.class_info.module_name}.py"
-            if enum.value_type is int:
+            if isinstance(enum, LiteralEnumProperty):
+                module_path.write_text(literal_enum_template.render(enum=enum), encoding=self.config.file_encoding)
+            elif enum.value_type is int:
                 module_path.write_text(int_enum_template.render(enum=enum), encoding=self.config.file_encoding)
             else:
                 module_path.write_text(str_enum_template.render(enum=enum), encoding=self.config.file_encoding)

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/config.py

@@ -43,6 +43,7 @@ class ConfigFile(BaseModel):
     post_hooks: Optional[List[str]] = None
     field_prefix: str = "field_"
     http_timeout: int = 5
+    literal_enums: bool = False
 
     @staticmethod
     def load_from_path(path: Path) -> "ConfigFile":
@@ -70,6 +71,7 @@ class Config:
     post_hooks: List[str]
     field_prefix: str
     http_timeout: int
+    literal_enums: bool
     document_source: Union[Path, str]
     file_encoding: str
     content_type_overrides: Dict[str, str]
@@ -109,6 +111,7 @@ class Config:
             post_hooks=post_hooks,
             field_prefix=config_file.field_prefix,
             http_timeout=config_file.http_timeout,
+            literal_enums=config_file.literal_enums,
             document_source=document_source,
             file_encoding=file_encoding,
             overwrite=overwrite,

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/parser/openapi.py

@@ -15,6 +15,7 @@ from .errors import GeneratorError, ParseError, PropertyError
 from .properties import (
     Class,
     EnumProperty,
+    LiteralEnumProperty,
     ModelProperty,
     Parameters,
     Property,
@@ -488,7 +489,7 @@ class GeneratorData:
     models: Iterator[ModelProperty]
     errors: List[ParseError]
     endpoint_collections_by_tag: Dict[utils.PythonIdentifier, EndpointCollection]
-    enums: Iterator[EnumProperty]
+    enums: Iterator[Union[EnumProperty, LiteralEnumProperty]]
 
     @staticmethod
     def from_dict(data: Dict[str, Any], *, config: Config) -> Union["GeneratorData", GeneratorError]:
@@ -517,7 +518,9 @@ class GeneratorData:
             data=openapi.paths, schemas=schemas, parameters=parameters, request_bodies=request_bodies, config=config
         )
 
-        enums = (prop for prop in schemas.classes_by_name.values() if isinstance(prop, EnumProperty))
+        enums = (
+            prop for prop in schemas.classes_by_name.values() if isinstance(prop, (EnumProperty, LiteralEnumProperty))
+        )
         models = (prop for prop in schemas.classes_by_name.values() if isinstance(prop, ModelProperty))
 
         return GeneratorData(

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/__init__.py

@@ -4,6 +4,7 @@ __all__ = [
     "AnyProperty",
     "Class",
     "EnumProperty",
+    "LiteralEnumProperty",
     "ModelProperty",
     "Parameters",
     "Property",
@@ -30,6 +31,7 @@ from .file import FileProperty
 from .float import FloatProperty
 from .int import IntProperty
 from .list_property import ListProperty
+from .literal_enum_property import LiteralEnumProperty
 from .model_property import ModelProperty, process_model
 from .none import NoneProperty
 from .property import Property
@@ -44,11 +46,12 @@ from .schemas import (
 )
 from .string import StringProperty
 from .union import UnionProperty
+from .uuid import UuidProperty
 
 
 def _string_based_property(
     name: str, required: bool, data: oai.Schema, config: Config
-) -> StringProperty | DateProperty | DateTimeProperty | FileProperty | PropertyError:
+) -> StringProperty | DateProperty | DateTimeProperty | FileProperty | UuidProperty | PropertyError:
     """Construct a Property from the type "string" """
     string_format = data.schema_format
     python_name = utils.PythonIdentifier(value=name, prefix=config.field_prefix)
@@ -79,6 +82,15 @@ def _string_based_property(
             description=data.description,
             example=data.example,
         )
+    if string_format == "uuid":
+        return UuidProperty.build(
+            name=name,
+            required=required,
+            default=data.default,
+            python_name=python_name,
+            description=data.description,
+            example=data.example,
+        )
     return StringProperty.build(
         name=name,
         default=data.default,
@@ -184,6 +196,15 @@ def property_from_data(  # noqa: PLR0911, PLR0912
             schemas,
         )
     if data.enum:
+        if config.literal_enums:
+            return LiteralEnumProperty.build(
+                data=data,
+                name=name,
+                required=required,
+                schemas=schemas,
+                parent_name=parent_name,
+                config=config,
+            )
         return EnumProperty.build(
             data=data,
             name=name,

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/enum_property.py

@@ -121,7 +121,7 @@ class EnumProperty(PropertyProtocol):
         if parent_name:
             class_name = f"{utils.pascal_case(parent_name)}{utils.pascal_case(class_name)}"
         class_info = Class.from_string(string=class_name, config=config)
-        values = EnumProperty.values_from_list(value_list)
+        values = EnumProperty.values_from_list(value_list, class_info)
 
         if class_info.name in schemas.classes_by_name:
             existing = schemas.classes_by_name[class_info.name]
@@ -183,7 +183,7 @@ class EnumProperty(PropertyProtocol):
         return imports
 
     @staticmethod
-    def values_from_list(values: list[str] | list[int]) -> dict[str, ValueType]:
+    def values_from_list(values: list[str] | list[int], class_info: Class) -> dict[str, ValueType]:
         """Convert a list of values into dict of {name: value}, where value can sometimes be None"""
         output: dict[str, ValueType] = {}
 
@@ -200,7 +200,10 @@ class EnumProperty(PropertyProtocol):
             else:
                 key = f"VALUE_{i}"
             if key in output:
-                raise ValueError(f"Duplicate key {key} in Enum")
+                raise ValueError(
+                    f"Duplicate key {key} in enum {class_info.module_name}.{class_info.name}; "
+                    f"consider setting literal_enums in your config"
+                )
             sanitized_key = utils.snake_case(key).upper()
             output[sanitized_key] = utils.remove_string_escapes(value)
         return output

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/list_property.py

@@ -58,12 +58,28 @@ class ListProperty(PropertyProtocol):
         """
         from . import property_from_data
 
-        if data.items is None:
-            return PropertyError(data=data, detail="type array must have items defined"), schemas
+        if data.items is None and not data.prefixItems:
+            return (
+                PropertyError(
+                    data=data,
+                    detail="type array must have items or prefixItems defined",
+                ),
+                schemas,
+            )
+
+        items = data.prefixItems or []
+        if data.items:
+            items.append(data.items)
+
+        if len(items) == 1:
+            inner_schema = items[0]
+        else:
+            inner_schema = oai.Schema(anyOf=items)
+
         inner_prop, schemas = property_from_data(
             name=f"{name}_item",
             required=True,
-            data=data.items,
+            data=inner_schema,
             schemas=schemas,
             parent_name=parent_name,
             config=config,

openapi_python_client-0.21.6/openapi_python_client/parser/properties/literal_enum_property.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+__all__ = ["LiteralEnumProperty"]
+
+from typing import Any, ClassVar, List, Union, cast
+
+from attr import evolve
+from attrs import define
+
+from ... import Config, utils
+from ... import schema as oai
+from ...schema import DataType
+from ..errors import PropertyError
+from .none import NoneProperty
+from .protocol import PropertyProtocol, Value
+from .schemas import Class, Schemas
+from .union import UnionProperty
+
+ValueType = Union[str, int]
+
+
+@define
+class LiteralEnumProperty(PropertyProtocol):
+    """A property that should use a literal enum"""
+
+    name: str
+    required: bool
+    default: Value | None
+    python_name: utils.PythonIdentifier
+    description: str | None
+    example: str | None
+    values: set[ValueType]
+    class_info: Class
+    value_type: type[ValueType]
+
+    template: ClassVar[str] = "literal_enum_property.py.jinja"
+
+    _allowed_locations: ClassVar[set[oai.ParameterLocation]] = {
+        oai.ParameterLocation.QUERY,
+        oai.ParameterLocation.PATH,
+        oai.ParameterLocation.COOKIE,
+        oai.ParameterLocation.HEADER,
+    }
+
+    @classmethod
+    def build(  # noqa: PLR0911
+        cls,
+        *,
+        data: oai.Schema,
+        name: str,
+        required: bool,
+        schemas: Schemas,
+        parent_name: str,
+        config: Config,
+    ) -> tuple[LiteralEnumProperty | NoneProperty | UnionProperty | PropertyError, Schemas]:
+        """
+        Create a LiteralEnumProperty from schema data.
+
+        Args:
+            data: The OpenAPI Schema which defines this enum.
+            name: The name to use for variables which receive this Enum's value (e.g. model property name)
+            required: Whether or not this Property is required in the calling context
+            schemas: The Schemas which have been defined so far (used to prevent naming collisions)
+            parent_name: The context in which this LiteralEnumProperty is defined, used to create more specific class names.
+            config: The global config for this run of the generator
+
+        Returns:
+            A tuple containing either the created property or a PropertyError AND update schemas.
+        """
+
+        enum = data.enum or []  # The outer function checks for this, but mypy doesn't know that
+
+        # OpenAPI allows for null as an enum value, but it doesn't make sense with how enums are constructed in Python.
+        # So instead, if null is a possible value, make the property nullable.
+        # Mypy is not smart enough to know that the type is right though
+        unchecked_value_list = [value for value in enum if value is not None]  # type: ignore
+
+        # It's legal to have an enum that only contains null as a value, we don't bother constructing an enum for that
+        if len(unchecked_value_list) == 0:
+            return (
+                NoneProperty.build(
+                    name=name,
+                    required=required,
+                    default="None",
+                    python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+                    description=None,
+                    example=None,
+                ),
+                schemas,
+            )
+
+        value_types = {type(value) for value in unchecked_value_list}
+        if len(value_types) > 1:
+            return PropertyError(
+                header="Enum values must all be the same type", detail=f"Got {value_types}", data=data
+            ), schemas
+        value_type = next(iter(value_types))
+        if value_type not in (str, int):
+            return PropertyError(header=f"Unsupported enum type {value_type}", data=data), schemas
+        value_list = cast(
+            Union[List[int], List[str]], unchecked_value_list
+        )  # We checked this with all the value_types stuff
+
+        if len(value_list) < len(enum):  # Only one of the values was None, that becomes a union
+            data.oneOf = [
+                oai.Schema(type=DataType.NULL),
+                data.model_copy(update={"enum": value_list, "default": data.default}),
+            ]
+            data.enum = None
+            return UnionProperty.build(
+                data=data,
+                name=name,
+                required=required,
+                schemas=schemas,
+                parent_name=parent_name,
+                config=config,
+            )
+
+        class_name = data.title or name
+        if parent_name:
+            class_name = f"{utils.pascal_case(parent_name)}{utils.pascal_case(class_name)}"
+        class_info = Class.from_string(string=class_name, config=config)
+        values: set[str | int] = set(value_list)
+
+        if class_info.name in schemas.classes_by_name:
+            existing = schemas.classes_by_name[class_info.name]
+            if not isinstance(existing, LiteralEnumProperty) or values != existing.values:
+                return (
+                    PropertyError(
+                        detail=f"Found conflicting enums named {class_info.name} with incompatible values.", data=data
+                    ),
+                    schemas,
+                )
+
+        prop = LiteralEnumProperty(
+            name=name,
+            required=required,
+            class_info=class_info,
+            values=values,
+            value_type=value_type,
+            default=None,
+            python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+            description=data.description,
+            example=data.example,
+        )
+        checked_default = prop.convert_value(data.default)
+        if isinstance(checked_default, PropertyError):
+            checked_default.data = data
+            return checked_default, schemas
+        prop = evolve(prop, default=checked_default)
+
+        schemas = evolve(schemas, classes_by_name={**schemas.classes_by_name, class_info.name: prop})
+        return prop, schemas
+
+    def convert_value(self, value: Any) -> Value | PropertyError | None:
+        if value is None or isinstance(value, Value):
+            return value
+        if isinstance(value, self.value_type):
+            if value in self.values:
+                return Value(python_code=repr(value), raw_value=value)
+            else:
+                return PropertyError(detail=f"Value {value} is not valid for enum {self.name}")
+        return PropertyError(detail=f"Cannot convert {value} to enum {self.name} of type {self.value_type}")
+
+    def get_base_type_string(self, *, quoted: bool = False) -> str:
+        return self.class_info.name
+
+    def get_base_json_type_string(self, *, quoted: bool = False) -> str:
+        return self.value_type.__name__
+
+    def get_instance_type_string(self) -> str:
+        return self.value_type.__name__
+
+    def get_imports(self, *, prefix: str) -> set[str]:
+        """
+        Get a set of import strings that should be included when this property is used somewhere
+
+        Args:
+            prefix: A prefix to put before any relative (local) module names. This should be the number of . to get
+            back to the root of the generated client.
+        """
+        imports = super().get_imports(prefix=prefix)
+        imports.add("from typing import cast")
+        imports.add(f"from {prefix}models.{self.class_info.module_name} import {self.class_info.name}")
+        imports.add(
+            f"from {prefix}models.{self.class_info.module_name} import check_{self.get_class_name_snake_case()}"
+        )
+        return imports
+
+    def get_class_name_snake_case(self) -> str:
+        return utils.snake_case(self.class_info.name)

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/merge_properties.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from openapi_python_client.parser.properties.date import DateProperty
 from openapi_python_client.parser.properties.datetime import DateTimeProperty
 from openapi_python_client.parser.properties.file import FileProperty
+from openapi_python_client.parser.properties.literal_enum_property import LiteralEnumProperty
 
 __all__ = ["merge_properties"]
 
@@ -53,6 +54,9 @@ def merge_properties(prop1: Property, prop2: Property) -> Property | PropertyErr
     if isinstance(prop1, EnumProperty) or isinstance(prop2, EnumProperty):
         return _merge_with_enum(prop1, prop2)
 
+    if isinstance(prop1, LiteralEnumProperty) or isinstance(prop2, LiteralEnumProperty):
+        return _merge_with_literal_enum(prop1, prop2)
+
     if (merged := _merge_same_type(prop1, prop2)) is not None:
         return merged
 
@@ -136,6 +140,32 @@ def _merge_with_enum(prop1: PropertyProtocol, prop2: PropertyProtocol) -> EnumPr
     )
 
 
+def _merge_with_literal_enum(prop1: PropertyProtocol, prop2: PropertyProtocol) -> LiteralEnumProperty | PropertyError:
+    if isinstance(prop1, LiteralEnumProperty) and isinstance(prop2, LiteralEnumProperty):
+        # We want the narrowest validation rules that fit both, so use whichever values list is a
+        # subset of the other.
+        if prop1.values <= prop2.values:
+            values = prop1.values
+            class_info = prop1.class_info
+        elif prop2.values <= prop1.values:
+            values = prop2.values
+            class_info = prop2.class_info
+        else:
+            return PropertyError(detail="can't redefine a literal enum property with incompatible lists of values")
+        return _merge_common_attributes(evolve(prop1, values=values, class_info=class_info), prop2)
+
+    # If enum values were specified for just one of the properties, use those.
+    enum_prop = prop1 if isinstance(prop1, LiteralEnumProperty) else cast(LiteralEnumProperty, prop2)
+    non_enum_prop = prop2 if isinstance(prop1, LiteralEnumProperty) else prop1
+    if (isinstance(non_enum_prop, IntProperty) and enum_prop.value_type is int) or (
+        isinstance(non_enum_prop, StringProperty) and enum_prop.value_type is str
+    ):
+        return _merge_common_attributes(enum_prop, prop1, prop2)
+    return PropertyError(
+        detail=f"can't combine literal enum of type {enum_prop.value_type} with {non_enum_prop.get_type_string(no_optional=True)}"
+    )
+
+
 def _merge_common_attributes(base: PropertyT, *extend_with: PropertyProtocol) -> PropertyT | PropertyError:
     """Create a new instance based on base, overriding basic attributes with values from extend_with, in order.
 

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/property.py

@@ -14,10 +14,12 @@ from .file import FileProperty
 from .float import FloatProperty
 from .int import IntProperty
 from .list_property import ListProperty
+from .literal_enum_property import LiteralEnumProperty
 from .model_property import ModelProperty
 from .none import NoneProperty
 from .string import StringProperty
 from .union import UnionProperty
+from .uuid import UuidProperty
 
 Property: TypeAlias = Union[
     AnyProperty,
@@ -26,6 +28,7 @@ Property: TypeAlias = Union[
     DateProperty,
     DateTimeProperty,
     EnumProperty,
+    LiteralEnumProperty,
     FileProperty,
     FloatProperty,
     IntProperty,
@@ -34,4 +37,5 @@ Property: TypeAlias = Union[
     NoneProperty,
     StringProperty,
     UnionProperty,
+    UuidProperty,
 ]

openapi_python_client-0.21.6/openapi_python_client/parser/properties/uuid.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar
+from uuid import UUID
+
+from attr import define
+
+from ... import schema as oai
+from ...utils import PythonIdentifier
+from ..errors import PropertyError
+from .protocol import PropertyProtocol, Value
+
+
+@define
+class UuidProperty(PropertyProtocol):
+    """A property of type uuid.UUID"""
+
+    name: str
+    required: bool
+    default: Value | None
+    python_name: PythonIdentifier
+    description: str | None
+    example: str | None
+
+    _type_string: ClassVar[str] = "UUID"
+    _json_type_string: ClassVar[str] = "str"
+    _allowed_locations: ClassVar[set[oai.ParameterLocation]] = {
+        oai.ParameterLocation.QUERY,
+        oai.ParameterLocation.PATH,
+        oai.ParameterLocation.COOKIE,
+        oai.ParameterLocation.HEADER,
+    }
+    template: ClassVar[str] = "uuid_property.py.jinja"
+
+    @classmethod
+    def build(
+        cls,
+        name: str,
+        required: bool,
+        default: Any,
+        python_name: PythonIdentifier,
+        description: str | None,
+        example: str | None,
+    ) -> UuidProperty | PropertyError:
+        checked_default = cls.convert_value(default)
+        if isinstance(checked_default, PropertyError):
+            return checked_default
+
+        return cls(
+            name=name,
+            required=required,
+            default=checked_default,
+            python_name=python_name,
+            description=description,
+            example=example,
+        )
+
+    @classmethod
+    def convert_value(cls, value: Any) -> Value | None | PropertyError:
+        if value is None or isinstance(value, Value):
+            return value
+        if isinstance(value, str):
+            try:
+                UUID(value)
+            except ValueError:
+                return PropertyError(f"Invalid UUID value: {value}")
+            return Value(python_code=f"UUID('{value}')", raw_value=value)
+        return PropertyError(f"Invalid UUID value: {value}")
+
+    def get_imports(self, *, prefix: str) -> set[str]:
+        """
+        Get a set of import strings that should be included when this property is used somewhere
+
+        Args:
+            prefix: A prefix to put before any relative (local) module names. This should be the number of . to get
+            back to the root of the generated client.
+        """
+        imports = super().get_imports(prefix=prefix)
+        imports.update({"from uuid import UUID"})
+        return imports

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/schema/openapi_schema_pydantic/schema.py

@@ -43,6 +43,7 @@ class Schema(BaseModel):
     anyOf: List[Union[Reference, "Schema"]] = Field(default_factory=list)
     schema_not: Optional[Union[Reference, "Schema"]] = Field(default=None, alias="not")
     items: Optional[Union[Reference, "Schema"]] = None
+    prefixItems: Optional[List[Union[Reference, "Schema"]]] = Field(default_factory=list)
     properties: Optional[Dict[str, Union[Reference, "Schema"]]] = None
     additionalProperties: Optional[Union[bool, Reference, "Schema"]] = None
     description: Optional[str] = None

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/templates/client.py.jinja

@@ -74,7 +74,7 @@ class Client:
 {% endmacro %}{{ builders("Client") }}
 {% macro httpx_stuff(name, custom_constructor=None) %}
     def set_httpx_client(self, client: httpx.Client) -> "{{ name }}":
-        """Manually the underlying httpx.Client
+        """Manually set the underlying httpx.Client
 
         **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
         """

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/templates/endpoint_module.py.jinja

@@ -7,7 +7,7 @@ from ...client import AuthenticatedClient, Client
 from ...types import Response, UNSET
 from ... import errors
 
-{% for relative in endpoint.relative_imports %}
+{% for relative in endpoint.relative_imports | sort %}
 {{ relative }}
 {% endfor %}
 
@@ -70,7 +70,7 @@ def _get_kwargs(
 
 def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[{{ return_string }}]:
     {% for response in endpoint.responses %}
-    if response.status_code == HTTPStatus.{{ response.status_code.name }}:
+    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) }}

openapi_python_client-0.21.6/openapi_python_client/templates/literal_enum.py.jinja

@@ -0,0 +1,10 @@
+from typing import Literal, Set, cast
+
+{{ enum.class_info.name }} = Literal{{ "%r" | format(enum.values|list|sort) }}
+
+{{ enum.get_class_name_snake_case() | upper }}_VALUES: Set[{{ enum.class_info.name }}] = { {% for v in enum.values|list|sort %}{{"%r"|format(v)}}, {% endfor %} }
+
+def check_{{ enum.get_class_name_snake_case() }}(value: {{ enum.get_instance_type_string() }}) -> {{ enum.class_info.name}}:
+    if value in {{ enum.get_class_name_snake_case() | upper }}_VALUES:
+        return cast({{enum.class_info.name}}, value)
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {{"{"}}{{ enum.get_class_name_snake_case() | upper }}_VALUES!r}")

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/openapi_python_client/templates/model.py.jinja

@@ -13,7 +13,7 @@ import json
 
 from ..types import UNSET, Unset
 
-{% for relative in model.relative_imports %}
+{% for relative in model.relative_imports | sort %}
 {{ relative }}
 {% endfor %}
 

openapi_python_client-0.21.6/openapi_python_client/templates/property_templates/literal_enum_property.py.jinja

@@ -0,0 +1,38 @@
+{% macro construct_function(property, source) %}
+check_{{ property.get_class_name_snake_case() }}({{ source }})
+{% endmacro %}
+
+{% from "property_templates/property_macros.py.jinja" import construct_template %}
+
+{% macro construct(property, source) %}
+{{ construct_template(construct_function, property, source) }}
+{% endmacro %}
+
+{% macro check_type_for_construct(property, source) %}isinstance({{ source }}, {{ property.get_instance_type_string() }}){% endmacro %}
+
+{% macro transform(property, source, destination, declare_type=True, multipart=False) %}
+{% set type_string = property.get_type_string(json=True) %}
+{% if property.required %}
+{{ destination }}{% if declare_type %}: {{ type_string }}{% endif %} = {{ source }}
+{%- else %}
+{{ destination }}{% if declare_type %}: {{ type_string }}{% endif %} = UNSET
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = {{ source }}
+{% endif %}
+{% endmacro %}
+
+{% macro transform_multipart(property, source, destination) %}
+{% set transformed = "(None, str(" + source + ").encode(), \"text/plain\")" %}
+{% set type_string = "Union[Unset, Tuple[None, bytes, str]]" %}
+{% if property.required %}
+{{ destination }} = {{ transformed }}
+{%- else %}
+{{ destination }}: {{ type_string }} = UNSET
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = {{ transformed }}
+{% endif %}
+{% endmacro %}
+
+{% macro transform_header(source) %}
+str({{ source }})
+{% endmacro %}

openapi_python_client-0.21.6/openapi_python_client/templates/property_templates/uuid_property.py.jinja

@@ -0,0 +1,38 @@
+{% macro construct_function(property, source) %}
+UUID({{ source }})
+{% endmacro %}
+
+{% from "property_templates/property_macros.py.jinja" import construct_template %}
+
+{% macro construct(property, source) %}
+{{ construct_template(construct_function, property, source) }}
+{% endmacro %}
+
+{% macro check_type_for_construct(property, source) %}isinstance({{ source }}, str){% endmacro %}
+
+{% macro transform(property, source, destination, declare_type=True) %}
+{% set transformed = "str(" + source + ")" %}
+{% if property.required %}
+{{ destination }} = {{ transformed }}
+{%- else %}
+{% if declare_type %}
+{% set type_annotation = property.get_type_string(json=True) %}
+{{ destination }}: {{ type_annotation }} = UNSET
+{% else %}
+{{ destination }} = UNSET
+{% endif %}
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = {{ transformed }}
+{%- endif %}
+{% endmacro %}
+
+{% macro transform_multipart(property, source, destination) %}
+{% if property.required %}
+{{ destination }} = str({{ source }})
+{%- else %}
+{% set type_annotation = property.get_type_string(json=True) | replace("str", "bytes") %}
+{{ destination }}: {{ type_annotation }} = UNSET
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = str({{ source }})
+{%- endif %}
+{% endmacro %}

{openapi_python_client-0.21.5 → openapi_python_client-0.21.6}/pyproject.toml

@@ -14,11 +14,11 @@ dependencies = [
     "python-dateutil>=2.8.1,<3.0.0",
     "httpx>=0.20.0,<0.28.0",
     "ruamel.yaml>=0.18.6,<0.19.0",
-    "ruff>=0.2,<0.7",
+    "ruff>=0.2,<0.8",
     "typing-extensions>=4.8.0,<5.0.0",
 ]
 name = "openapi-python-client"
-version = "0.21.5"
+version = "0.21.6"
 description = "Generate modern Python clients from OpenAPI"
 keywords = [
     "OpenAPI",
@@ -35,6 +35,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Software Development :: Code Generators",
     "Typing :: Typed",
 ]
@@ -59,7 +60,7 @@ exclude = [
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B", "PL", "RUF"]
-ignore = ["E501", "PLR0913"]
+ignore = ["E501", "PLR0913", "PLR2004"]
 
 [tool.ruff.lint.per-file-ignores]
 "openapi_python_client/cli.py" = ["B008"]
@@ -114,7 +115,7 @@ mypy = "mypy openapi_python_client"
 check = { composite = ["lint", "format", "mypy", "test"] }
 regen = {composite = ["regen_e2e", "regen_integration"]}
 e2e = "pytest openapi_python_client end_to_end_tests/test_end_to_end.py"
-re = {composite = ["regen_e2e", "e2e"]}
+re = {composite = ["regen_e2e", "e2e --snapshot-update"]}
 regen_e2e = "python -m end_to_end_tests.regen_golden_record"
 
 [tool.pdm.scripts.test]