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

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()}"
     )
 
 

openapi_python_client/parser/properties/model_property.py

@@ -3,14 +3,14 @@ from __future__ import annotations
 from itertools import chain
 from typing import Any, ClassVar, NamedTuple
 
-from attrs import define, evolve
+from attrs import define, evolve, field
 
-from ... import Config, utils
+from ... import Config, strings
 from ... import schema as oai
-from ...utils import PythonIdentifier
+from ...strings import PythonIdentifier
 from ..errors import ParseError, PropertyError
 from .any import AnyProperty
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 from .schemas import Class, ReferencePath, Schemas, parse_reference_path
 
 
@@ -18,15 +18,15 @@ from .schemas import Class, ReferencePath, Schemas, parse_reference_path
 class ModelProperty(PropertyProtocol):
     """A property which refers to another Schema"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
-    python_name: utils.PythonIdentifier
-    example: str | None
+    python_name: strings.PythonIdentifier
+    example: oai.UntrustedString | None = field(converter=convert_example)
     class_info: Class
     data: oai.Schema
-    description: str
-    roots: set[ReferencePath | utils.ClassName]
+    description: oai.UntrustedString | None
+    roots: set[ReferencePath | strings.ClassName]
     required_properties: list[Property] | None
     optional_properties: list[Property] | None
     relative_imports: set[str] | None
@@ -43,13 +43,13 @@ class ModelProperty(PropertyProtocol):
         cls,
         *,
         data: oai.Schema,
-        name: str,
+        name: oai.UntrustedString,
         schemas: Schemas,
         required: bool,
         parent_name: str | None,
         config: Config,
         process_properties: bool,
-        roots: set[ReferencePath | utils.ClassName],
+        roots: set[ReferencePath | strings.ClassName],
     ) -> tuple[ModelProperty | PropertyError, Schemas]:
         """
         A single ModelProperty from its OAI data
@@ -65,12 +65,13 @@ class ModelProperty(PropertyProtocol):
             roots: Set of strings that identify schema objects on which the new ModelProperty will depend
             process_properties: Determines whether the new ModelProperty will be initialized with property data
         """
+        class_string: str | oai.UntrustedString
         if not config.use_path_prefixes_for_title_model_names and data.title:
             class_string = data.title
         else:
             title = data.title or name
             if parent_name:
-                class_string = f"{utils.pascal_case(parent_name)}{utils.pascal_case(title)}"
+                class_string = f"{strings.pascal_case(parent_name)}{strings.pascal_case(title)}"
             else:
                 class_string = title
         class_info = Class.from_string(string=class_string, config=config)
@@ -92,7 +93,7 @@ class ModelProperty(PropertyProtocol):
             relative_imports = property_data.relative_imports
             lazy_imports = property_data.lazy_imports
             for root in roots:
-                if isinstance(root, utils.ClassName):
+                if isinstance(root, strings.ClassName):
                     continue
                 schemas.add_dependencies(root, {class_info.name})
 
@@ -105,11 +106,11 @@ class ModelProperty(PropertyProtocol):
             relative_imports=relative_imports,
             lazy_imports=lazy_imports,
             additional_properties=additional_properties,
-            description=data.description or "",
+            description=data.description,
             default=None,
             required=required,
             name=name,
-            python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+            python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
             example=data.example,
         )
         if class_info.name in schemas.classes_by_name:
@@ -126,7 +127,7 @@ class ModelProperty(PropertyProtocol):
         return prop, schemas
 
     @classmethod
-    def convert_value(cls, value: Any) -> Value | None | PropertyError:
+    def convert_value(cls, value: Any) -> Value | PropertyError | None:
         if value is not None:
             return PropertyError(detail="ModelProperty cannot have a default value")  # pragma: no cover
         return None
@@ -140,8 +141,8 @@ class ModelProperty(PropertyProtocol):
         """Constructs a self import statement from this ModelProperty's attributes"""
         return f"models.{self.class_info.module_name} import {self.class_info.name}"
 
-    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_imports(self, *, prefix: str) -> set[str]:
         """
@@ -188,9 +189,9 @@ class ModelProperty(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)
@@ -203,7 +204,7 @@ class ModelProperty(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")
 
 
 from .property import Property  # noqa: E402
@@ -232,14 +233,14 @@ def _process_properties(  # noqa: PLR0912, PLR0911
     *,
     data: oai.Schema,
     schemas: Schemas,
-    class_name: utils.ClassName,
+    class_name: strings.ClassName,
     config: Config,
-    roots: set[ReferencePath | utils.ClassName],
+    roots: set[ReferencePath | strings.ClassName],
 ) -> _PropertyData | PropertyError:
     from . import property_from_data  # noqa: PLC0415
     from .merge_properties import merge_properties  # noqa: PLC0415
 
-    properties: dict[str, Property] = {}
+    properties: dict[oai.UntrustedString, Property] = {}
     relative_imports: set[str] = set()
     lazy_imports: set[str] = set()
     required_set = set(data.required or [])
@@ -265,7 +266,7 @@ def _process_properties(  # noqa: PLR0912, PLR0911
         properties[merged_prop.name] = merged_prop
         return None
 
-    unprocessed_props: list[tuple[str, oai.Reference | oai.Schema]] = (
+    unprocessed_props: list[tuple[oai.UntrustedString, oai.Reference | oai.Schema]] = (
         list(data.properties.items()) if data.properties else []
     )
     for sub_prop in data.allOf:
@@ -275,7 +276,7 @@ def _process_properties(  # noqa: PLR0912, PLR0911
                 return PropertyError(detail=ref_path.detail, data=sub_prop)
             sub_model = schemas.classes_by_reference.get(ref_path)
             if sub_model is None:
-                return PropertyError(f"Reference {sub_prop.ref} not found")
+                return PropertyError(f"Reference {sub_prop.ref.get_untrusted_value()} not found")
             if not isinstance(sub_model, ModelProperty):
                 return PropertyError("Cannot take allOf a non-object")
             # Properties of allOf references first should be processed first
@@ -335,10 +336,10 @@ def _process_properties(  # noqa: PLR0912, PLR0911
 
 
 ANY_ADDITIONAL_PROPERTY = AnyProperty.build(
-    name="additional",
+    name=oai.UntrustedString("additional"),
     required=True,
     default=None,
-    description="",
+    description=None,
     python_name=PythonIdentifier(value="additional", prefix=""),
     example=None,
 )
@@ -348,10 +349,10 @@ def _get_additional_properties(
     *,
     schema_additional: None | (bool | (oai.Reference | oai.Schema)),
     schemas: Schemas,
-    class_name: utils.ClassName,
+    class_name: strings.ClassName,
     config: Config,
-    roots: set[ReferencePath | utils.ClassName],
-) -> tuple[Property | None | PropertyError, Schemas]:
+    roots: set[ReferencePath | strings.ClassName],
+) -> tuple[Property | PropertyError | None, Schemas]:
     from . import property_from_data  # noqa: PLC0415
 
     if schema_additional is None:
@@ -367,7 +368,7 @@ def _get_additional_properties(
         return ANY_ADDITIONAL_PROPERTY, schemas
 
     additional_properties, schemas = property_from_data(
-        name="AdditionalProperty",
+        name=oai.UntrustedString("AdditionalProperty"),
         required=True,  # in the sense that if present in the dict will not be None
         data=schema_additional,
         schemas=schemas,
@@ -384,7 +385,7 @@ def _process_property_data(
     schemas: Schemas,
     class_info: Class,
     config: Config,
-    roots: set[ReferencePath | utils.ClassName],
+    roots: set[ReferencePath | strings.ClassName],
 ) -> tuple[tuple[_PropertyData, Property | None] | PropertyError, Schemas]:
     property_data = _process_properties(
         data=data, schemas=schemas, class_name=class_info.name, config=config, roots=roots