chore: Refactor Value to store raw values

Author: dbanty

openapi_python_client/parser/properties/any.py

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

openapi_python_client/parser/properties/boolean.py

@@ -59,9 +59,9 @@ def convert_value(cls, value: Any) -> Value | None | PropertyError:
             return value
         if isinstance(value, str):
             if value.lower() == "true":
-                return Value("True")
+                return Value(python_code="True", raw_value=value)
             elif value.lower() == "false":
-                return Value("False")
+                return Value(python_code="False", raw_value=value)
         if isinstance(value, bool):
-            return Value(str(value))
+            return Value(python_code=str(value), raw_value=value)
         return PropertyError(f"Invalid boolean value: {value}")

openapi_python_client/parser/properties/const.py

@@ -69,7 +69,9 @@ def convert_value(self, value: Any) -> Value | None | PropertyError:
         if value is None:
             return value
         if value != self.value:
-            return PropertyError(detail=f"Invalid value for const {self.name}; {value} != {self.value}")
+            return PropertyError(
+                detail=f"Invalid value for const {self.name}; {value.raw_value} != {self.value.raw_value}"
+            )
         return value
 
     @staticmethod
@@ -89,7 +91,7 @@ def _convert_value(value: Any) -> Value | None:
             return value  # pragma: no cover
         if isinstance(value, str):
             return StringProperty.convert_value(value)
-        return Value(str(value))
+        return Value(python_code=str(value), raw_value=value)
 
     def get_type_string(
         self,
@@ -99,7 +101,7 @@ def get_type_string(
         multipart: bool = False,
         quoted: bool = False,
     ) -> str:
-        lit = f"Literal[{self.value}]"
+        lit = f"Literal[{self.value.python_code}]"
         if not no_optional and not self.required:
             return f"Union[{lit}, Unset]"
         return lit

openapi_python_client/parser/properties/date.py

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

openapi_python_client/parser/properties/datetime.py

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

openapi_python_client/parser/properties/enum_property.py

@@ -159,17 +159,11 @@ def convert_value(self, value: Any) -> Value | PropertyError | None:
         if isinstance(value, self.value_type):
             inverse_values = {v: k for k, v in self.values.items()}
             try:
-                return Value(f"{self.class_info.name}.{inverse_values[value]}")
+                return Value(python_code=f"{self.class_info.name}.{inverse_values[value]}", raw_value=value)
             except KeyError:
                 return PropertyError(detail=f"Value {value} is not valid for enum {self.name}")
         return PropertyError(detail=f"Cannot convert {value} to enum {self.name} of type {self.value_type}")
 
-    def default_to_raw(self) -> ValueType | None:
-        if self.default is None:
-            return None
-        key = self.default.split(".")[1]
-        return self.values[key]
-
     def get_base_type_string(self, *, quoted: bool = False) -> str:
         return self.class_info.name
 

openapi_python_client/parser/properties/float.py

@@ -61,11 +61,11 @@ def convert_value(cls, value: Any) -> Value | None | PropertyError:
         if isinstance(value, str):
             try:
                 parsed = float(value)
-                return Value(str(parsed))
+                return Value(python_code=str(parsed), raw_value=value)
             except ValueError:
                 return PropertyError(f"Invalid float value: {value}")
         if isinstance(value, float):
-            return Value(str(value))
+            return Value(python_code=str(value), raw_value=value)
         if isinstance(value, int) and not isinstance(value, bool):
-            return Value(str(float(value)))
+            return Value(python_code=str(float(value)), raw_value=value)
         return PropertyError(f"Cannot convert {value} to a float")

openapi_python_client/parser/properties/int.py

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

openapi_python_client/parser/properties/merge_properties.py

@@ -148,7 +148,10 @@ def _merge_common_attributes(base: PropertyT, *extend_with: PropertyProtocol) ->
     """
     current = base
     for override in extend_with:
-        override_default = current.convert_value(override.default_to_raw())
+        if override.default is not None:
+            override_default = current.convert_value(override.default.raw_value)
+        else:
+            override_default = None
         if isinstance(override_default, PropertyError):
             return override_default
         current = evolve(

openapi_python_client/parser/properties/none.py

@@ -57,5 +57,5 @@ def convert_value(cls, value: Any) -> Value | None | PropertyError:
             return value
         if isinstance(value, str):
             if value == "None":
-                return Value(value)
+                return Value(python_code=value, raw_value=value)
         return PropertyError(f"Value {value} is not valid, only None is allowed")

openapi_python_client/parser/properties/protocol.py

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

openapi_python_client/parser/properties/string.py

@@ -65,4 +65,4 @@ def convert_value(cls, value: Any) -> Value | None:
             return value
         if not isinstance(value, str):
             value = str(value)
-        return Value(repr(utils.remove_string_escapes(value)))
+        return Value(python_code=repr(utils.remove_string_escapes(value)), raw_value=value)

openapi_python_client/templates/property_templates/const_property.py.jinja

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