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

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/.gitignore

@@ -24,6 +24,9 @@ dmypy.json
 # JetBrains
 .idea/
 
+# Visual Studio Code
+.vscode/
+
 test-reports/
 
 /coverage.xml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openapi-python-client
-Version: 0.21.3
+Version: 0.21.5
 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>

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/bodies.py

@@ -117,6 +117,7 @@ def body_from_data(
                     **schemas.classes_by_name,
                     prop.class_info.name: prop,
                 },
+                models_to_process=[*schemas.models_to_process, prop],
             )
         bodies.append(
             Body(

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

@@ -155,7 +155,7 @@ class Endpoint:
                     ParseError(
                         detail=(
                             f"Invalid response status code {code} (not a valid HTTP "
-                            f"status code), response will be ommitted from generated "
+                            f"status code), response will be omitted from generated "
                             f"client"
                         )
                     )
@@ -175,7 +175,7 @@ class Endpoint:
                     ParseError(
                         detail=(
                             f"Cannot parse response for status code {status_code}{detail_suffix}, "
-                            f"response will be ommitted from generated client"
+                            f"response will be omitted from generated client"
                         ),
                         data=response.data,
                     )

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

@@ -83,7 +83,6 @@ def _string_based_property(
         name=name,
         default=data.default,
         required=required,
-        pattern=data.pattern,
         python_name=python_name,
         description=data.description,
         example=data.example,
@@ -126,7 +125,7 @@ def _property_from_ref(
     return prop, schemas
 
 
-def property_from_data(  # noqa: PLR0911
+def property_from_data(  # noqa: PLR0911, PLR0912
     name: str,
     required: bool,
     data: oai.Reference | oai.Schema,
@@ -153,7 +152,7 @@ def property_from_data(  # noqa: PLR0911
     sub_data: list[oai.Schema | oai.Reference] = data.allOf + data.anyOf + data.oneOf
     # A union of a single reference should just be passed through to that reference (don't create copy class)
     if len(sub_data) == 1 and isinstance(sub_data[0], oai.Reference):
-        return _property_from_ref(
+        prop, schemas = _property_from_ref(
             name=name,
             required=required,
             parent=data,
@@ -162,6 +161,16 @@ def property_from_data(  # noqa: PLR0911
             config=config,
             roots=roots,
         )
+        # We won't be generating a separate Python class for this schema - references to it will just use
+        # the class for the schema it's referencing - so we don't add it to classes_by_name; but we do
+        # add it to models_to_process, if it's a model, because its properties still need to be resolved.
+        if isinstance(prop, ModelProperty):
+            schemas = evolve(
+                schemas,
+                models_to_process=[*schemas.models_to_process, prop],
+            )
+        return prop, schemas
+
     if data.type == oai.DataType.BOOLEAN:
         return (
             BooleanProperty.build(
@@ -271,7 +280,7 @@ def property_from_data(  # noqa: PLR0911
         AnyProperty.build(
             name=name,
             required=required,
-            default=None,
+            default=data.default,
             python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
             description=data.description,
             example=data.example,
@@ -341,7 +350,7 @@ def _process_model_errors(
 
 
 def _process_models(*, schemas: Schemas, config: Config) -> Schemas:
-    to_process = (prop for prop in schemas.classes_by_name.values() if isinstance(prop, ModelProperty))
+    to_process = schemas.models_to_process
     still_making_progress = True
     final_model_errors: list[tuple[ModelProperty, PropertyError]] = []
     latest_model_errors: list[tuple[ModelProperty, PropertyError]] = []
@@ -368,12 +377,11 @@ def _process_models(*, schemas: Schemas, config: Config) -> Schemas:
                 continue
             schemas = schemas_or_err
             still_making_progress = True
-        to_process = (prop for prop in next_round)
+        to_process = next_round
 
     final_model_errors.extend(latest_model_errors)
     errors = _process_model_errors(final_model_errors, schemas=schemas)
-    schemas.errors.extend(errors)
-    return schemas
+    return evolve(schemas, errors=[*schemas.errors, *errors], models_to_process=to_process)
 
 
 def build_schemas(

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/any.py

@@ -33,9 +33,13 @@ class AnyProperty(PropertyProtocol):
 
     @classmethod
     def convert_value(cls, value: Any) -> Value | None:
-        if value is None or isinstance(value, Value):
+        from .string import StringProperty
+
+        if value is None:
             return value
-        return Value(str(value))
+        if isinstance(value, str):
+            return StringProperty.convert_value(value)
+        return Value(python_code=str(value), raw_value=value)
 
     name: str
     required: bool

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/boolean.py

@@ -59,9 +59,9 @@ class BooleanProperty(PropertyProtocol):
             return value
         if isinstance(value, str):
             if value.lower() == "true":
-                return Value("True")
+                return Value(python_code="True", raw_value=value)
             elif value.lower() == "false":
-                return Value("False")
+                return Value(python_code="False", raw_value=value)
         if isinstance(value, bool):
-            return Value(str(value))
+            return Value(python_code=str(value), raw_value=value)
         return PropertyError(f"Invalid boolean value: {value}")

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/const.py

@@ -27,7 +27,7 @@ class ConstProperty(PropertyProtocol):
     def build(
         cls,
         *,
-        const: str | int,
+        const: str | int | float | bool,
         default: Any,
         name: str,
         python_name: PythonIdentifier,
@@ -63,13 +63,13 @@ class ConstProperty(PropertyProtocol):
         return prop
 
     def convert_value(self, value: Any) -> Value | None | PropertyError:
-        if isinstance(value, Value):
-            return value
         value = self._convert_value(value)
         if value is None:
             return value
         if value != self.value:
-            return PropertyError(detail=f"Invalid value for const {self.name}; {value} != {self.value}")
+            return PropertyError(
+                detail=f"Invalid value for const {self.name}; {value.raw_value} != {self.value.raw_value}"
+            )
         return value
 
     @staticmethod
@@ -85,11 +85,9 @@ class ConstProperty(PropertyProtocol):
     def _convert_value(value: Any) -> Value | None:
         if value is None or isinstance(value, Value):
             return value
-        if isinstance(value, Value):
-            return value  # pragma: no cover
         if isinstance(value, str):
             return StringProperty.convert_value(value)
-        return Value(str(value))
+        return Value(python_code=str(value), raw_value=value)
 
     def get_type_string(
         self,
@@ -99,7 +97,7 @@ class ConstProperty(PropertyProtocol):
         multipart: bool = False,
         quoted: bool = False,
     ) -> str:
-        lit = f"Literal[{self.value}]"
+        lit = f"Literal[{self.value.python_code}]"
         if not no_optional and not self.required:
             return f"Union[{lit}, Unset]"
         return lit
@@ -115,6 +113,6 @@ class ConstProperty(PropertyProtocol):
         if self.required:
             return {"from typing import Literal"}
         return {
-            "from typing import Literal, Union",
+            "from typing import Literal, Union, cast",
             f"from {prefix}types import UNSET, Unset",
         }

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/date.py

@@ -57,7 +57,7 @@ class DateProperty(PropertyProtocol):
                 isoparse(value).date()  # make sure it's a valid value
             except ValueError as e:
                 return PropertyError(f"Invalid date: {e}")
-            return Value(f"isoparse({value!r}).date()")
+            return Value(python_code=f"isoparse({value!r}).date()", raw_value=value)
         return PropertyError(f"Cannot convert {value} to a date")
 
     def get_imports(self, *, prefix: str) -> set[str]:

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/datetime.py

@@ -59,7 +59,7 @@ class DateTimeProperty(PropertyProtocol):
                 isoparse(value)  # make sure it's a valid value
             except ValueError as e:
                 return PropertyError(f"Invalid datetime: {e}")
-            return Value(f"isoparse({value!r})")
+            return Value(python_code=f"isoparse({value!r})", raw_value=value)
         return PropertyError(f"Cannot convert {value} to a datetime")
 
     def get_imports(self, *, prefix: str) -> set[str]:

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

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__all__ = ["EnumProperty"]
+__all__ = ["EnumProperty", "ValueType"]
 
 from typing import Any, ClassVar, List, Union, cast
 
@@ -159,7 +159,7 @@ class EnumProperty(PropertyProtocol):
         if isinstance(value, self.value_type):
             inverse_values = {v: k for k, v in self.values.items()}
             try:
-                return Value(f"{self.class_info.name}.{inverse_values[value]}")
+                return Value(python_code=f"{self.class_info.name}.{inverse_values[value]}", raw_value=value)
             except KeyError:
                 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}")

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/float.py

@@ -61,11 +61,11 @@ class FloatProperty(PropertyProtocol):
         if isinstance(value, str):
             try:
                 parsed = float(value)
-                return Value(str(parsed))
+                return Value(python_code=str(parsed), raw_value=value)
             except ValueError:
                 return PropertyError(f"Invalid float value: {value}")
         if isinstance(value, float):
-            return Value(str(value))
+            return Value(python_code=str(value), raw_value=value)
         if isinstance(value, int) and not isinstance(value, bool):
-            return Value(str(float(value)))
+            return Value(python_code=str(float(value)), raw_value=value)
         return PropertyError(f"Cannot convert {value} to a float")

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/int.py

@@ -58,12 +58,16 @@ class IntProperty(PropertyProtocol):
     def convert_value(cls, value: Any) -> Value | None | PropertyError:
         if value is None or isinstance(value, Value):
             return value
-        if isinstance(value, str):
+        converted = value
+        if isinstance(converted, str):
             try:
-                int(value)
+                converted = float(converted)
             except ValueError:
-                return PropertyError(f"Invalid int value: {value}")
-            return Value(value)
-        if isinstance(value, int) and not isinstance(value, bool):
-            return Value(str(value))
+                return PropertyError(f"Invalid int value: {converted}")
+        if isinstance(converted, float):
+            as_int = int(converted)
+            if converted == as_int:
+                converted = as_int
+        if isinstance(converted, int) and not isinstance(converted, bool):
+            return Value(python_code=str(converted), raw_value=value)
         return PropertyError(f"Invalid int value: {value}")

openapi_python_client-0.21.5/openapi_python_client/parser/properties/merge_properties.py

@@ -0,0 +1,168 @@
+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
+
+__all__ = ["merge_properties"]
+
+from typing import TypeVar, cast
+
+from attr import evolve
+
+from ..errors import PropertyError
+from . import FloatProperty
+from .any import AnyProperty
+from .enum_property import EnumProperty
+from .int import IntProperty
+from .list_property import ListProperty
+from .property import Property
+from .protocol import PropertyProtocol
+from .string import StringProperty
+
+PropertyT = TypeVar("PropertyT", bound=PropertyProtocol)
+
+
+STRING_WITH_FORMAT_TYPES = (DateProperty, DateTimeProperty, FileProperty)
+
+
+def merge_properties(prop1: Property, prop2: Property) -> Property | PropertyError:  # noqa: PLR0911
+    """Attempt to create a new property that incorporates the behavior of both.
+
+    This is used when merging schemas with allOf, when two schemas define a property with the same name.
+
+    OpenAPI defines allOf in terms of validation behavior: the input must pass the validation rules
+    defined in all the listed schemas. Our task here is slightly more difficult, since we must end
+    up with a single Property object that will be used to generate a single class property in the
+    generated code. Due to limitations of our internal model, this may not be possible for some
+    combinations of property attributes that OpenAPI supports (for instance, we have no way to represent
+    a string property that must match two different regexes).
+
+    Properties can also have attributes that do not represent validation rules, such as "description"
+    and "example". OpenAPI does not define any overriding/aggregation rules for these in allOf. The
+    implementation here is, assuming prop1 and prop2 are in the same order that the schemas were in the
+    allOf, any such attributes that prop2 specifies will override the ones from prop1.
+    """
+    if isinstance(prop2, AnyProperty):
+        return _merge_common_attributes(prop1, prop2)
+
+    if isinstance(prop1, AnyProperty):
+        # Use the base type of `prop2`, but keep the override order
+        return _merge_common_attributes(prop2, prop1, prop2)
+
+    if isinstance(prop1, EnumProperty) or isinstance(prop2, EnumProperty):
+        return _merge_with_enum(prop1, prop2)
+
+    if (merged := _merge_same_type(prop1, prop2)) is not None:
+        return merged
+
+    if (merged := _merge_numeric(prop1, prop2)) is not None:
+        return merged
+
+    if (merged := _merge_string_with_format(prop1, prop2)) is not None:
+        return merged
+
+    return PropertyError(
+        detail=f"{prop1.get_type_string(no_optional=True)} can't be merged with {prop2.get_type_string(no_optional=True)}"
+    )
+
+
+def _merge_same_type(prop1: Property, prop2: Property) -> Property | None | PropertyError:
+    if type(prop1) is not type(prop2):
+        return None
+
+    if prop1 == prop2:
+        # It's always OK to redefine a property with everything exactly the same
+        return prop1
+
+    if isinstance(prop1, ListProperty) and isinstance(prop2, ListProperty):
+        inner_property = merge_properties(prop1.inner_property, prop2.inner_property)  # type: ignore
+        if isinstance(inner_property, PropertyError):
+            return PropertyError(detail=f"can't merge list properties: {inner_property.detail}")
+        prop1.inner_property = inner_property
+
+    # For all other property types, there aren't any special attributes that affect validation, so just
+    # apply the rules for common attributes like "description".
+    return _merge_common_attributes(prop1, prop2)
+
+
+def _merge_string_with_format(prop1: Property, prop2: Property) -> Property | None | PropertyError:
+    """Merge a string that has no format with a string that has a format"""
+    # Here we need to use the DateProperty/DateTimeProperty/FileProperty as the base so that we preserve
+    # its class, but keep the correct override order for merging the attributes.
+    if isinstance(prop1, StringProperty) and isinstance(prop2, STRING_WITH_FORMAT_TYPES):
+        # Use the more specific class as a base, but keep the correct override order
+        return _merge_common_attributes(prop2, prop1, prop2)
+    elif isinstance(prop2, StringProperty) and isinstance(prop1, STRING_WITH_FORMAT_TYPES):
+        return _merge_common_attributes(prop1, prop2)
+    else:
+        return None
+
+
+def _merge_numeric(prop1: Property, prop2: Property) -> IntProperty | None | PropertyError:
+    """Merge IntProperty with FloatProperty"""
+    if isinstance(prop1, IntProperty) and isinstance(prop2, (IntProperty, FloatProperty)):
+        return _merge_common_attributes(prop1, prop2)
+    elif isinstance(prop2, IntProperty) and isinstance(prop1, (IntProperty, FloatProperty)):
+        # Use the IntProperty as a base since it's more restrictive, but keep the correct override order
+        return _merge_common_attributes(prop2, prop1, prop2)
+    else:
+        return None
+
+
+def _merge_with_enum(prop1: PropertyProtocol, prop2: PropertyProtocol) -> EnumProperty | PropertyError:
+    if isinstance(prop1, EnumProperty) and isinstance(prop2, EnumProperty):
+        # We want the narrowest validation rules that fit both, so use whichever values list is a
+        # subset of the other.
+        if _values_are_subset(prop1, prop2):
+            values = prop1.values
+            class_info = prop1.class_info
+        elif _values_are_subset(prop2, prop1):
+            values = prop2.values
+            class_info = prop2.class_info
+        else:
+            return PropertyError(detail="can't redefine an 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, EnumProperty) else cast(EnumProperty, prop2)
+    non_enum_prop = prop2 if isinstance(prop1, EnumProperty) 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 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.
+
+    For "default", "description", and "example", a non-None value overrides any value from a previously
+    specified property. The behavior is similar to using the spread operator with dictionaries, except
+    that None means "not specified".
+
+    For "required", any True value overrides all other values (a property that was previously required
+    cannot become optional).
+    """
+    current = base
+    for override in extend_with:
+        if override.default is not None:
+            override_default = current.convert_value(override.default.raw_value)
+        else:
+            override_default = None
+        if isinstance(override_default, PropertyError):
+            return override_default
+        current = evolve(
+            current,  # type: ignore # can't prove that every property type is an attrs class, but it is
+            required=current.required or override.required,
+            default=override_default or current.default,
+            description=override.description or current.description,
+            example=override.example or current.example,
+        )
+    return current
+
+
+def _values_are_subset(prop1: EnumProperty, prop2: EnumProperty) -> bool:
+    return set(prop1.values.items()) <= set(prop2.values.items())

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/model_property.py

@@ -10,7 +10,6 @@ from ... import schema as oai
 from ...utils import PythonIdentifier
 from ..errors import ParseError, PropertyError
 from .any import AnyProperty
-from .enum_property import EnumProperty
 from .protocol import PropertyProtocol, Value
 from .schemas import Class, ReferencePath, Schemas, parse_reference_path
 
@@ -119,7 +118,11 @@ class ModelProperty(PropertyProtocol):
             )
             return error, schemas
 
-        schemas = evolve(schemas, classes_by_name={**schemas.classes_by_name, class_info.name: prop})
+        schemas = evolve(
+            schemas,
+            classes_by_name={**schemas.classes_by_name, class_info.name: prop},
+            models_to_process=[*schemas.models_to_process, prop],
+        )
         return prop, schemas
 
     @classmethod
@@ -216,59 +219,6 @@ class ModelProperty(PropertyProtocol):
 from .property import Property  # noqa: E402
 
 
-def _values_are_subset(first: EnumProperty, second: EnumProperty) -> bool:
-    return set(first.values.items()) <= set(second.values.items())
-
-
-def _types_are_subset(first: EnumProperty, second: Property) -> bool:
-    from . import IntProperty, StringProperty
-
-    if first.value_type is int and isinstance(second, IntProperty):
-        return True
-    if first.value_type is str and isinstance(second, StringProperty):
-        return True
-    return False
-
-
-def _enum_subset(first: Property, second: Property) -> EnumProperty | None:
-    """Return the EnumProperty that is the subset of the other, if possible."""
-
-    if isinstance(first, EnumProperty):
-        if isinstance(second, EnumProperty):
-            if _values_are_subset(first, second):
-                return first
-            if _values_are_subset(second, first):
-                return second
-            return None
-        return first if _types_are_subset(first, second) else None
-
-    if isinstance(second, EnumProperty) and _types_are_subset(second, first):
-        return second
-    return None
-
-
-def _merge_properties(first: Property, second: Property) -> Property | PropertyError:
-    required = first.required or second.required
-
-    err = None
-
-    if first.__class__ == second.__class__:
-        first = evolve(first, required=required)
-        second = evolve(second, required=required)
-        if first == second:
-            return first
-        err = PropertyError(header="Cannot merge properties", detail="Properties has conflicting values")
-
-    enum_subset = _enum_subset(first, second)
-    if enum_subset is not None:
-        return evolve(enum_subset, required=required)
-
-    return err or PropertyError(
-        header="Cannot merge properties",
-        detail=f"{first.__class__}, {second.__class__}Properties have incompatible types",
-    )
-
-
 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)
@@ -297,6 +247,7 @@ def _process_properties(  # noqa: PLR0912, PLR0911
     roots: set[ReferencePath | utils.ClassName],
 ) -> _PropertyData | PropertyError:
     from . import property_from_data
+    from .merge_properties import merge_properties
 
     properties: dict[str, Property] = {}
     relative_imports: set[str] = set()
@@ -307,26 +258,26 @@ def _process_properties(  # noqa: PLR0912, PLR0911
         nonlocal properties
 
         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
+        merged_prop = merge_properties(name_conflict, new_prop) if name_conflict else new_prop
+        if isinstance(merged_prop, PropertyError):
+            merged_prop.header = f"Found conflicting properties named {new_prop.name} when creating {class_name}"
+            return merged_prop
 
         for other_prop in properties.values():
-            if other_prop.name == merged_prop_or_error.name:
+            if other_prop.name == merged_prop.name:
                 continue  # Same property, probably just got merged
-            if other_prop.python_name != merged_prop_or_error.python_name:
+            if other_prop.python_name != merged_prop.python_name:
                 continue
-            naming_error = _resolve_naming_conflict(merged_prop_or_error, other_prop, config)
+            naming_error = _resolve_naming_conflict(merged_prop, other_prop, config)
             if naming_error is not None:
                 return naming_error
 
-        properties[merged_prop_or_error.name] = merged_prop_or_error
+        properties[merged_prop.name] = merged_prop
         return None
 
-    unprocessed_props = data.properties or {}
+    unprocessed_props: list[tuple[str, oai.Reference | oai.Schema]] = (
+        list(data.properties.items()) if data.properties else []
+    )
     for sub_prop in data.allOf:
         if isinstance(sub_prop, oai.Reference):
             ref_path = parse_reference_path(sub_prop.ref)
@@ -348,10 +299,10 @@ def _process_properties(  # noqa: PLR0912, PLR0911
                     return err
             schemas.add_dependencies(ref_path=ref_path, roots=roots)
         else:
-            unprocessed_props.update(sub_prop.properties or {})
+            unprocessed_props.extend(sub_prop.properties.items() if sub_prop.properties else [])
             required_set.update(sub_prop.required or [])
 
-    for key, value in unprocessed_props.items():
+    for key, value in unprocessed_props:
         prop_required = key in required_set
         prop_or_error: Property | (PropertyError | None)
         prop_or_error, schemas = property_from_data(

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/none.py

@@ -57,5 +57,5 @@ class NoneProperty(PropertyProtocol):
             return value
         if isinstance(value, str):
             if value == "None":
-                return Value(value)
+                return Value(python_code=value, raw_value=value)
         return PropertyError(f"Value {value} is not valid, only None is allowed")

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/protocol.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 __all__ = ["PropertyProtocol", "Value"]
 
 from abc import abstractmethod
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TypeVar
 
 from ... import Config
@@ -16,8 +17,15 @@ else:
     ModelProperty = "ModelProperty"
 
 
-class Value(str):
-    """Represents a valid (converted) value for a property"""
+@dataclass
+class Value:
+    """
+    Some literal values in OpenAPI documents (like defaults) have to be converted into Python code safely
+    (with string escaping, for example). We still keep the `raw_value` around for merging `allOf`.
+    """
+
+    python_code: str
+    raw_value: Any
 
 
 PropertyType = TypeVar("PropertyType", bound="PropertyProtocol")
@@ -148,7 +156,7 @@ class PropertyProtocol(Protocol):
         """How this should be declared in a dataclass"""
         default: str | None
         if self.default is not None:
-            default = self.default
+            default = self.default.python_code
         elif not self.required:
             default = "UNSET"
         else:
@@ -162,7 +170,7 @@ class PropertyProtocol(Protocol):
         """Returns property docstring"""
         doc = f"{self.python_name} ({self.get_type_string()}): {self.description or ''}"
         if self.default:
-            doc += f" Default: {self.default}."
+            doc += f" Default: {self.default.python_code}."
         if self.example:
             doc += f" Example: {self.example}."
         return doc

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/schemas.py

@@ -22,8 +22,10 @@ from ...utils import ClassName, PythonIdentifier
 from ..errors import ParameterError, ParseError, PropertyError
 
 if TYPE_CHECKING:  # pragma: no cover
+    from .model_property import ModelProperty
     from .property import Property
 else:
+    ModelProperty = "ModelProperty"
     Property = "Property"
 
 
@@ -77,6 +79,7 @@ class Schemas:
     classes_by_reference: Dict[ReferencePath, Property] = field(factory=dict)
     dependencies: Dict[ReferencePath, Set[Union[ReferencePath, ClassName]]] = field(factory=dict)
     classes_by_name: Dict[ClassName, Property] = field(factory=dict)
+    models_to_process: List[ModelProperty] = field(factory=list)
     errors: List[ParseError] = field(factory=list)
 
     def add_dependencies(self, ref_path: ReferencePath, roots: Set[Union[ReferencePath, ClassName]]) -> None:

{openapi_python_client-0.21.3 → openapi_python_client-0.21.5}/openapi_python_client/parser/properties/string.py

@@ -21,8 +21,6 @@ class StringProperty(PropertyProtocol):
     python_name: PythonIdentifier
     description: str | None
     example: str | None
-    max_length: int | None = None
-    pattern: str | None = None
     _type_string: ClassVar[str] = "str"
     _json_type_string: ClassVar[str] = "str"
     _allowed_locations: ClassVar[set[oai.ParameterLocation]] = {
@@ -41,7 +39,6 @@ class StringProperty(PropertyProtocol):
         python_name: PythonIdentifier,
         description: str | None,
         example: str | None,
-        pattern: str | None = None,
     ) -> StringProperty | PropertyError:
         checked_default = cls.convert_value(default)
         return cls(
@@ -51,7 +48,6 @@ class StringProperty(PropertyProtocol):
             python_name=python_name,
             description=description,
             example=example,
-            pattern=pattern,
         )
 
     @classmethod
@@ -69,4 +65,4 @@ class StringProperty(PropertyProtocol):
             return value
         if not isinstance(value, str):
             value = str(value)
-        return Value(repr(utils.remove_string_escapes(value)))
+        return Value(python_code=repr(utils.remove_string_escapes(value)), raw_value=value)

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

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, model_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, model_validator
 
 from ..data_type import DataType
 from .discriminator import Discriminator
@@ -23,9 +23,9 @@ class Schema(BaseModel):
     title: Optional[str] = None
     multipleOf: Optional[float] = Field(default=None, gt=0.0)
     maximum: Optional[float] = None
-    exclusiveMaximum: Optional[bool] = None
+    exclusiveMaximum: Optional[Union[bool, float]] = None
     minimum: Optional[float] = None
-    exclusiveMinimum: Optional[bool] = None
+    exclusiveMinimum: Optional[Union[bool, float]] = None
     maxLength: Optional[int] = Field(default=None, ge=0)
     minLength: Optional[int] = Field(default=None, ge=0)
     pattern: Optional[str] = None
@@ -36,7 +36,7 @@ class Schema(BaseModel):
     minProperties: Optional[int] = Field(default=None, ge=0)
     required: Optional[List[str]] = Field(default=None, min_length=1)
     enum: Union[None, List[Any]] = Field(default=None, min_length=1)
-    const: Union[None, StrictStr, StrictInt] = None
+    const: Union[None, StrictStr, StrictInt, StrictFloat, StrictBool] = None
     type: Union[DataType, List[DataType], None] = Field(default=None)
     allOf: List[Union[Reference, "Schema"]] = Field(default_factory=list)
     oneOf: List[Union[Reference, "Schema"]] = Field(default_factory=list)
@@ -160,6 +160,33 @@ class Schema(BaseModel):
         },
     )
 
+    @model_validator(mode="after")
+    def handle_exclusive_min_max(self) -> "Schema":
+        """
+        Convert exclusiveMinimum/exclusiveMaximum between OpenAPI v3.0 (bool) and v3.1 (numeric).
+        """
+        # Handle exclusiveMinimum
+        if isinstance(self.exclusiveMinimum, bool) and self.minimum is not None:
+            if self.exclusiveMinimum:
+                self.exclusiveMinimum = self.minimum
+                self.minimum = None
+            else:
+                self.exclusiveMinimum = None
+        elif isinstance(self.exclusiveMinimum, float):
+            self.minimum = None
+
+        # Handle exclusiveMaximum
+        if isinstance(self.exclusiveMaximum, bool) and self.maximum is not None:
+            if self.exclusiveMaximum:
+                self.exclusiveMaximum = self.maximum
+                self.maximum = None
+            else:
+                self.exclusiveMaximum = None
+        elif isinstance(self.exclusiveMaximum, float):
+            self.maximum = None
+
+        return self
+
     @model_validator(mode="after")
     def handle_nullable(self) -> "Schema":
         """Convert the old 3.0 `nullable` property into the new 3.1 style"""

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

@@ -138,6 +138,7 @@ return field_dict
     {% for lazy_import in model.lazy_imports %}
         {{ lazy_import }}
     {% endfor %}
+{% if (model.required_properties or model.optional_properties or model.additional_properties) %}
         d = src_dict.copy()
 {% for property in model.required_properties + model.optional_properties %}
     {% if property.required %}
@@ -153,6 +154,7 @@ return field_dict
     {% endif %}
 
 {% endfor %}
+{% endif %}
         {{ module_name }} = cls(
 {% for property in model.required_properties + model.optional_properties %}
             {{ property.python_name }}={{ property.python_name }},

openapi_python_client-0.21.5/openapi_python_client/templates/property_templates/const_property.py.jinja

@@ -0,0 +1,5 @@
+{% macro construct(property, source) %}
+{{ property.python_name }} = cast({{ property.get_type_string() }} , {{ source }})
+if {{ property.python_name }} != {{ property.value.python_code }}{% if not property.required %}and not isinstance({{ property.python_name }}, Unset){% endif %}:
+    raise ValueError(f"{{ property.name }} must match const {{ property.value.python_code }}, got '{{'{' + property.python_name + '}' }}'")
+{%- endmacro %}

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

@@ -18,7 +18,7 @@ dependencies = [
     "typing-extensions>=4.8.0,<5.0.0",
 ]
 name = "openapi-python-client"
-version = "0.21.3"
+version = "0.21.5"
 description = "Generate modern Python clients from OpenAPI"
 keywords = [
     "OpenAPI",
@@ -63,9 +63,10 @@ ignore = ["E501", "PLR0913"]
 
 [tool.ruff.lint.per-file-ignores]
 "openapi_python_client/cli.py" = ["B008"]
+"tests/*" = ["PLR2004"]
 
 [tool.coverage.run]
-omit = ["openapi_python_client/templates/*"]
+omit = ["openapi_python_client/__main__.py", "openapi_python_client/templates/*"]
 
 [tool.mypy]
 plugins = ["pydantic.mypy"]
@@ -129,7 +130,7 @@ composite = ["test --cov openapi_python_client tests --cov-report=term-missing"]
 
 [tool.pdm.scripts.regen_integration]
 shell = """
-openapi-python-client update --url https://raw.githubusercontent.com/openapi-generators/openapi-test-server/main/openapi.json --config integration-tests/config.yaml --meta pdm \
+openapi-python-client generate --overwrite --url https://raw.githubusercontent.com/openapi-generators/openapi-test-server/main/openapi.json --config integration-tests/config.yaml --meta none --output-path integration-tests/integration_tests \
 """
 
 [build-system]

openapi_python_client-0.21.3/openapi_python_client/templates/property_templates/const_property.py.jinja

@@ -1,5 +0,0 @@
-{% macro construct(property, source) %}
-{{ property.python_name }} = cast({{ property.get_type_string() }} , {{ source }})
-if {{ property.python_name }} != {{ property.value }}{% if not property.required %}and not isinstance({{ property.python_name }}, Unset){% endif %}:
-    raise ValueError(f"{{ property.name }} must match const {{ property.value }}, got '{{'{' + property.python_name + '}' }}'")
-{%- endmacro %}