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

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

openapi_python_client/parser/properties/none.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 NoneProperty(PropertyProtocol):
     """A property that can only be None"""
 
-    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)
 
     _allowed_locations: ClassVar[set[oai.ParameterLocation]] = {
         oai.ParameterLocation.QUERY,
@@ -32,12 +32,12 @@ class NoneProperty(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,
     ) -> NoneProperty | PropertyError:
         checked_default = cls.convert_value(default)
         if isinstance(checked_default, PropertyError):
@@ -52,10 +52,10 @@ class NoneProperty(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):
             if value == "None":
-                return Value(python_code=value, raw_value=value)
+                return Value(python_code=PythonCode(value), raw_value=value)
         return PropertyError(f"Value {value} is not valid, only None is allowed")

openapi_python_client/parser/properties/protocol.py

@@ -1,20 +1,29 @@
 from __future__ import annotations
 
-__all__ = ["PropertyProtocol", "Value"]
+__all__ = ["PropertyProtocol", "Value", "convert_example"]
 
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TypeVar
+from typing import Any, ClassVar, Protocol, TypeVar
 
 from ... import Config
 from ... import schema as oai
-from ...utils import PythonIdentifier
+from ...strings import PythonCode, PythonIdentifier, safe_for_docstring
 from ..errors import ParseError, PropertyError
 
-if TYPE_CHECKING:  # pragma: no cover
-    from .model_property import ModelProperty
-else:
-    ModelProperty = "ModelProperty"
+
+def convert_example(example: Any) -> oai.UntrustedString | None:
+    """
+    Convert a raw OpenAPI `example` (which can be anything) into an `UntrustedString` (or None).
+
+    Examples only ever appear in docstrings, so non-string examples are stringified. Wrapping ensures a
+    template which uses an example without escaping renders a safe-but-broken value instead of an exploit.
+    """
+    if example is None or isinstance(example, oai.UntrustedString):
+        return example
+    if isinstance(example, str):
+        return oai.UntrustedString(example)
+    return oai.UntrustedString(str(example))
 
 
 @dataclass
@@ -24,7 +33,7 @@ class Value:
     (with string escaping, for example). We still keep the `raw_value` around for merging `allOf`.
     """
 
-    python_code: str
+    python_code: PythonCode
     raw_value: Any
 
 
@@ -45,7 +54,7 @@ class PropertyProtocol(Protocol):
         ValidationError: Raised when the default value fails to be converted to the expected type
     """
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     _type_string: ClassVar[str] = ""
     _json_type_string: ClassVar[str] = ""  # Type of the property after JSON serialization
@@ -56,26 +65,26 @@ class PropertyProtocol(Protocol):
     }
     default: Value | None
     python_name: PythonIdentifier
-    description: str | None
-    example: str | None
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None
 
     template: ClassVar[str] = "any_property.py.jinja"
     json_is_dict: ClassVar[bool] = False
 
     @abstractmethod
-    def convert_value(self, value: Any) -> Value | None | PropertyError:
+    def convert_value(self, value: Any) -> Value | PropertyError | None:
         """Convert a string value to a Value object"""
         raise NotImplementedError()  # pragma: no cover
 
     def validate_location(self, location: oai.ParameterLocation) -> ParseError | None:
         """Returns an error if this type of property is not allowed in the given location"""
         if location not in self._allowed_locations:
-            return ParseError(detail=f"{self.get_type_string()} is not allowed in {location}")
+            return ParseError(detail=f"{self.get_type_string().as_unembedded_code()} is not allowed in {location}")
         if location == oai.ParameterLocation.PATH and not self.required:
             return ParseError(detail="Path parameter must be required")
         return None
 
-    def set_python_name(self, new_name: str, config: Config, skip_snake_case: bool = False) -> None:
+    def set_python_name(self, new_name: oai.UntrustedString, config: Config, skip_snake_case: bool = False) -> None:
         """Mutates this Property to set a new python_name.
 
         Required to mutate due to how Properties are stored and the difficulty of updating them in-dict.
@@ -88,21 +97,21 @@ class PropertyProtocol(Protocol):
             PythonIdentifier(value=new_name, prefix=config.field_prefix, skip_snake_case=skip_snake_case),
         )
 
-    def get_base_type_string(self) -> str:
-        """Get the string describing the Python type of this property. Base types no require quoting."""
-        return self._type_string
+    def get_base_type_string(self) -> PythonCode:
+        """Get the code describing the Python type of this property. Base types no require quoting."""
+        return PythonCode(self._type_string)
 
-    def get_base_json_type_string(self) -> str:
-        """Get the string describing the JSON type of this property. Base types no require quoting."""
-        return self._json_type_string
+    def get_base_json_type_string(self) -> PythonCode:
+        """Get the code describing the JSON type of this property. Base types no require quoting."""
+        return PythonCode(self._json_type_string)
 
     def get_type_string(
         self,
         no_optional: bool = False,
         json: bool = False,
-    ) -> str:
+    ) -> 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)
@@ -115,10 +124,10 @@ class PropertyProtocol(Protocol):
 
         if no_optional or self.required:
             return type_string
-        return f"{type_string} | Unset"
+        return PythonCode(f"{type_string.as_unembedded_code()} | Unset")
 
-    def get_instance_type_string(self) -> str:
-        """Get a string representation of runtime type that should be used for `isinstance` checks"""
+    def get_instance_type_string(self) -> PythonCode:
+        """Get a Python code representation of runtime type that should be used for `isinstance` checks"""
         return self.get_type_string(no_optional=True)
 
     # noinspection PyUnusedLocal
@@ -144,25 +153,26 @@ class PropertyProtocol(Protocol):
         """
         return set()
 
-    def to_string(self) -> str:
+    def to_string(self) -> PythonCode:
         """How this should be declared in a dataclass"""
         default: str | None
         if self.default is not None:
-            default = self.default.python_code
+            default = self.default.python_code.as_unembedded_code()
         elif not self.required:
             default = "UNSET"
         else:
             default = None
 
+        declaration = f"{self.python_name}: {self.get_type_string().as_unembedded_code()}"
         if default is not None:
-            return f"{self.python_name}: {self.get_type_string()} = {default}"
-        return f"{self.python_name}: {self.get_type_string()}"
+            declaration += f" = {default}"
+        return PythonCode(declaration)
 
     def to_docstring(self) -> str:
         """Returns property docstring"""
-        doc = f"{self.python_name} ({self.get_type_string()}): {self.description or ''}"
+        doc = f"{self.python_name} ({safe_for_docstring(self.get_type_string())}): {safe_for_docstring(self.description or '')}"
         if self.default:
-            doc += f" Default: {self.default.python_code}."
+            doc += f" Default: {safe_for_docstring(self.default.python_code)}."
         if self.example:
-            doc += f" Example: {self.example}."
+            doc += f" Example: {safe_for_docstring(self.example)}."
         return doc

openapi_python_client/parser/properties/schemas.py

@@ -10,7 +10,7 @@ __all__ = [
     "update_schemas_with_data",
 ]
 
-from typing import TYPE_CHECKING, NewType, cast
+from typing import TYPE_CHECKING, NewType
 from urllib.parse import urlparse
 
 from attrs import define, evolve, field
@@ -18,7 +18,9 @@ from attrs import define, evolve, field
 from ... import Config
 from ... import schema as oai
 from ...schema.openapi_schema_pydantic import Parameter
-from ...utils import ClassName, PythonIdentifier
+from ...schema.ref import Ref
+from ...schema.untrusted_string import UntrustedString
+from ...strings import ClassName, PythonIdentifier
 from ..errors import ParameterError, ParseError, PropertyError
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -29,10 +31,10 @@ else:
     Property = "Property"
 
 
-ReferencePath = NewType("ReferencePath", str)
+ReferencePath = NewType("ReferencePath", UntrustedString)
 
 
-def parse_reference_path(ref_path_raw: str) -> ReferencePath | ParseError:
+def parse_reference_path(ref_path_raw: Ref) -> ReferencePath | ParseError:
     """
     Takes a raw string provided in a `$ref` and turns it into a validated `_ReferencePath` or a `ParseError` if
     validation fails.
@@ -40,17 +42,17 @@ def parse_reference_path(ref_path_raw: str) -> ReferencePath | ParseError:
     See Also:
         - https://swagger.io/docs/specification/using-ref/
     """
-    parsed = urlparse(ref_path_raw)
+    parsed = urlparse(ref_path_raw.get_untrusted_value())
     if parsed.scheme or parsed.path:
-        return ParseError(detail=f"Remote references such as {ref_path_raw} are not supported yet.")
-    return cast(ReferencePath, parsed.fragment)
+        return ParseError(detail=f"Remote references such as {parsed} are not supported yet.")
+    return ReferencePath(UntrustedString(parsed.fragment))
 
 
-def get_reference_simple_name(ref_path: str) -> str:
+def get_reference_simple_name(ref_path: Ref | UntrustedString) -> UntrustedString:
     """
     Takes a path like `/components/schemas/NameOfThing` and returns a string like `NameOfThing`.
     """
-    return ref_path.rsplit("/", maxsplit=1)[-1]
+    return UntrustedString(ref_path.get_untrusted_value().rsplit("/", maxsplit=1)[-1])
 
 
 @define
@@ -61,10 +63,10 @@ class Class:
     module_name: PythonIdentifier
 
     @staticmethod
-    def from_string(*, string: str, config: Config) -> "Class":
+    def from_string(*, string: str | UntrustedString, config: Config) -> "Class":
         """Get a Class from an arbitrary string"""
-        class_name = get_reference_simple_name(string)  # Get rid of ref path stuff
-        class_name = ClassName(class_name, config.field_prefix)
+        untrusted_class_name = get_reference_simple_name(Ref(string))  # Get rid of ref path stuff
+        class_name = ClassName(untrusted_class_name, config.field_prefix)
         override = config.class_overrides.get(class_name)
 
         if override is not None and override.class_name is not None:
@@ -134,12 +136,15 @@ def update_schemas_with_data(
     )
 
     if isinstance(prop, PropertyError):
-        prop.detail = f"{prop.header}: {prop.detail}"
-        prop.header = f"Unable to parse schema {ref_path}"
-        if isinstance(prop.data, oai.Reference) and prop.data.ref.endswith(ref_path):  # pragma: nocover
-            prop.detail += (
+        detail = f"{prop.header}: {prop.detail}" if prop.detail is not None else prop.header
+        prop.header = f"Unable to parse schema {ref_path.get_untrusted_value()}"
+        if isinstance(prop.data, oai.Reference) and prop.data.ref.endswith(
+            ref_path.get_untrusted_value()
+        ):  # pragma: nocover
+            detail += (
                 "\n\nRecursive and circular references are not supported directly in an array schema's 'items' section"
             )
+        prop.detail = detail
         return prop
 
     schemas = evolve(schemas, classes_by_reference={ref_path: prop, **schemas.classes_by_reference})
@@ -157,7 +162,7 @@ class Parameters:
 
 def parameter_from_data(
     *,
-    name: str,
+    name: UntrustedString,
     data: oai.Reference | oai.Parameter,
     parameters: Parameters,
     config: Config,
@@ -171,10 +176,10 @@ def parameter_from_data(
         return ParameterError("Parameter has no schema"), parameters
 
     new_param = Parameter(
-        name=name,
+        name=name.get_untrusted_value(),
         required=data.required,
         explode=data.explode,
-        style=data.style,
+        style=data.style.get_untrusted_value() if data.style is not None else None,
         param_schema=data.param_schema,
         param_in=data.param_in,
     )
@@ -203,10 +208,12 @@ def update_parameters_with_data(
     """
     param, parameters = parameter_from_data(data=data, name=data.name, parameters=parameters, config=config)
 
-    if isinstance(param, ParameterError):
+    if isinstance(param, ParameterError):  # pragma: no cover
         param.detail = f"{param.header}: {param.detail}"
-        param.header = f"Unable to parse parameter {ref_path}"
-        if isinstance(param.data, oai.Reference) and param.data.ref.endswith(ref_path):  # pragma: nocover
+        param.header = f"Unable to parse parameter {ref_path.get_untrusted_value()}"
+        if isinstance(param.data, oai.Reference) and param.data.ref.endswith(
+            ref_path.get_untrusted_value()
+        ):  # pragma: nocover
             param.detail += (
                 "\n\nRecursive and circular references are not supported. "
                 "See https://github.com/openapi-generators/openapi-python-client/issues/466"
@@ -245,5 +252,5 @@ def parameter_from_reference(
 
     _resolved_parameter_class = parameters.classes_by_reference.get(ref_path, None)
     if _resolved_parameter_class is None:
-        return ParameterError(detail=f"Reference `{ref_path}` not found.")
+        return ParameterError(detail=f"Reference `{ref_path.get_untrusted_value()}` not found.")
     return _resolved_parameter_class

openapi_python_client/parser/properties/string.py

@@ -2,25 +2,24 @@ from __future__ import annotations
 
 from typing import Any, ClassVar, overload
 
-from attr import define
+from attr import define, field
 
 from ... import schema as oai
-from ... import utils
-from ...utils import PythonIdentifier
+from ...strings import PythonCode, PythonIdentifier, remove_string_escapes
 from ..errors import PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 
 
 @define
 class StringProperty(PropertyProtocol):
     """A property of type str"""
 
-    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] = "str"
     _json_type_string: ClassVar[str] = "str"
     _allowed_locations: ClassVar[set[oai.ParameterLocation]] = {
@@ -33,12 +32,12 @@ class StringProperty(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,
     ) -> StringProperty | PropertyError:
         checked_default = cls.convert_value(default)
         return cls(
@@ -65,4 +64,4 @@ class StringProperty(PropertyProtocol):
             return value
         if not isinstance(value, str):
             value = str(value)
-        return Value(python_code=repr(utils.remove_string_escapes(value)), raw_value=value)
+        return Value(python_code=PythonCode(repr(remove_string_escapes(value))), raw_value=value)