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

openapi_python_client/parser/properties/__init__.py

@@ -18,8 +18,10 @@ from collections.abc import Iterable
 
 from attrs import evolve
 
-from ... import Config, utils
+from ... import Config, strings
 from ... import schema as oai
+from ...schema.ref import Ref
+from ...schema.untrusted_string import UntrustedString
 from ..errors import ParameterError, ParseError, PropertyError
 from .any import AnyProperty
 from .boolean import BooleanProperty
@@ -51,11 +53,11 @@ from .uuid import UuidProperty
 
 
 def _string_based_property(
-    name: str, required: bool, data: oai.Schema, config: Config
+    name: UntrustedString, required: bool, data: oai.Schema, config: Config
 ) -> 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)
+    python_name = strings.PythonIdentifier(value=name, prefix=config.field_prefix)
     if string_format == "date-time":
         return DateTimeProperty.build(
             name=name,
@@ -103,16 +105,17 @@ def _string_based_property(
 
 
 def _property_from_ref(
-    name: str,
+    *,
+    name: UntrustedString,
     required: bool,
     parent: oai.Schema | None,
     data: oai.Reference,
     schemas: Schemas,
     config: Config,
-    roots: set[ReferencePath | utils.ClassName],
+    roots: set[ReferencePath | strings.ClassName],
 ) -> tuple[Property | PropertyError, Schemas]:
     ref_path = parse_reference_path(data.ref)
-    if isinstance(ref_path, ParseError):
+    if isinstance(ref_path, ParseError):  # pragma: no cover
         return PropertyError(data=data, detail=ref_path.detail), schemas
     existing = schemas.classes_by_reference.get(ref_path)
     if not existing:
@@ -130,7 +133,7 @@ def _property_from_ref(
         existing,
         required=required,
         name=name,
-        python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+        python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
         default=default,  # type: ignore # mypy can't tell that default comes from the same class...
     )
 
@@ -139,18 +142,18 @@ def _property_from_ref(
 
 
 def property_from_data(  # noqa: PLR0911, PLR0912
-    name: str,
+    *,
+    name: UntrustedString,
     required: bool,
     data: oai.Reference | oai.Schema,
     schemas: Schemas,
     parent_name: str,
     config: Config,
     process_properties: bool = True,
-    roots: set[ReferencePath | utils.ClassName] | None = None,
+    roots: set[ReferencePath | strings.ClassName] | None = None,
 ) -> tuple[Property | PropertyError, Schemas]:
     """Generate a Property from the OpenAPI dictionary representation of it"""
     roots = roots or set()
-    name = utils.remove_string_escapes(name)
     if isinstance(data, oai.Reference):
         return _property_from_ref(
             name=name,
@@ -190,7 +193,7 @@ def property_from_data(  # noqa: PLR0911, PLR0912
                 name=name,
                 required=required,
                 default=data.default,
-                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,
             ),
@@ -230,7 +233,7 @@ def property_from_data(  # noqa: PLR0911, PLR0912
                 required=required,
                 default=data.default,
                 const=data.const,
-                python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+                python_name=strings.PythonIdentifier(value=name, prefix=config.field_prefix),
                 description=data.description,
             ),
             schemas,
@@ -246,7 +249,7 @@ def property_from_data(  # noqa: PLR0911, PLR0912
                 name=name,
                 default=data.default,
                 required=required,
-                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,
             ),
@@ -258,7 +261,7 @@ def property_from_data(  # noqa: PLR0911, PLR0912
                 name=name,
                 default=data.default,
                 required=required,
-                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,
             ),
@@ -270,7 +273,7 @@ def property_from_data(  # noqa: PLR0911, PLR0912
                 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=data.description,
                 example=data.example,
             ),
@@ -303,7 +306,7 @@ def property_from_data(  # noqa: PLR0911, PLR0912
             name=name,
             required=required,
             default=data.default,
-            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,
         ),
@@ -313,11 +316,11 @@ def property_from_data(  # noqa: PLR0911, PLR0912
 
 def _create_schemas(
     *,
-    components: dict[str, oai.Reference | oai.Schema],
+    components: dict[UntrustedString, oai.Reference | oai.Schema],
     schemas: Schemas,
     config: Config,
 ) -> Schemas:
-    to_process: Iterable[tuple[str, oai.Reference | oai.Schema]] = components.items()
+    to_process: Iterable[tuple[UntrustedString, oai.Reference | oai.Schema]] = components.items()
     still_making_progress = True
     errors: list[PropertyError] = []
 
@@ -325,12 +328,12 @@ def _create_schemas(
     while still_making_progress:
         still_making_progress = False
         errors = []
-        next_round: list[tuple[str, oai.Reference | oai.Schema]] = []
+        next_round: list[tuple[UntrustedString, oai.Reference | oai.Schema]] = []
         # Only accumulate errors from the last round, since we might fix some along the way
         for name, data in to_process:
             schema_data: oai.Reference | oai.Schema | None = data
-            ref_path = parse_reference_path(f"#/components/schemas/{name}")
-            if isinstance(ref_path, ParseError):
+            ref_path = parse_reference_path(Ref(f"#/components/schemas/{name.get_untrusted_value()}"))
+            if isinstance(ref_path, ParseError):  # pragma: no cover
                 schemas.errors.append(PropertyError(detail=ref_path.detail, data=data))
                 continue
             if isinstance(data, oai.Reference):
@@ -361,13 +364,13 @@ def _create_schemas(
     return schemas
 
 
-def _propogate_removal(*, root: ReferencePath | utils.ClassName, schemas: Schemas, error: PropertyError) -> None:
-    if isinstance(root, utils.ClassName):
+def _propogate_removal(*, root: ReferencePath | strings.ClassName, schemas: Schemas, error: PropertyError) -> None:
+    if isinstance(root, strings.ClassName):
         schemas.classes_by_name.pop(root, None)
         return
     if root in schemas.classes_by_reference:
         error.detail = error.detail or ""
-        error.detail += f"\n{root}"
+        error.detail += f"\n{root.get_untrusted_value()}"
         del schemas.classes_by_reference[root]
         for child in schemas.dependencies.get(root, set()):
             _propogate_removal(root=child, schemas=schemas, error=error)
@@ -399,10 +402,10 @@ def _process_models(*, schemas: Schemas, config: Config) -> Schemas:
         for model_prop in to_process:
             schemas_or_err = process_model(model_prop, schemas=schemas, config=config)
             if isinstance(schemas_or_err, PropertyError):
-                schemas_or_err.header = f"\nUnable to process schema {model_prop.name}:"
+                schemas_or_err.header = f"\nUnable to process schema {model_prop.name.get_untrusted_value()}:"
                 if isinstance(schemas_or_err.data, oai.Reference) and schemas_or_err.data.ref.endswith(
                     f"/{model_prop.class_info.name}"
-                ):
+                ):  # pragma: no cover
                     schemas_or_err.detail = schemas_or_err.detail or ""
                     schemas_or_err.detail += "\n\nRecursive allOf reference found"
                     final_model_errors.append((model_prop, schemas_or_err))
@@ -421,7 +424,7 @@ def _process_models(*, schemas: Schemas, config: Config) -> Schemas:
 
 def build_schemas(
     *,
-    components: dict[str, oai.Reference | oai.Schema],
+    components: dict[UntrustedString, oai.Reference | oai.Schema],
     schemas: Schemas,
     config: Config,
 ) -> Schemas:
@@ -433,12 +436,12 @@ def build_schemas(
 
 def build_parameters(
     *,
-    components: dict[str, oai.Reference | oai.Parameter],
+    components: dict[UntrustedString, oai.Reference | oai.Parameter],
     parameters: Parameters,
     config: Config,
 ) -> Parameters:
     """Get a list of Parameters from an OpenAPI dict"""
-    to_process: Iterable[tuple[str, oai.Reference | oai.Parameter]] = []
+    to_process: Iterable[tuple[UntrustedString, oai.Reference | oai.Parameter]] = []
     if components is not None:
         to_process = components.items()
     still_making_progress = True
@@ -451,17 +454,17 @@ def build_parameters(
         next_round = []
         # Only accumulate errors from the last round, since we might fix some along the way
         for name, data in to_process:
-            if isinstance(data, oai.Reference):
+            if isinstance(data, oai.Reference):  # pragma: no cover
                 parameters.errors.append(ParameterError(data=data, detail="Reference parameters are not supported."))
                 continue
-            ref_path = parse_reference_path(f"#/components/parameters/{name}")
-            if isinstance(ref_path, ParseError):
+            ref_path = parse_reference_path(Ref(f"#/components/parameters/{name.get_untrusted_value()}"))
+            if isinstance(ref_path, ParseError):  # pragma: no cover
                 parameters.errors.append(ParameterError(detail=ref_path.detail, data=data))
                 continue
             parameters_or_err = update_parameters_with_data(
                 ref_path=ref_path, data=data, parameters=parameters, config=config
             )
-            if isinstance(parameters_or_err, ParameterError):
+            if isinstance(parameters_or_err, ParameterError):  # pragma: no cover
                 next_round.append((name, data))
                 errors.append(parameters_or_err)
                 continue

openapi_python_client/parser/properties/any.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from typing import Any, ClassVar
 
-from attr import define
+from attr import define, field
 
-from ...utils import PythonIdentifier
-from .protocol import PropertyProtocol, Value
+from ...schema.untrusted_string import UntrustedString
+from ...strings import PythonCode, PythonIdentifier
+from .protocol import PropertyProtocol, Value, convert_example
 
 
 @define
@@ -15,12 +16,13 @@ class AnyProperty(PropertyProtocol):
     @classmethod
     def build(
         cls,
-        name: str,
+        *,
+        name: UntrustedString,
         required: bool,
         default: Any,
         python_name: PythonIdentifier,
-        description: str | None,
-        example: str | None,
+        description: UntrustedString | None,
+        example: Any,
     ) -> AnyProperty:
         return cls(
             name=name,
@@ -39,13 +41,13 @@ class AnyProperty(PropertyProtocol):
             return value
         if isinstance(value, str):
             return StringProperty.convert_value(value)
-        return Value(python_code=str(value), raw_value=value)
+        return Value(python_code=PythonCode(str(value)), raw_value=value)
 
-    name: str
+    name: UntrustedString
     required: bool
     default: Value | None
     python_name: PythonIdentifier
-    description: str | None
-    example: str | None
+    description: UntrustedString | None
+    example: UntrustedString | None = field(converter=convert_example)
     _type_string: ClassVar[str] = "Any"
     _json_type_string: ClassVar[str] = "Any"

openapi_python_client/parser/properties/boolean.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 BooleanProperty(PropertyProtocol):
     """Property for bool"""
 
-    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] = "bool"
     _json_type_string: ClassVar[str] = "bool"
@@ -34,12 +34,13 @@ class BooleanProperty(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,
     ) -> BooleanProperty | PropertyError:
         checked_default = cls.convert_value(default)
         if isinstance(checked_default, PropertyError):
@@ -54,14 +55,14 @@ class BooleanProperty(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):
             if value.lower() == "true":
-                return Value(python_code="True", raw_value=value)
+                return Value(python_code=PythonCode("True"), raw_value=value)
             elif value.lower() == "false":
-                return Value(python_code="False", raw_value=value)
+                return Value(python_code=PythonCode("False"), raw_value=value)
         if isinstance(value, bool):
-            return Value(python_code=str(value), raw_value=value)
+            return Value(python_code=PythonCode(str(value)), raw_value=value)
         return PropertyError(f"Invalid boolean value: {value}")

openapi_python_client/parser/properties/const.py

@@ -4,7 +4,8 @@ from typing import Any, ClassVar, overload
 
 from attr import define
 
-from ...utils import PythonIdentifier
+from ... import schema as oai
+from ...strings import PythonCode, PythonIdentifier
 from ..errors import PropertyError
 from .protocol import PropertyProtocol, Value
 from .string import StringProperty
@@ -14,12 +15,12 @@ from .string import StringProperty
 class ConstProperty(PropertyProtocol):
     """A property representing a const value"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     value: Value
     default: Value | None
     python_name: PythonIdentifier
-    description: str | None
+    description: oai.UntrustedString | None
     example: None
     template: ClassVar[str] = "const_property.py.jinja"
 
@@ -29,10 +30,10 @@ class ConstProperty(PropertyProtocol):
         *,
         const: str | int | float | bool,
         default: Any,
-        name: str,
+        name: oai.UntrustedString,
         python_name: PythonIdentifier,
         required: bool,
-        description: str | None,
+        description: oai.UntrustedString | None,
     ) -> ConstProperty | PropertyError:
         """
         Create a `ConstProperty` the right way.
@@ -62,7 +63,7 @@ class ConstProperty(PropertyProtocol):
         prop.default = converted_default
         return prop
 
-    def convert_value(self, value: Any) -> Value | None | PropertyError:
+    def convert_value(self, value: Any) -> Value | PropertyError | None:
         value = self._convert_value(value)
         if value is None:
             return value
@@ -87,16 +88,16 @@ class ConstProperty(PropertyProtocol):
             return value
         if isinstance(value, str):
             return StringProperty.convert_value(value)
-        return Value(python_code=str(value), raw_value=value)
+        return Value(python_code=PythonCode(str(value)), raw_value=value)
 
     def get_type_string(
         self,
         no_optional: bool = False,
         json: bool = False,
-    ) -> str:
-        lit = f"Literal[{self.value.python_code}]"
+    ) -> PythonCode:
+        lit = PythonCode(f"Literal[{self.value.python_code.as_unembedded_code()}]")
         if not no_optional and not self.required:
-            return f"{lit} | Unset"
+            return PythonCode(f"{lit.as_unembedded_code()} | Unset")
         return lit
 
     def get_imports(self, *, prefix: str) -> set[str]:

openapi_python_client/parser/properties/date.py

@@ -3,23 +3,24 @@ from __future__ import annotations
 import datetime
 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 PythonCode, PythonIdentifier
 from ..errors import PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 
 
 @define
 class DateProperty(PropertyProtocol):
     """A property of type datetime.date"""
 
-    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] = "datetime.date"
     _json_type_string: ClassVar[str] = "str"
@@ -28,12 +29,13 @@ class DateProperty(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,
     ) -> DateProperty | PropertyError:
         checked_default = cls.convert_value(default)
         if isinstance(checked_default, PropertyError):
@@ -49,7 +51,7 @@ class DateProperty(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):
@@ -57,7 +59,7 @@ class DateProperty(PropertyProtocol):
                 datetime.date.fromisoformat(value)  # make sure it's a valid value
             except ValueError as e:
                 return PropertyError(f"Invalid date: {e}")
-            return Value(python_code=f"datetime.date.fromisoformat({value!r})", raw_value=value)
+            return Value(python_code=PythonCode(f"datetime.date.fromisoformat({value!r})"), raw_value=value)
         return PropertyError(f"Cannot convert {value} to a date")
 
     def get_imports(self, *, prefix: str) -> set[str]:

openapi_python_client/parser/properties/datetime.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 import datetime
 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 PythonCode, PythonIdentifier
 from ..errors import PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 
 
 @define
@@ -16,12 +17,12 @@ class DateTimeProperty(PropertyProtocol):
     A property of type datetime.datetime
     """
 
-    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] = "datetime.datetime"
     _json_type_string: ClassVar[str] = "str"
@@ -30,12 +31,13 @@ class DateTimeProperty(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,
     ) -> DateTimeProperty | PropertyError:
         checked_default = cls.convert_value(default)
         if isinstance(checked_default, PropertyError):
@@ -51,7 +53,7 @@ class DateTimeProperty(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
         if isinstance(value, str):
@@ -59,7 +61,7 @@ class DateTimeProperty(PropertyProtocol):
                 datetime.datetime.fromisoformat(value)  # make sure it's a valid value
             except ValueError as e:
                 return PropertyError(f"Invalid datetime: {e}")
-            return Value(python_code=f"datetime.datetime.fromisoformat({value!r})", raw_value=value)
+            return Value(python_code=PythonCode(f"datetime.datetime.fromisoformat({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/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