openapi-python-client 0.28.4__py3-none-any.whl → 0.29.1__py3-none-any.whl

openapi_python_client/parser/properties/enum_property.py

@@ -5,14 +5,14 @@ __all__ = ["EnumProperty", "ValueType"]
 from typing import Any, ClassVar, cast
 
 from attr import evolve
-from attrs import define
+from attrs import define, field
 
-from ... import Config, utils
+from ... import Config, strings
 from ... import schema as oai
 from ...schema import DataType
 from ..errors import PropertyError
 from .none import NoneProperty
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 from .schemas import Class, Schemas
 from .union import UnionProperty
 
@@ -23,12 +23,12 @@ ValueType = str | int
 class EnumProperty(PropertyProtocol):
     """A property that should use an enum"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
-    python_name: utils.PythonIdentifier
-    description: str | None
-    example: str | None
+    python_name: strings.PythonIdentifier
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
     values: dict[str, ValueType]
     class_info: Class
     value_type: type[ValueType]
@@ -47,7 +47,7 @@ class EnumProperty(PropertyProtocol):
         cls,
         *,
         data: oai.Schema,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         schemas: Schemas,
         parent_name: str,
@@ -83,7 +83,7 @@ class EnumProperty(PropertyProtocol):
                     name=name,
                     required=required,
                     default="None",
-                    python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+                    python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
                     description=None,
                     example=None,
                 ),
@@ -115,9 +115,9 @@ class EnumProperty(PropertyProtocol):
                 config=config,
             )
 
-        class_name = data.title or name
+        class_name: str | oai.UntrustedString = data.title or name
         if parent_name:
-            class_name = f"{utils.pascal_case(parent_name)}{utils.pascal_case(class_name)}"
+            class_name = f"{strings.pascal_case(parent_name)}{strings.pascal_case(class_name)}"
         class_info = Class.from_string(string=class_name, config=config)
         var_names = data.model_extra.get("x-enum-varnames", []) if data.model_extra else []
         values = EnumProperty.values_from_list(value_list, class_info, var_names)
@@ -139,7 +139,7 @@ class EnumProperty(PropertyProtocol):
             values=values,
             value_type=value_type,
             default=None,
-            python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+            python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
             description=data.description,
             example=data.example,
         )
@@ -158,16 +158,19 @@ class EnumProperty(PropertyProtocol):
         if isinstance(value, self.value_type):
             inverse_values = {v: k for k, v in self.values.items()}
             try:
-                return Value(python_code=f"{self.class_info.name}.{inverse_values[value]}", raw_value=value)
+                return Value(
+                    python_code=strings.PythonCode(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}")
 
-    def get_base_type_string(self) -> str:
-        return self.class_info.name
+    def get_base_type_string(self) -> strings.PythonCode:
+        return strings.PythonCode(self.class_info.name)
 
-    def get_base_json_type_string(self) -> str:
-        return self.value_type.__name__
+    def get_base_json_type_string(self) -> strings.PythonCode:
+        return strings.PythonCode(self.value_type.__name__)
 
     def get_imports(self, *, prefix: str) -> set[str]:
         """
@@ -194,7 +197,7 @@ class EnumProperty(PropertyProtocol):
             if isinstance(value, int):
                 if use_var_names:
                     key = var_names[i]
-                    sanitized_key = utils.snake_case(key).upper()
+                    sanitized_key = strings.snake_case(key).upper()
                     output[sanitized_key] = value
                 elif value < 0:
                     output[f"VALUE_NEGATIVE_{-value}"] = value
@@ -212,6 +215,6 @@ class EnumProperty(PropertyProtocol):
                     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)
+            sanitized_key = strings.snake_case(key).upper()
+            output[sanitized_key] = strings.in_double_quote_literal(value)
         return output

openapi_python_client/parser/properties/file.py

@@ -2,23 +2,24 @@ from __future__ import annotations
 
 from typing import Any, ClassVar
 
-from attr import define
+from attr import define, field
 
-from ...utils import PythonIdentifier
+from ... import schema as oai
+from ...strings import PythonIdentifier
 from ..errors import PropertyError
-from .protocol import PropertyProtocol
+from .protocol import PropertyProtocol, convert_example
 
 
 @define
 class FileProperty(PropertyProtocol):
     """A property used for uploading files"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: None
     python_name: PythonIdentifier
-    description: str | None
-    example: str | None
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
 
     _type_string: ClassVar[str] = "File"
     # Return type of File.to_tuple()
@@ -28,12 +29,12 @@ class FileProperty(PropertyProtocol):
     @classmethod
     def build(
         cls,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         default: Any,
         python_name: PythonIdentifier,
-        description: str | None,
-        example: str | None,
+        description: oai.UntrustedString | None,
+        example: Any,
     ) -> FileProperty | PropertyError:
         default_or_err = cls.convert_value(default)
         if isinstance(default_or_err, PropertyError):
@@ -49,7 +50,7 @@ class FileProperty(PropertyProtocol):
         )
 
     @classmethod
-    def convert_value(cls, value: Any) -> None | PropertyError:
+    def convert_value(cls, value: Any) -> PropertyError | None:
         if value is not None:
             return PropertyError(detail="File properties cannot have a default value")
         return value

openapi_python_client/parser/properties/float.py

@@ -2,24 +2,24 @@ from __future__ import annotations
 
 from typing import Any, ClassVar
 
-from attr import define
+from attr import define, field
 
 from ... import schema as oai
-from ...utils import PythonIdentifier
+from ...strings import PythonCode, PythonIdentifier
 from ..errors import PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 
 
 @define
 class FloatProperty(PropertyProtocol):
     """A property of type float"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
     python_name: PythonIdentifier
-    description: str | None
-    example: str | None
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
 
     _type_string: ClassVar[str] = "float"
     _json_type_string: ClassVar[str] = "float"
@@ -34,12 +34,12 @@ class FloatProperty(PropertyProtocol):
     @classmethod
     def build(
         cls,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         default: Any,
         python_name: PythonIdentifier,
-        description: str | None,
-        example: str | None,
+        description: oai.UntrustedString | None,
+        example: Any,
     ) -> FloatProperty | PropertyError:
         checked_default = cls.convert_value(default)
         if isinstance(checked_default, PropertyError):
@@ -55,17 +55,17 @@ class FloatProperty(PropertyProtocol):
         )
 
     @classmethod
-    def convert_value(cls, value: Any) -> Value | None | PropertyError:
+    def convert_value(cls, value: Any) -> Value | PropertyError | None:
         if isinstance(value, Value) or value is None:
             return value
         if isinstance(value, str):
             try:
                 parsed = float(value)
-                return Value(python_code=str(parsed), raw_value=value)
+                return Value(python_code=PythonCode(str(parsed)), raw_value=value)
             except ValueError:
                 return PropertyError(f"Invalid float value: {value}")
         if isinstance(value, float):
-            return Value(python_code=str(value), raw_value=value)
+            return Value(python_code=PythonCode(str(value)), raw_value=value)
         if isinstance(value, int) and not isinstance(value, bool):
-            return Value(python_code=str(float(value)), raw_value=value)
+            return Value(python_code=PythonCode(str(float(value))), raw_value=value)
         return PropertyError(f"Cannot convert {value} to a float")

openapi_python_client/parser/properties/int.py

@@ -2,24 +2,24 @@ from __future__ import annotations
 
 from typing import Any, ClassVar
 
-from attr import define
+from attr import define, field
 
 from ... import schema as oai
-from ...utils import PythonIdentifier
+from ...strings import PythonCode, PythonIdentifier
 from ..errors import PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 
 
 @define
 class IntProperty(PropertyProtocol):
     """A property of type int"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
     python_name: PythonIdentifier
-    description: str | None
-    example: str | None
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
 
     _type_string: ClassVar[str] = "int"
     _json_type_string: ClassVar[str] = "int"
@@ -34,12 +34,12 @@ class IntProperty(PropertyProtocol):
     @classmethod
     def build(
         cls,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         default: Any,
         python_name: PythonIdentifier,
-        description: str | None,
-        example: str | None,
+        description: oai.UntrustedString | None,
+        example: Any,
     ) -> IntProperty | PropertyError:
         checked_default = cls.convert_value(default)
         if isinstance(checked_default, PropertyError):
@@ -55,7 +55,7 @@ class IntProperty(PropertyProtocol):
         )
 
     @classmethod
-    def convert_value(cls, value: Any) -> Value | None | PropertyError:
+    def convert_value(cls, value: Any) -> Value | PropertyError | None:
         if value is None or isinstance(value, Value):
             return value
         converted = value
@@ -69,5 +69,5 @@ class IntProperty(PropertyProtocol):
             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 Value(python_code=PythonCode(str(converted)), raw_value=value)
         return PropertyError(f"Invalid int value: {value}")

openapi_python_client/parser/properties/list_property.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import Any, ClassVar
 
-from attr import define
+from attr import define, field
 
-from ... import Config, utils
+from ... import Config, strings
 from ... import schema as oai
 from ..errors import PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 from .schemas import ReferencePath, Schemas
 
 
@@ -15,12 +15,12 @@ from .schemas import ReferencePath, Schemas
 class ListProperty(PropertyProtocol):
     """A property representing a list (array) of other properties"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
-    python_name: utils.PythonIdentifier
-    description: str | None
-    example: str | None
+    python_name: strings.PythonIdentifier
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
     inner_property: PropertyProtocol
     template: ClassVar[str] = "list_property.py.jinja"
 
@@ -29,13 +29,13 @@ class ListProperty(PropertyProtocol):
         cls,
         *,
         data: oai.Schema,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         schemas: Schemas,
         parent_name: str,
         config: Config,
         process_properties: bool,
-        roots: set[ReferencePath | utils.ClassName],
+        roots: set[ReferencePath | strings.ClassName],
     ) -> tuple[ListProperty | PropertyError, Schemas]:
         """
         Build a ListProperty the right way, use this instead of the normal constructor.
@@ -77,7 +77,7 @@ class ListProperty(PropertyProtocol):
             inner_schema = oai.Schema(anyOf=items)
 
         inner_prop, schemas = property_from_data(
-            name=f"{name}_item",
+            name=oai.UntrustedString(f"{name.get_untrusted_value()}_item"),
             required=True,
             data=inner_schema,
             schemas=schemas,
@@ -95,25 +95,25 @@ class ListProperty(PropertyProtocol):
                 required=required,
                 default=None,
                 inner_property=inner_prop,
-                python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+                python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
                 description=data.description,
                 example=data.example,
             ),
             schemas,
         )
 
-    def convert_value(self, value: Any) -> Value | None | PropertyError:
+    def convert_value(self, value: Any) -> Value | PropertyError | None:
         return None  # pragma: no cover
 
-    def get_base_type_string(self) -> str:
-        return f"list[{self.inner_property.get_type_string()}]"
+    def get_base_type_string(self) -> strings.PythonCode:
+        return strings.PythonCode(f"list[{self.inner_property.get_type_string().as_unembedded_code()}]")
 
-    def get_base_json_type_string(self) -> str:
-        return f"list[{self.inner_property.get_type_string(json=True)}]"
+    def get_base_json_type_string(self) -> strings.PythonCode:
+        return strings.PythonCode(f"list[{self.inner_property.get_type_string(json=True).as_unembedded_code()}]")
 
-    def get_instance_type_string(self) -> str:
-        """Get a string representation of runtime type that should be used for `isinstance` checks"""
-        return "list"
+    def get_instance_type_string(self) -> strings.PythonCode:
+        """Get a code representation of runtime type that should be used for `isinstance` checks"""
+        return strings.PythonCode("list")
 
     def get_imports(self, *, prefix: str) -> set[str]:
         """
@@ -137,9 +137,9 @@ class ListProperty(PropertyProtocol):
         self,
         no_optional: bool = False,
         json: bool = False,
-    ) -> str:
+    ) -> strings.PythonCode:
         """
-        Get a string representation of type that should be used when declaring this property
+        Get a Python code representation of type that should be used when declaring this property
 
         Args:
             no_optional: Do not include Optional or Unset even if the value is optional (needed for isinstance checks)
@@ -152,4 +152,4 @@ class ListProperty(PropertyProtocol):
 
         if no_optional or self.required:
             return type_string
-        return f"{type_string} | Unset"
+        return strings.PythonCode(f"{type_string.as_unembedded_code()} | Unset")

openapi_python_client/parser/properties/literal_enum_property.py

@@ -5,14 +5,14 @@ __all__ = ["LiteralEnumProperty"]
 from typing import Any, ClassVar, cast
 
 from attr import evolve
-from attrs import define
+from attrs import define, field
 
-from ... import Config, utils
+from ... import Config, strings
 from ... import schema as oai
 from ...schema import DataType
 from ..errors import PropertyError
 from .none import NoneProperty
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 from .schemas import Class, Schemas
 from .union import UnionProperty
 
@@ -23,12 +23,12 @@ ValueType = str | int
 class LiteralEnumProperty(PropertyProtocol):
     """A property that should use a literal enum"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
-    python_name: utils.PythonIdentifier
-    description: str | None
-    example: str | None
+    python_name: strings.PythonIdentifier
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
     values: set[ValueType]
     class_info: Class
     value_type: type[ValueType]
@@ -47,7 +47,7 @@ class LiteralEnumProperty(PropertyProtocol):
         cls,
         *,
         data: oai.Schema,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         schemas: Schemas,
         parent_name: str,
@@ -82,7 +82,7 @@ class LiteralEnumProperty(PropertyProtocol):
                     name=name,
                     required=required,
                     default="None",
-                    python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+                    python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
                     description=None,
                     example=None,
                 ),
@@ -114,9 +114,9 @@ class LiteralEnumProperty(PropertyProtocol):
                 config=config,
             )
 
-        class_name = data.title or name
+        class_name: str | oai.UntrustedString = data.title or name
         if parent_name:
-            class_name = f"{utils.pascal_case(parent_name)}{utils.pascal_case(class_name)}"
+            class_name = f"{strings.pascal_case(parent_name)}{strings.pascal_case(class_name)}"
         class_info = Class.from_string(string=class_name, config=config)
         values: set[str | int] = set(value_list)
 
@@ -137,7 +137,7 @@ class LiteralEnumProperty(PropertyProtocol):
             values=values,
             value_type=value_type,
             default=None,
-            python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+            python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
             description=data.description,
             example=data.example,
         )
@@ -155,19 +155,19 @@ class LiteralEnumProperty(PropertyProtocol):
             return value
         if isinstance(value, self.value_type):
             if value in self.values:
-                return Value(python_code=repr(value), raw_value=value)
+                return Value(python_code=strings.PythonCode(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) -> str:
-        return self.class_info.name
+    def get_base_type_string(self) -> strings.PythonCode:
+        return strings.PythonCode(self.class_info.name)
 
-    def get_base_json_type_string(self) -> str:
-        return self.value_type.__name__
+    def get_base_json_type_string(self) -> strings.PythonCode:
+        return strings.PythonCode(self.value_type.__name__)
 
-    def get_instance_type_string(self) -> str:
-        return self.value_type.__name__
+    def get_instance_type_string(self) -> strings.PythonCode:
+        return strings.PythonCode(self.value_type.__name__)
 
     def get_imports(self, *, prefix: str) -> set[str]:
         """
@@ -186,4 +186,4 @@ class LiteralEnumProperty(PropertyProtocol):
         return imports
 
     def get_class_name_snake_case(self) -> str:
-        return utils.snake_case(self.class_info.name)
+        return strings.snake_case(self.class_info.name)

openapi_python_client/parser/properties/merge_properties.py

@@ -67,11 +67,12 @@ def merge_properties(prop1: Property, prop2: Property) -> Property | PropertyErr
         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)}"
+        detail=f"{prop1.get_type_string(no_optional=True).as_unembedded_code()} can't be merged with "
+        f"{prop2.get_type_string(no_optional=True).as_unembedded_code()}"
     )
 
 
-def _merge_same_type(prop1: Property, prop2: Property) -> Property | None | PropertyError:
+def _merge_same_type(prop1: Property, prop2: Property) -> Property | PropertyError | None:
     if type(prop1) is not type(prop2):
         return None
 
@@ -90,7 +91,7 @@ def _merge_same_type(prop1: Property, prop2: Property) -> Property | None | Prop
     return _merge_common_attributes(prop1, prop2)
 
 
-def _merge_string_with_format(prop1: Property, prop2: Property) -> Property | None | PropertyError:
+def _merge_string_with_format(prop1: Property, prop2: Property) -> Property | PropertyError | None:
     """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.
@@ -103,7 +104,7 @@ def _merge_string_with_format(prop1: Property, prop2: Property) -> Property | No
         return None
 
 
-def _merge_numeric(prop1: Property, prop2: Property) -> IntProperty | None | PropertyError:
+def _merge_numeric(prop1: Property, prop2: Property) -> IntProperty | PropertyError | None:
     """Merge IntProperty with FloatProperty"""
     if isinstance(prop1, IntProperty) and isinstance(prop2, IntProperty | FloatProperty):
         return _merge_common_attributes(prop1, prop2)
@@ -136,7 +137,8 @@ def _merge_with_enum(prop1: PropertyProtocol, prop2: PropertyProtocol) -> EnumPr
     ):
         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)}"
+        detail=f"can't combine enum of type {enum_prop.value_type} with "
+        f"{non_enum_prop.get_type_string(no_optional=True).as_unembedded_code()}"
     )
 
 
@@ -162,7 +164,8 @@ def _merge_with_literal_enum(prop1: PropertyProtocol, prop2: PropertyProtocol) -
     ):
         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)}"
+        detail=f"can't combine literal enum of type {enum_prop.value_type} with "
+        f"{non_enum_prop.get_type_string(no_optional=True).as_unembedded_code()}"
     )