Allow Unset values to avoid being send during serialization

Author: bowenwr

openapi_python_client/parser/properties.py

@@ -51,9 +51,16 @@ def get_type_string(self, no_optional: bool = False) -> str:
         Args:
             no_optional: Do not include Optional even if the value is optional (needed for isinstance checks)
         """
-        if no_optional or (self.required and not self.nullable):
-            return self._type_string
-        return f"Optional[{self._type_string}]"
+        return type_string(no_optional, self, self._type_string)
+
+    def get_query_string(self, no_optional: bool = False) -> str:
+        """
+        Get a string representation of type that should be used when the property is represented in a query string.
+
+        Args:
+            no_optional: Do not include Optional even if the value is optional (needed for isinstance checks)
+        """
+        return query_string(no_optional, self, self._type_string)
 
     def get_imports(self, *, prefix: str) -> Set[str]:
         """
@@ -63,24 +70,42 @@ def get_imports(self, *, prefix: str) -> Set[str]:
             prefix: A prefix to put before any relative (local) module names. This should be the number of . to get
             back to the root of the generated client.
         """
-        if self.nullable or not self.required:
+        if self.required and self.nullable:
             return {"from typing import Optional"}
+        elif not self.required:
+            return {"from typing import Union",
+                    f"from {prefix}types import Unset",
+                    f"from {prefix}types import UNSET"}
         return set()
 
     def to_string(self) -> str:
         """ How this should be declared in a dataclass """
         if self.default:
             default = self.default
         elif not self.required:
-            default = "None"
+            default = "UNSET"
         else:
             default = None
 
         if default is not None:
-            return f"{self.python_name}: {self.get_type_string()} = {self.default}"
+            return f"{self.python_name}: {self.get_type_string()} = {default}"
         else:
             return f"{self.python_name}: {self.get_type_string()}"
 
+    def to_query_string(self) -> str:
+        """ How this should be declared in a query string """
+        if self.default:
+            default = self.default
+        elif not self.required:
+            default = "None"
+        else:
+            default = None
+
+        if default is not None:
+            return f"{self.python_name}: {self.get_query_string()} = {default}"
+        else:
+            return f"{self.python_name}: {self.get_query_string()}"
+
 
 @dataclass
 class StringProperty(Property):
@@ -222,9 +247,13 @@ class ListProperty(Property, Generic[InnerProp]):
 
     def get_type_string(self, no_optional: bool = False) -> str:
         """ Get a string representation of type that should be used when declaring this property """
-        if no_optional or (self.required and not self.nullable):
-            return f"List[{self.inner_property.get_type_string()}]"
-        return f"Optional[List[{self.inner_property.get_type_string()}]]"
+        return type_string(no_optional, self, f"List[{self.inner_property.get_type_string()}]")
+
+    def get_query_string(self, no_optional: bool = False) -> str:
+        """
+        Get a string representation of type that should be used when the property is represented in a query string.
+        """
+        return query_string(no_optional, self, f"List[{self.inner_property.get_query_string()}]")
 
     def get_imports(self, *, prefix: str) -> Set[str]:
         """
@@ -254,9 +283,15 @@ def get_type_string(self, no_optional: bool = False) -> str:
         """ Get a string representation of type that should be used when declaring this property """
         inner_types = [p.get_type_string() for p in self.inner_properties]
         inner_prop_string = ", ".join(inner_types)
-        if no_optional or (self.required and not self.nullable):
-            return f"Union[{inner_prop_string}]"
-        return f"Optional[Union[{inner_prop_string}]]"
+        return type_string(no_optional, self, inner_prop_string, is_outer_union=True)
+
+    def get_query_string(self, no_optional: bool = False) -> str:
+        """
+        Get a string representation of type that should be used when the property is represented in a query string.
+        """
+        inner_types = [p.get_query_string() for p in self.inner_properties]
+        inner_prop_string = ", ".join(inner_types)
+        return query_string(no_optional, self, inner_prop_string, is_outer_union=True)
 
     def get_imports(self, *, prefix: str) -> Set[str]:
         """
@@ -328,10 +363,13 @@ def get_enum(name: str) -> Optional["EnumProperty"]:
 
     def get_type_string(self, no_optional: bool = False) -> str:
         """ Get a string representation of type that should be used when declaring this property """
+        return type_string(no_optional, self, self.reference.class_name)
 
-        if no_optional or (self.required and not self.nullable):
-            return self.reference.class_name
-        return f"Optional[{self.reference.class_name}]"
+    def get_query_string(self, no_optional: bool = False) -> str:
+        """
+        Get a string representation of type that should be used when the property is represented in a query string.
+        """
+        return query_string(no_optional, self, self.reference.class_name)
 
     def get_imports(self, *, prefix: str) -> Set[str]:
         """
@@ -390,9 +428,13 @@ def template(self) -> str:  # type: ignore
 
     def get_type_string(self, no_optional: bool = False) -> str:
         """ Get a string representation of type that should be used when declaring this property """
-        if no_optional or (self.required and not self.nullable):
-            return self.reference.class_name
-        return f"Optional[{self.reference.class_name}]"
+        return type_string(no_optional, self, self.reference.class_name)
+
+    def get_query_string(self, no_optional: bool = False) -> str:
+        """
+        Get a string representation of type that should be used when the property is represented in a query string.
+        """
+        return query_string(no_optional, self, self.reference.class_name)
 
     def get_imports(self, *, prefix: str) -> Set[str]:
         """
@@ -575,3 +617,27 @@ def property_from_data(
         return _property_from_data(name=name, required=required, data=data)
     except ValidationError:
         return PropertyError(detail="Failed to validate default value", data=data)
+
+
+def type_string(no_optional: bool, prop: Property, inner_type_string: str, is_outer_union: bool = False) -> str:
+    if no_optional or (prop.required and not prop.nullable):
+        if is_outer_union:
+            return f"Union[{inner_type_string}]"
+        return inner_type_string
+    elif prop.nullable and prop.required:
+        if is_outer_union:
+            return f"Optional[Union[{inner_type_string}]]"
+        return f"Optional[{inner_type_string}]"
+    elif not prop.nullable and not prop.required:
+        return f"Union[Unset, None, {inner_type_string}]"
+    return f"Union[Unset, {inner_type_string}]"
+
+
+def query_string(no_optional: bool, prop: Property, inner_type_string: str, is_outer_union: bool = False) -> str:
+    if no_optional or (prop.required and not prop.nullable):
+        if is_outer_union:
+            return f"Union[{inner_type_string}]"
+        return inner_type_string
+    if is_outer_union:
+        return f"Optional[Union[{inner_type_string}]]"
+    return f"Optional[{inner_type_string}]"

openapi_python_client/templates/endpoint_macros.pyi

@@ -80,7 +80,7 @@ client: Client,
 {% endif %}
 {# path parameters #}
 {% for parameter in endpoint.path_parameters %}
-{{ parameter.to_string() }},
+{{ parameter.to_query_string() }},
 {% endfor %}
 {# Form data if any #}
 {% if endpoint.form_body_reference %}
@@ -96,10 +96,10 @@ json_body: {{ endpoint.json_body.get_type_string() }},
 {% endif %}
 {# query parameters #}
 {% for parameter in endpoint.query_parameters %}
-{{ parameter.to_string() }},
+{{ parameter.to_query_string() }},
 {% endfor %}
 {% for parameter in endpoint.header_parameters %}
-{{ parameter.to_string() }},
+{{ parameter.to_query_string() }},
 {% endfor %}
 {% endmacro %}
 

openapi_python_client/templates/model.pyi

@@ -24,11 +24,17 @@ class {{ model.reference.class_name }}:
         {% endif %}
         {% endfor %}
 
-        return {
-            {% for property in model.required_properties + model.optional_properties %}
-            "{{ property.name }}": {{ property.python_name }},
-            {% endfor %}
-        }
+        properties: Dict[str, Any] = dict()
+
+        {% for property in model.required_properties + model.optional_properties %}
+        {% if not property.required %}
+        if {{property.python_name}} != UNSET:
+            properties["{{ property.name }}"] = {{ property.python_name }}
+        {% else %}
+        properties["{{ property.name }}"] = {{ property.python_name }}
+        {% endif %}
+        {% endfor %}
+        return properties
 
     @staticmethod
     def from_dict(d: Dict[str, Any]) -> "{{ model.reference.class_name }}":

openapi_python_client/templates/types.py

@@ -1,8 +1,11 @@
 """ Contains some shared types for properties """
-from typing import BinaryIO, Generic, MutableMapping, Optional, TextIO, Tuple, TypeVar, Union
+from typing import BinaryIO, Generic, MutableMapping, NewType, Optional, TextIO, Tuple, TypeVar, Union
 
 import attr
 
+Unset = NewType("Unset", object)
+UNSET: Unset = object()
+
 
 @attr.s(auto_attribs=True)
 class File:

tests/test_openapi_parser/test_properties.py

@@ -24,13 +24,23 @@ def test_get_type_string(self):
         p = Property(name="test", required=True, default=None, nullable=False)
         p._type_string = "TestType"
 
+        # Nullable = False, Required = True
         assert p.get_type_string() == "TestType"
+
+        # Nullable = False, Required = False, No Default
+        p.nullable = False
         p.required = False
-        assert p.get_type_string() == "Optional[TestType]"
+        assert p.get_type_string() == "Union[Unset, None, TestType]"
         assert p.get_type_string(True) == "TestType"
 
+        # Nullable = True, Required = False, No Default
         p.required = False
         p.nullable = True
+        assert p.get_type_string() == "Union[Unset, TestType]"
+
+        # Nullable = True, Required = True, No Default
+        p.required = True
+        p.nullable = True
         assert p.get_type_string() == "Optional[TestType]"
 
     def test_to_string(self, mocker):
@@ -42,12 +52,33 @@ def test_to_string(self, mocker):
         get_type_string = mocker.patch.object(p, "get_type_string")
 
         assert p.to_string() == f"{snake_case(name)}: {get_type_string()}"
-        p.required = False
-        assert p.to_string() == f"{snake_case(name)}: {get_type_string()} = None"
+        p.required = True
+        p.nullable = True
+        assert p.to_string() == f"{snake_case(name)}: {get_type_string()}"
 
         p.default = "TEST"
         assert p.to_string() == f"{snake_case(name)}: {get_type_string()} = TEST"
 
+        p.nullable = False
+        p.required = False
+        p.default = None
+        assert p.to_string() == f"{snake_case(name)}: {get_type_string()} = UNSET"
+
+    def test_to_query_string(self, mocker):
+        from openapi_python_client.parser.properties import Property
+
+        name = mocker.MagicMock()
+        snake_case = mocker.patch("openapi_python_client.utils.snake_case")
+        p = Property(name=name, required=True, default=None, nullable=False)
+        get_query_string = mocker.patch.object(p, "get_query_string")
+
+        assert p.to_query_string() == f"{snake_case(name)}: {get_query_string()}"
+        p.required = False
+        assert p.to_query_string() == f"{snake_case(name)}: {get_query_string()} = None"
+
+        p.default = "TEST"
+        assert p.to_query_string() == f"{snake_case(name)}: {get_query_string()} = TEST"
+
     def test_get_imports(self, mocker):
         from openapi_python_client.parser.properties import Property
 
@@ -56,9 +87,16 @@ def test_get_imports(self, mocker):
         p = Property(name=name, required=True, default=None, nullable=False)
         assert p.get_imports(prefix="") == set()
 
-        p.required = False
+        p.nullable = True
         assert p.get_imports(prefix="") == {"from typing import Optional"}
 
+        p.required = False
+        assert p.get_imports(prefix="..") == {
+            "from typing import Union",
+            "from ..types import Unset",
+            "from ..types import UNSET",
+        }
+
     def test__validate_default(self):
         from openapi_python_client.parser.properties import Property