diff --git a/.changesets/1792775030-0ae07c4d.yaml b/.changesets/1792775030-0ae07c4d.yaml new file mode 100644 index 000000000..03b2239ab --- /dev/null +++ b/.changesets/1792775030-0ae07c4d.yaml @@ -0,0 +1,10 @@ +id: 1792775030-0ae07c4d +features: + - core +targets: + - pythonv2 +type: fix +bump: patch +description: leave fields filtered by include, exclude, exclude_unset or exclude_defaults out of model dumps +author: 2ynn +date: "2026-10-23" diff --git a/.changesets/1792778028-be2ce88f.yaml b/.changesets/1792778028-be2ce88f.yaml new file mode 100644 index 000000000..729ea7983 --- /dev/null +++ b/.changesets/1792778028-be2ce88f.yaml @@ -0,0 +1,10 @@ +id: 1792778028-be2ce88f +features: + - core +targets: + - pythonv2 +type: fix +bump: patch +description: keep the value of fields with an empty API name in model dumps +author: 2ynn +date: "2026-10-23" diff --git a/pkg/generate/snapshots/base64_input_mode_shared_order_py_test.go b/pkg/generate/snapshots/base64_input_mode_shared_order_py_test.go index ae75d37f7..23cc0dacf 100644 --- a/pkg/generate/snapshots/base64_input_mode_shared_order_py_test.go +++ b/pkg/generate/snapshots/base64_input_mode_shared_order_py_test.go @@ -154,6 +154,8 @@ from base64order.types import ( Base64FileInput, BaseModel, UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, ) from pydantic import model_serializer from typing import Optional, Union @@ -168,13 +170,19 @@ class Gadget2(BaseModel): image: Optional[Base64EncodedString] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["image"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -214,6 +222,8 @@ from base64order.types import ( Base64FileInput, BaseModel, UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, ) from pydantic import model_serializer from typing import Optional, Union @@ -231,13 +241,19 @@ class Thumbnail(BaseModel): image: Optional[Base64EncodedString] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["label", "image"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -260,6 +276,8 @@ from base64order.types import ( Base64FileInput, BaseModel, UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, ) import pydantic from pydantic import model_serializer @@ -312,15 +330,21 @@ class Widget(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( ["id", "thumbnail", "images", "imagesByName", "imageOrIndex", "imageOrFlag"] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/pkg/generate/snapshots/field_alias_model_rebuild_py_test.go b/pkg/generate/snapshots/field_alias_model_rebuild_py_test.go index 76ec77f63..6c3ab33eb 100644 --- a/pkg/generate/snapshots/field_alias_model_rebuild_py_test.go +++ b/pkg/generate/snapshots/field_alias_model_rebuild_py_test.go @@ -76,7 +76,12 @@ import pydantic from pydantic import model_serializer from typing import Optional from typing_extensions import Annotated, NotRequired, TypedDict -from userapi.types import BaseModel, UNSET_SENTINEL +from userapi.types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) class UserProfileTypedDict(TypedDict): @@ -96,13 +101,19 @@ class UserProfile(BaseModel): phone_number: Annotated[Optional[str], pydantic.Field(alias="phoneNumber")] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["phoneNumber"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/pkg/generate/snapshots/namespaces/model_namespace_sanitization_test.go b/pkg/generate/snapshots/namespaces/model_namespace_sanitization_test.go index e8e0d1297..978e09c0c 100644 --- a/pkg/generate/snapshots/namespaces/model_namespace_sanitization_test.go +++ b/pkg/generate/snapshots/namespaces/model_namespace_sanitization_test.go @@ -142,7 +142,12 @@ func TestSnapPyModelNamespaceSanitization(t *testing.T) { from __future__ import annotations from pydantic import model_serializer -from test.types import BaseModel, UNSET_SENTINEL +from test.types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -155,13 +160,19 @@ class Widget(BaseModel): name: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["name"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/pkg/generate/snapshots/serialize_as_any_discriminated_union_py_test.go b/pkg/generate/snapshots/serialize_as_any_discriminated_union_py_test.go index 6ed6b3197..57af9e102 100644 --- a/pkg/generate/snapshots/serialize_as_any_discriminated_union_py_test.go +++ b/pkg/generate/snapshots/serialize_as_any_discriminated_union_py_test.go @@ -105,7 +105,15 @@ from .alphaconfig import AlphaConfig, AlphaConfigTypedDict from .betaconfig import BetaConfig, BetaConfigTypedDict import pydantic from pydantic import Field, SerializeAsAny, model_serializer -from sdk.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL +from sdk.types import ( + BaseModel, + Nullable, + OptionalNullable, + UNSET, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from typing import Union from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict @@ -132,14 +140,20 @@ class Body(BaseModel): ] = UNSET @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["executionConfig"]) nullable_fields = set(["executionConfig"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) is_nullable_and_explicitly_set = ( k in nullable_fields diff --git a/pkg/generate/snapshots/split_model_py_test.go b/pkg/generate/snapshots/split_model_py_test.go index 7b134d7d5..a63e5574f 100644 --- a/pkg/generate/snapshots/split_model_py_test.go +++ b/pkg/generate/snapshots/split_model_py_test.go @@ -160,7 +160,12 @@ from .field_005 import ( Field005TypedDict, ) from pydantic import model_serializer -from splittest.types import BaseModel, UNSET_SENTINEL +from splittest.types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -188,6 +193,9 @@ class BigModel(BaseModel): field_005: Optional[Field005] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -199,11 +207,14 @@ class BigModel(BaseModel): "field_005", ] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -220,7 +231,12 @@ class BigModel(BaseModel): from __future__ import annotations from pydantic import model_serializer -from splittest.types import BaseModel, UNSET_SENTINEL +from splittest.types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -233,13 +249,19 @@ class Field000(BaseModel): value: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["value"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -257,13 +279,19 @@ class Field001(BaseModel): value: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["value"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -281,13 +309,19 @@ class Field002(BaseModel): value: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["value"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -304,7 +338,12 @@ class Field002(BaseModel): from __future__ import annotations from pydantic import model_serializer -from splittest.types import BaseModel, UNSET_SENTINEL +from splittest.types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -317,13 +356,19 @@ class Field003(BaseModel): value: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["value"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -341,13 +386,19 @@ class Field004(BaseModel): value: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["value"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -365,13 +416,19 @@ class Field005(BaseModel): value: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["value"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/templates/perms.go b/templates/perms.go index 29a0436db..89399c940 100644 --- a/templates/perms.go +++ b/templates/perms.go @@ -1689,6 +1689,7 @@ var fileMode = map[string]fs.FileMode{ "templates/pythonv2/tests/primary/test_helpers.py": 0o644, "templates/pythonv2/tests/primary/test_hooks_additional.py.stmpl": 0o644, "templates/pythonv2/tests/primary/test_jsonl_streaming_additional.py": 0o644, + "templates/pythonv2/tests/primary/test_model_dump_filters_additional.py": 0o644, "templates/pythonv2/tests/primary/test_model_serializer_alias.py": 0o644, "templates/pythonv2/tests/primary/test_open_discriminated_union.py": 0o644, "templates/pythonv2/tests/primary/test_open_enum_union_discrimination.py": 0o644, diff --git a/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/__init__.py b/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/__init__.py index ea21969b1..775f3caae 100644 --- a/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/__init__.py +++ b/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/__init__.py @@ -1,22 +1,26 @@ from .base64fileinput import Base64EncodedString, Base64FileInput from .basemodel import ( BaseModel, + current_exclude_none, Nullable, OptionalNullable, UnrecognizedInt, UnrecognizedStr, UNSET, UNSET_SENTINEL, + serialize_with_info, ) __all__ = [ "Base64EncodedString", "Base64FileInput", "BaseModel", + "current_exclude_none", "Nullable", "OptionalNullable", "UnrecognizedInt", "UnrecognizedStr", "UNSET", "UNSET_SENTINEL", + "serialize_with_info", ] diff --git a/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/basemodel.py b/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/basemodel.py index 23751499a..a09f3923c 100644 --- a/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/basemodel.py +++ b/templates/templates/pythonv2/auxiliary/{{getSourcePath}}/types/basemodel.py @@ -1,7 +1,8 @@ +from contextvars import ContextVar from pydantic import ConfigDict, model_serializer from pydantic import BaseModel as PydanticBaseModel from pydantic_core import PydanticSerializationUnexpectedValue, core_schema -from typing import TYPE_CHECKING, Any, Literal, Optional, Type, TypeVar, Union +from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Type, TypeVar, Union from typing_extensions import TypeAliasType, TypeAlias @@ -35,6 +36,24 @@ def __bool__(self) -> Literal[False]: ) +_exclude_none: ContextVar[Optional[bool]] = ContextVar("exclude_none", default=None) + + +def serialize_with_info( + serialize: Callable[[Any], Any], handler: Any, info: core_schema.SerializationInfo +) -> Any: + token = _exclude_none.set(info.exclude_none) + try: + return serialize(handler) + finally: + _exclude_none.reset(token) + + +def current_exclude_none() -> Optional[bool]: + """Return the exclude_none option of the enclosing serialize_with_info call, or None outside of one.""" + return _exclude_none.get() + + def _unrecognized_serialization(cls: Type[Union[str, int]]) -> core_schema.PlainSerializerFunctionSerSchema: def serialize(value: Any, info: core_schema.SerializationInfo) -> Any: # Decline other values so union serialization tries the remaining members diff --git a/templates/templates/pythonv2/model.py.stmpl b/templates/templates/pythonv2/model.py.stmpl index c4d42bc95..8ea1ecdc8 100644 --- a/templates/templates/pythonv2/model.py.stmpl +++ b/templates/templates/pythonv2/model.py.stmpl @@ -75,8 +75,14 @@ class {{$className}}(BaseModel): {{- if or $hasNullableField $hasOptionalField}} {{- addImport "pydantic" "model_serializer"}} {{- addImport "types" "UNSET_SENTINEL" true}} + {{- addImport "types" "serialize_with_info" true}} + {{- addImport "types" "current_exclude_none" true}} + {{- $serializeMethodName := sanitizeSerializeMethodName $type}} @model_serializer(mode="wrap") - def {{sanitizeSerializeMethodName $type}}(self, handler): + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.{{$serializeMethodName}}, handler, info) + + def {{$serializeMethodName}}(self, handler): {{- $nullDefaultFields := templateNullDefaultFieldList $type}} {{- $hasNullDefaultField := gt (len $nullDefaultFields) 0}} {{- if $hasOptionalField}} @@ -88,11 +94,14 @@ class {{$className}}(BaseModel): {{- end}} {{- end}} {{- end}} + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) {{- if $hasAdditionalProperties}} serialized.pop(k, serialized.pop(n, None)) diff --git a/templates/templates/pythonv2/tests/primary/test_model_dump_filters_additional.py b/templates/templates/pythonv2/tests/primary/test_model_dump_filters_additional.py new file mode 100644 index 000000000..a6aa8ca22 --- /dev/null +++ b/templates/templates/pythonv2/tests/primary/test_model_dump_filters_additional.py @@ -0,0 +1,232 @@ +import json +from typing import List, Optional + +from pydantic import TypeAdapter, model_serializer + +from openapi import utils +from openapi.models import errors, shared +from openapi.types import Nullable + + +def filtered_fields(display_name="name", **kwargs): + return shared.FilteredFields( + display_name=display_name, required_nullable=None, **kwargs + ) + + +class TestModelDumpFilters: + def test_exclude_leaves_required_field_out(self): + model = filtered_fields() + + assert "displayName" not in model.model_dump(exclude={"display_name"}) + assert "displayName" not in model.model_dump( + by_alias=True, exclude={"display_name"} + ) + assert "displayName" not in json.loads( + model.model_dump_json(exclude={"display_name"}) + ) + + def test_include_leaves_other_fields_out(self): + model = filtered_fields(optional_nullable="x") + + assert model.model_dump(include={"optional_nullable"}) == { + "optionalNullable": "x" + } + assert model.model_dump(by_alias=True, include={"display_name"}) == { + "displayName": "name" + } + + def test_exclude_unset_leaves_unset_fields_out(self): + model = filtered_fields() + + assert model.model_dump(exclude_unset=True) == { + "displayName": "name", + "requiredNullable": None, + } + + def test_exclude_defaults_leaves_default_fields_out(self): + model = filtered_fields(with_default="other") + + assert model.model_dump(exclude_defaults=True) == { + "displayName": "name", + "requiredNullable": None, + "withDefault": "other", + } + + def test_exclude_none_still_writes_back_excluded_required_field(self): + model = filtered_fields() + + dumped = model.model_dump(exclude={"display_name"}, exclude_none=True) + + assert dumped["displayName"] is None + + def test_nested_exclude(self): + model = filtered_fields( + child=filtered_fields("child"), children=[filtered_fields("item")] + ) + + dumped = model.model_dump( + exclude={ + "child": {"display_name"}, + "children": {"__all__": {"display_name"}}, + } + ) + + assert dumped["displayName"] == "name" + assert "displayName" not in dumped["child"] + assert "displayName" not in dumped["children"][0] + + +class TestNestedDefaultDumps: + def test_nested_models_keep_api_names(self): + model = filtered_fields( + child=filtered_fields("child"), children=[filtered_fields("item")] + ) + + for dumped in (model.model_dump(), json.loads(model.model_dump_json())): + assert dumped["child"]["displayName"] == "child" + assert dumped["child"]["requiredNullable"] is None + assert dumped["children"][0]["displayName"] == "item" + + def test_model_lists_keep_api_names(self): + adapter = TypeAdapter(List[shared.FilteredFields]) + + dumped = adapter.dump_python([filtered_fields("first")]) + + assert dumped[0]["displayName"] == "first" + assert dumped[0]["requiredNullable"] is None + + +class TestRequestBodies: + def test_explicit_nulls(self): + model = filtered_fields(optional_nullable=None) + + assert ( + utils.marshal_json(model, shared.FilteredFields) + == '{"displayName":"name","requiredNullable":null,"kind":"filtered","nullDefault":null,"optionalNullable":null,"withDefault":"fallback"}' + ) + + def test_required_nullable_null(self): + model = shared.PaginationCursorNullableLimitNextCursor( + next_cursor=None, results=["a"] + ) + + assert ( + utils.marshal_json(model, shared.PaginationCursorNullableLimitNextCursor) + == '{"next_cursor":null,"results":["a"]}' + ) + + def test_nested_nulls_and_api_names(self): + model = filtered_fields( + child=filtered_fields("child", optional_nullable=None), + children=[filtered_fields("item")], + ) + + assert json.loads(utils.marshal_json(model, shared.FilteredFields)) == { + "displayName": "name", + "requiredNullable": None, + "child": { + "displayName": "child", + "requiredNullable": None, + "kind": "filtered", + "nullDefault": None, + "optionalNullable": None, + "withDefault": "fallback", + }, + "children": [ + { + "displayName": "item", + "requiredNullable": None, + "kind": "filtered", + "nullDefault": None, + "withDefault": "fallback", + } + ], + "kind": "filtered", + "nullDefault": None, + "withDefault": "fallback", + } + + def test_null_additional_property_omitted(self): + model = shared.ObjWithAnyAdditionalProperties.model_validate( + {"normalField": "x", "future": None} + ) + + assert ( + utils.marshal_json(model, shared.ObjWithAnyAdditionalProperties) + == '{"normalField":"x"}' + ) + + def test_additional_property_under_python_name(self): + model = shared.ObjWithAnyAdditionalProperties.model_validate( + {"normalField": None, "normal_field": "extra"} + ) + other = shared.FilteredFieldsWithAdditionalProperties.model_validate( + {"displayName": None, "display_name": "extra"} + ) + + assert ( + utils.marshal_json(model, shared.ObjWithAnyAdditionalProperties) + == '{"normalField":"extra"}' + ) + assert ( + utils.marshal_json(other, shared.FilteredFieldsWithAdditionalProperties) + == '{"displayName":"extra"}' + ) + + def test_top_level_none(self): + assert utils.marshal_json(None, Optional[shared.FilteredFields]) == "" + assert utils.marshal_json(None, Nullable[shared.FilteredFields]) == "null" + + +class TestErrorData: + def test_plain_filtering(self): + data = errors.FilteredFieldsErrorData() + + assert data.model_dump() == {"detail": None} + assert data.model_dump(exclude_none=True) == {} + assert data.model_dump(exclude_unset=True) == {} + + def test_nested_model_honours_exclude(self): + data = errors.FilteredFieldsErrorData(detail=filtered_fields()) + + dumped = data.model_dump(exclude={"detail": {"display_name"}}) + + assert "displayName" not in dumped["detail"] + assert dumped["detail"]["requiredNullable"] is None + + +class TestEmptyAlias: + def test_value_kept_under_empty_api_name(self): + model = shared.BinaryString(file_name="a", content=b"x") + + assert model.model_dump(by_alias=True)[""] == b"x" + assert model.model_dump()[""] == b"x" + assert "content" not in model.model_dump(by_alias=True) + assert "" not in model.model_dump(by_alias=True, exclude={"content"}) + + +class TestSerializerOverrides: + def test_decorated_override_calls_parent(self): + class Custom(shared.FilteredFields): + @model_serializer(mode="wrap") + def serialize_model(self, handler): + return {**super().serialize_model(handler), "custom": True} + + dumped = Custom(display_name="name", required_nullable=None).model_dump() + + assert dumped["displayName"] == "name" + assert dumped["requiredNullable"] is None + assert dumped["custom"] is True + + def test_undecorated_override_keeps_filters(self): + class Custom(shared.FilteredFields): + def serialize_model(self, handler): + return {**super().serialize_model(handler), "custom": True} + + dumped = Custom(display_name="name", required_nullable=None).model_dump( + exclude={"display_name"} + ) + + assert "displayName" not in dumped + assert dumped["custom"] is True diff --git a/tests/specs/fragments/primary/model-dump-filters.yaml b/tests/specs/fragments/primary/model-dump-filters.yaml new file mode 100644 index 000000000..ab22fca0a --- /dev/null +++ b/tests/specs/fragments/primary/model-dump-filters.yaml @@ -0,0 +1,86 @@ +openapi: 3.1.0 +security: + - apiKeyAuth: [] + - oauth2: [] + - clientCredentials: [read, write] + - customSchemeAppId: [] + - basicHttp: [] + - accessToken: [] + - {} +paths: + /errors/model-dump-filters: + get: + operationId: getFilteredFieldsError + description: >- + Declares an error response whose body nests an object schema with + required, nullable, defaulted and const properties, so that serializing + the error body with fields filtered out can be checked against the same + rules as ordinary models. + tags: + - errors + responses: + "200": + description: OK + "400": + description: Error whose body nests FilteredFields + content: + application/json: + schema: + $ref: "#/components/schemas/FilteredFieldsError" +components: + schemas: + FilteredFields: + x-speakeasy-include: true + type: object + description: >- + Object with a required renamed property, required and optional nullable + properties, a property with a default, a nullable property with a null + default, a const property, and nested copies of itself as a property and + as array items. Fields that a serializer is asked to leave out (by + explicit selection, because they were never set, or because they hold + their default) must stay out of the output, while request bodies keep + sending required and explicitly set nullable properties as null. + required: + - displayName + - requiredNullable + - kind + properties: + displayName: + type: string + requiredNullable: + type: [string, "null"] + optionalNullable: + type: [string, "null"] + withDefault: + type: string + default: fallback + nullDefault: + type: [string, "null"] + default: null + kind: + type: string + const: filtered + child: + $ref: "#/components/schemas/FilteredFields" + children: + type: array + items: + $ref: "#/components/schemas/FilteredFields" + FilteredFieldsWithAdditionalProperties: + x-speakeasy-include: true + type: object + description: >- + Object with an optional nullable renamed property and untyped + additional properties, for request bodies that hold both the renamed + property and an additional property keyed by the property's other + spelling. + properties: + displayName: + type: [string, "null"] + additionalProperties: true + FilteredFieldsError: + type: object + description: Error body that nests FilteredFields. + properties: + detail: + $ref: "#/components/schemas/FilteredFields" diff --git a/zSDKs/sdk-pythonv2/.speakeasy/gen.lock b/zSDKs/sdk-pythonv2/.speakeasy/gen.lock index e8f70e907..006701500 100644 --- a/zSDKs/sdk-pythonv2/.speakeasy/gen.lock +++ b/zSDKs/sdk-pythonv2/.speakeasy/gen.lock @@ -502,19 +502,19 @@ trackedFiles: src/speakeasy/new_openapi/models/_operation_with_leading_and_trailing_underscores_op.py: last_write_checksum: sha1:9da7c78f1847e53efbd5892794ba082c856ccc88 src/speakeasy/new_openapi/models/aloof.py: - last_write_checksum: sha1:35e39e540a3a978d4566d3cdbddfe45719802d27 + last_write_checksum: sha1:7d5c2f9f93ff0d2eaccf19e894805a036d0e4644 src/speakeasy/new_openapi/models/approvalconfig.py: last_write_checksum: sha1:7412b9518b49bedad8b8965bd94e907ede790c97 src/speakeasy/new_openapi/models/assetimageblock.py: - last_write_checksum: sha1:d52a5d536ad6d67e26a289043c15616a88a13cb3 + last_write_checksum: sha1:3e7482f00de1249646d0cb5880b955eb5d99f532 src/speakeasy/new_openapi/models/assetnotestep.py: - last_write_checksum: sha1:d4de19b9c876d034d0b654ff965151f36a5dd0fa + last_write_checksum: sha1:b1f7c2b50aa5e51315f1bf780167d8d7257c1e5d src/speakeasy/new_openapi/models/assetoutputstep.py: - last_write_checksum: sha1:e11a9e1fda2956b99efb96c28d8891f361ff8598 + last_write_checksum: sha1:a3427e648ce9b6da7268219944a6bdb592c23dab src/speakeasy/new_openapi/models/assetresult.py: - last_write_checksum: sha1:053e5b48bbea5b9b8ad13654374a9ca87c6b9b25 + last_write_checksum: sha1:4a83b820c5e97289860c50fe29beaa71400e3edb src/speakeasy/new_openapi/models/assettextblock.py: - last_write_checksum: sha1:67d4d7c51ffd5b4dff26f51060181a0e7440d863 + last_write_checksum: sha1:f12c2b6c140b931ae6eadcce83f71f3e723b6a5a src/speakeasy/new_openapi/models/authop.py: last_write_checksum: sha1:7ccdc07da84bfe62e2bd395cc016d72aabc44b2e src/speakeasy/new_openapi/models/badrequestresponse_error.py: @@ -528,37 +528,37 @@ trackedFiles: src/speakeasy/new_openapi/models/bar/pet.py: last_write_checksum: sha1:c8a5a8ed46d1c0db53ff55b0a75f68e003d79767 src/speakeasy/new_openapi/models/bar/petowner.py: - last_write_checksum: sha1:e52f159a5d74ec77c97dc984757acf7d40f7adf9 + last_write_checksum: sha1:c7477a97f9e07544f2caa179e268ca66b7621e26 src/speakeasy/new_openapi/models/bar/petstatus.py: last_write_checksum: sha1:37b688c141361461830c1dfe2933997fd6a00951 src/speakeasy/new_openapi/models/bar/vehicle.py: last_write_checksum: sha1:5c6366c72438154f3adff350cef5c7da577cc2f6 src/speakeasy/new_openapi/models/baseuser.py: - last_write_checksum: sha1:e83b85798ea0a31f62b1009929b8962a0251b387 + last_write_checksum: sha1:9c43fc13b1c56d3d71fec599c44feaedd8c3a6b2 src/speakeasy/new_openapi/models/baz/__init__.py: last_write_checksum: sha1:fbb65d90be5fef910378ae7ea0d3dd972ac7752e src/speakeasy/new_openapi/models/baz/namespaced.py: - last_write_checksum: sha1:89128b0e925b13cf7da3ec70559eb66630053dba + last_write_checksum: sha1:be1a641b3ed6141607dc82d6230dca0a2b5d62b2 src/speakeasy/new_openapi/models/baz/pet.py: - last_write_checksum: sha1:be6a33736e75bd3e6da798c7b55551096f40bb1a + last_write_checksum: sha1:b4f8f9c05ef7b80677e41efaed107f004068113a src/speakeasy/new_openapi/models/binaryandstringuploadop.py: - last_write_checksum: sha1:d28b000594da626cd5e2017fed2abb503c6a693b + last_write_checksum: sha1:b5f0ff8e0a8ee3d4cfefbac3968814e4ef37ddd6 src/speakeasy/new_openapi/models/boole.py: - last_write_checksum: sha1:b534197e01155ba069dbf0d49ac6c8114f025c8f + last_write_checksum: sha1:d0bece48dee869be0295c136baa8a39241b19e28 src/speakeasy/new_openapi/models/chatagentrequest.py: - last_write_checksum: sha1:7665bd46b5f4b4c167c5bca03c3e70487bee1731 + last_write_checksum: sha1:fc3497158390367bb7980cfa28f1cb9a3c84b26a src/speakeasy/new_openapi/models/chatmodelrequest.py: - last_write_checksum: sha1:ac61ed44911dc0f545f12a14d814c77124804cac + last_write_checksum: sha1:ada3acf0366b89d5372844d819c9a2878c37b627 src/speakeasy/new_openapi/models/chatop.py: - last_write_checksum: sha1:e4e04fd79f37eef3cc957d083d3f965166a4ea3a + last_write_checksum: sha1:1a7c2d7c150bcf4627385d1248b64e4f0e8f77b0 src/speakeasy/new_openapi/models/circle.py: - last_write_checksum: sha1:6437e8c90b8f9a8e2a953508aec5d0f4be2afc93 + last_write_checksum: sha1:59fecfeb6fcae929a0b3008842eed775e6aee9ac src/speakeasy/new_openapi/models/circularunion.py: last_write_checksum: sha1:82a4d2ffc8dbd0662e0649763a65bdc7e31478e7 src/speakeasy/new_openapi/models/color.py: last_write_checksum: sha1:3cbf117fac27321e49b2989a82adac7105121b82 src/speakeasy/new_openapi/models/createwithunionop.py: - last_write_checksum: sha1:e73a49dfb874d8527afb29b6526d2d741436956d + last_write_checksum: sha1:852a860989bb94f6da7555642a184907fbc54c2b src/speakeasy/new_openapi/models/deleteuserop.py: last_write_checksum: sha1:757b8d3047b3ae8383ac982267c7a3d6456a338c src/speakeasy/new_openapi/models/deprecated1op.py: @@ -576,49 +576,49 @@ trackedFiles: src/speakeasy/new_openapi/models/escalation.py: last_write_checksum: sha1:d6e4cb3baf6dbdc96219e96ce57a92f11c1b582b src/speakeasy/new_openapi/models/exhaustiveobject.py: - last_write_checksum: sha1:4ca50d9c344cbde4fbf5680eb355abd8ef65c035 + last_write_checksum: sha1:62b2e4ee73fcff9281b549102651f9d6a2fd2ceb src/speakeasy/new_openapi/models/failedresponse_error.py: last_write_checksum: sha1:29230b2bcd0614d4ccf00b8b19e9660a7bdda77e src/speakeasy/new_openapi/models/file.py: - last_write_checksum: sha1:29702f9a14288ca324941ae38aa0bca47692b30d + last_write_checksum: sha1:77bc34d9843b7ae79a8d867bbed4f59ac330aa54 src/speakeasy/new_openapi/models/foo/__init__.py: last_write_checksum: sha1:c85b4cda9e10fac134bf17e81db393b79d9d79b7 src/speakeasy/new_openapi/models/foo/animal.py: last_write_checksum: sha1:1e9b5c9e735c19a027e5d90564cba3b6216ad3f7 src/speakeasy/new_openapi/models/foo/cat.py: - last_write_checksum: sha1:6e7022c0497ec6b428afa5ef849faa3fa2488793 + last_write_checksum: sha1:be5a4ca4c749cea9648c7c23a7f1c54d9b2ccbaf src/speakeasy/new_openapi/models/foo/dog.py: - last_write_checksum: sha1:143c62d509fcd2214f311f8634cf20d55d11b5d8 + last_write_checksum: sha1:936f47a96e8305d6e2675a8d0fd63f8d2c7a4757 src/speakeasy/new_openapi/models/foo/organization.py: - last_write_checksum: sha1:7e66ee1c2ab4e069720cddeb307d4154f2f62d56 + last_write_checksum: sha1:7351aebee79f474fb1b06c7d90b16229e2ac5c0c src/speakeasy/new_openapi/models/foo/pet.py: - last_write_checksum: sha1:51aed346b747dec49b9d6ebb537b15dd566a7304 + last_write_checksum: sha1:240c2ca9b4837191ebbc96a325c16387632f0225 src/speakeasy/new_openapi/models/foo/petowner.py: - last_write_checksum: sha1:cd0f740bd3c7f3e24c9394ea5752cdb622b6e889 + last_write_checksum: sha1:e15a7705b1b30855051539691fcf97139f3e413b src/speakeasy/new_openapi/models/foo/petspecies.py: last_write_checksum: sha1:a5df0b625565ecf78ea933a3f2af562386fba17a src/speakeasy/new_openapi/models/gender.py: last_write_checksum: sha1:e935cf4f6a56e1109e0c326a15d967644b2c8106 src/speakeasy/new_openapi/models/getassetop.py: - last_write_checksum: sha1:0442d66318c5b70bcc5ed666688da94c96f42be4 + last_write_checksum: sha1:44277245515c29448f58b8f59374ea9a58ab234f src/speakeasy/new_openapi/models/getduplicateexportcollisionop.py: - last_write_checksum: sha1:e5c1456c4b1fb71ce1bb3489464612b6d86697a9 + last_write_checksum: sha1:db815162db233e531630dfe5e4544d1532469f3c src/speakeasy/new_openapi/models/getemptyobjecterrorop.py: last_write_checksum: sha1:75c623983f8830cd7252d230ce6e0e9d4df6829e src/speakeasy/new_openapi/models/geterrorinunionop.py: last_write_checksum: sha1:356f45f833c96cce62bda024eacf978475a07d0c src/speakeasy/new_openapi/models/geterroronlyexampleop.py: - last_write_checksum: sha1:0cc84d395bcce4e330da237c70950c2ab0228a0c + last_write_checksum: sha1:2411418d8fa81b92d4d6d9a57babf87b6b40b9a7 src/speakeasy/new_openapi/models/getfullyflattenedrequestop.py: - last_write_checksum: sha1:7ba1e287cb17cb2da60899b9ff01a4c6f9432d83 + last_write_checksum: sha1:3aa6f3ee594ca9afad7d0b4d09f9aeb9243fedea src/speakeasy/new_openapi/models/getpetownersop.py: last_write_checksum: sha1:9b7829885bcdbb78f372af13245e3c1b29d49ae5 src/speakeasy/new_openapi/models/getpolymorphismop.py: - last_write_checksum: sha1:e2d1112e233be966aa52d2edcb92886d0af916fd + last_write_checksum: sha1:a6045de4c5fce5ed40ea616b03dadedbeab70cb2 src/speakeasy/new_openapi/models/getpositionaldefaultop.py: last_write_checksum: sha1:72ca9dae3ea68f51322778f910fc1aa899be05b3 src/speakeasy/new_openapi/models/getrequestbodyflattenedawayop.py: - last_write_checksum: sha1:f83489f1b376ecf017b29a3a1dc7c6b3d7fbf040 + last_write_checksum: sha1:0d5473e179be890a71a193055a8ac515398c67a9 src/speakeasy/new_openapi/models/getunionerrorsop.py: last_write_checksum: sha1:0b4b09143c2133f9440983ce6297890124117b9f src/speakeasy/new_openapi/models/getuserop.py: @@ -626,17 +626,17 @@ trackedFiles: src/speakeasy/new_openapi/models/internal/__init__.py: last_write_checksum: sha1:fa00c646cfffc2553593346d80fbd5c7ddb4d9b5 src/speakeasy/new_openapi/models/internal/globals.py: - last_write_checksum: sha1:d83d5b7d6b07956aad0ab8b52203d8f09108cb6b + last_write_checksum: sha1:11c41d1841e6e10c3ad70bd708fb7e3ac1627c12 src/speakeasy/new_openapi/models/listtest1op.py: - last_write_checksum: sha1:cc70ac62847c4c5168b208405aafd6fee9b7a70a + last_write_checksum: sha1:2cca9f8fc68dbb6c209c0f6eb1766e5a7b70d0c6 src/speakeasy/new_openapi/models/loginop.py: last_write_checksum: sha1:468add7ca4aea76c9e1a7ccaa627b59c45fb3e70 src/speakeasy/new_openapi/models/mcppolicy.py: last_write_checksum: sha1:79b406c5b22b34cc7d9b42eed4d5763ed4dffb81 src/speakeasy/new_openapi/models/metadata.py: - last_write_checksum: sha1:928fb3c7da2cbfa0a7f3fe25a2b87811ff4527b0 + last_write_checksum: sha1:08aebfa97e52c1f3e396e93eec5700c9ddf9e3ec src/speakeasy/new_openapi/models/metadataany.py: - last_write_checksum: sha1:10e645df6416f193bcb1ea032b6d8fd34604ff83 + last_write_checksum: sha1:3119c8620b5f91e1de3c334f8ed9d90bc23a38c2 src/speakeasy/new_openapi/models/namespaceconflicttest.py: last_write_checksum: sha1:3c086e737bdd18289b7b56a14e9813070773cafa src/speakeasy/new_openapi/models/namespacetypestest.py: @@ -644,9 +644,9 @@ trackedFiles: src/speakeasy/new_openapi/models/no_response_error.py: last_write_checksum: sha1:7f326424a7d5ae1bcd5c89a0d6b3dbda9138942f src/speakeasy/new_openapi/models/objwithrenamedproperties.py: - last_write_checksum: sha1:2f84b8dffc356c937e3b32180163aa8712cb4dac + last_write_checksum: sha1:a1cb0a0e9f2b3b0ee3609973aa23bfa8403dabc0 src/speakeasy/new_openapi/models/oneofwithfactoredoutproperties.py: - last_write_checksum: sha1:e4e3e4d809ac36f7287983ae486961147d859f9c + last_write_checksum: sha1:cf82ca7c17376a48b597dc4d3cc4c7fc6d9ffa04 src/speakeasy/new_openapi/models/parenthesesinpathallowedop.py: last_write_checksum: sha1:ee19301a0804f599fa29c944f7bc86d3db6ebe19 src/speakeasy/new_openapi/models/paymentcreatedop.py: @@ -658,15 +658,15 @@ trackedFiles: src/speakeasy/new_openapi/models/postfileop.py: last_write_checksum: sha1:bc0eb2314695db796f69f04532d81dc3c606f963 src/speakeasy/new_openapi/models/postfilewithencodingop.py: - last_write_checksum: sha1:3d6a6bafb6adcf855ae6bd6f4b74f6b59d1f1a30 + last_write_checksum: sha1:7f67dddd29b57a33120d494d93c1c04b90f3f5c4 src/speakeasy/new_openapi/models/posttest2op.py: - last_write_checksum: sha1:ae6b813db75d86901e3781a093f5f54b1760f3fd + last_write_checksum: sha1:60bea245fd32613810e5097f6f67c03ba1941474 src/speakeasy/new_openapi/models/rectangle.py: - last_write_checksum: sha1:62a38bb81f6dbb64315353ac09f69830798e6dcc + last_write_checksum: sha1:b6a9e8d5cb586eabe77586a63a96060d969cb999 src/speakeasy/new_openapi/models/recursiveformfield.py: - last_write_checksum: sha1:01fdeb92f3b6bc3c6e7de7ced06c36c3a861891e + last_write_checksum: sha1:433873f8617d1251423cb37fdb26153b93fd3b62 src/speakeasy/new_openapi/models/renderassetop.py: - last_write_checksum: sha1:39bfa820d75a7a8f3492ff90fb8f013eca213e62 + last_write_checksum: sha1:7f91b58d0d30605b310ad1cea0f20218d858434a src/speakeasy/new_openapi/models/requesttimeouterror.py: last_write_checksum: sha1:c77b2803afb86e196db8e547bde9128effdc50a8 src/speakeasy/new_openapi/models/responsevalidationerror.py: @@ -678,11 +678,11 @@ trackedFiles: src/speakeasy/new_openapi/models/sdkerror.py: last_write_checksum: sha1:0f8bfdf0fadae51b100d3e3ca9e861c757cbbabc src/speakeasy/new_openapi/models/security.py: - last_write_checksum: sha1:4060364b8d8502f5b5711cb602a7708508d00cfd + last_write_checksum: sha1:64b7a508bc67ec5540f5d95cab4636612a2509e3 src/speakeasy/new_openapi/models/shape.py: last_write_checksum: sha1:efe7d67814c451101cdbf6e6a39c713096e68853 src/speakeasy/new_openapi/models/shaperequest.py: - last_write_checksum: sha1:2f066023fe01b1d30d09e19b589f566ae7f93f7c + last_write_checksum: sha1:b563e440470bc8de0bdaf9dbe33d8113a1d98d67 src/speakeasy/new_openapi/models/simpleobject.py: last_write_checksum: sha1:eddf0fd28390a97b1f5f2fd4ca813067fdf5c42a src/speakeasy/new_openapi/models/someunion.py: @@ -694,11 +694,11 @@ trackedFiles: src/speakeasy/new_openapi/models/taskresponse.py: last_write_checksum: sha1:5efbbd31fa80e1e17e8765f77ece3c04e5ddf68a src/speakeasy/new_openapi/models/templatebracestest.py: - last_write_checksum: sha1:83fe8c8d4f4617600f6bc7287a9d5a0394df6dd4 + last_write_checksum: sha1:a3c6a7940de5d91eca7035c053f8249957ecd969 src/speakeasy/new_openapi/models/test2request.py: - last_write_checksum: sha1:f6c1e519be3cbda2be87f3fe9f7c566c2d3dc905 + last_write_checksum: sha1:de50ce6bcc6fd6b3e8fd7efc86330d7a67116e0f src/speakeasy/new_openapi/models/test2response.py: - last_write_checksum: sha1:bcef408d9a1bdf0e231d048cf028b6e43a4de9a4 + last_write_checksum: sha1:6e5e54783658f8859c15ee23e039561fa7a52f66 src/speakeasy/new_openapi/models/test2response_error.py: last_write_checksum: sha1:77b07c54b21fc19d9a9e5b5e13430e8795ad9bc3 src/speakeasy/new_openapi/models/testendpointop.py: @@ -710,11 +710,11 @@ trackedFiles: src/speakeasy/new_openapi/models/updateuserop.py: last_write_checksum: sha1:6afb62851a48192e0d31b237389b364d681107fd src/speakeasy/new_openapi/models/user.py: - last_write_checksum: sha1:6eb0297ce97089c4af5321155ac948af668e40e8 + last_write_checksum: sha1:1d72f49732c8f7cb7e7611e9fd2ee05ee70b45ce src/speakeasy/new_openapi/models/validateop.py: - last_write_checksum: sha1:c7ca37971829305d16b5655075b08031a1206da9 + last_write_checksum: sha1:5ed40dabc7287602fee6d10293c13f439f98739c src/speakeasy/new_openapi/models/variantrecord.py: - last_write_checksum: sha1:7c239ed1798eb0d8749c0bf577390b3eafa40b0d + last_write_checksum: sha1:af782587820dc4e6c06e6ff138f8380d76a1ede8 src/speakeasy/new_openapi/namespacetests.py: last_write_checksum: sha1:e8dda8124b42827a2e415670fb668bc28372ffa4 src/speakeasy/new_openapi/obsolete.py: @@ -742,11 +742,11 @@ trackedFiles: src/speakeasy/new_openapi/testgroup.py: last_write_checksum: sha1:086431534cbb4def1de44a50b88c88f6f7b9954f src/speakeasy/new_openapi/types/__init__.py: - last_write_checksum: sha1:f9ad14217f832e74f594285960125add50324be9 + last_write_checksum: sha1:166eb50af851c4200ed67fe47c64b1d58b99ed72 src/speakeasy/new_openapi/types/base64fileinput.py: last_write_checksum: sha1:1522687ae3398374c35710cad993a6e82b5ab99d src/speakeasy/new_openapi/types/basemodel.py: - last_write_checksum: sha1:6295cc5750e00e0323902092f7e52549937b0b9c + last_write_checksum: sha1:ebe5d75bf430ed4b0c52cfbdda3e3cb9ba6c9c64 src/speakeasy/new_openapi/types_.py: last_write_checksum: sha1:05e36f6428f04b1ea7d2609aa55f3966868b58f0 src/speakeasy/new_openapi/utils/__init__.py: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/aloof.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/aloof.py index 7cf7381d0..e9e85f49a 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/aloof.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/aloof.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info import pydantic from pydantic import model_serializer from typing import Optional @@ -19,13 +19,19 @@ class Aloof(BaseModel): int_: Annotated[Optional[int], pydantic.Field(alias="int")] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["bool", "int"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetimageblock.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetimageblock.py index d005940b6..4f9862488 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetimageblock.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetimageblock.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import validate_const import pydantic from pydantic import model_serializer @@ -30,13 +30,19 @@ class AssetImageBlock(BaseModel): uri: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["data", "mime_type", "uri"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetnotestep.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetnotestep.py index 5536d6cc1..3459b7711 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetnotestep.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetnotestep.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import validate_const import pydantic from pydantic import model_serializer @@ -24,13 +24,19 @@ class AssetNoteStep(BaseModel): text: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["text"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetoutputstep.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetoutputstep.py index 995cfaa58..5639458c0 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetoutputstep.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetoutputstep.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import validate_const from ..utils.unions import parse_open_union from .assetimageblock import AssetImageBlock, AssetImageBlockTypedDict @@ -64,13 +64,19 @@ class AssetOutputStep(BaseModel): content: Optional[List[Content]] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["content"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetresult.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetresult.py index 8f4f424b8..fae15aade 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetresult.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assetresult.py @@ -1,7 +1,13 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL, UnrecognizedStr +from ..types import ( + BaseModel, + UNSET_SENTINEL, + UnrecognizedStr, + current_exclude_none, + serialize_with_info, +) from ..utils.unions import parse_open_union from .assetnotestep import AssetNoteStep, AssetNoteStepTypedDict from .assetoutputstep import AssetOutputStep, AssetOutputStepTypedDict @@ -77,13 +83,19 @@ class AssetResult(BaseModel): steps: Optional[List[Step]] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["id", "status", "steps"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assettextblock.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assettextblock.py index 20eb18301..0e184d377 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assettextblock.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/assettextblock.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import validate_const import pydantic from pydantic import model_serializer @@ -24,13 +24,19 @@ class AssetTextBlock(BaseModel): text: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["text"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/bar/petowner.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/bar/petowner.py index 043e02ee5..d0642277f 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/bar/petowner.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/bar/petowner.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from .pet import Pet, PetTypedDict import pydantic from pydantic import model_serializer @@ -29,13 +34,19 @@ class PetOwner(BaseModel): r"""A pet in the bar namespace""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["pet"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baseuser.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baseuser.py index d88636517..04c45af5c 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baseuser.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baseuser.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from .gender import Gender from .metadata import Metadata, MetadataParam from .metadataany import MetadataAny, MetadataAnyParam @@ -52,6 +52,9 @@ class BaseUser(BaseModel): r"""A metadata object with additionalProperties true (any type) - should be flattened""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -66,11 +69,14 @@ def serialize_model(self, handler): "metadataAny", ] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/namespaced.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/namespaced.py index 4e19deb6a..889a61b74 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/namespaced.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/namespaced.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from ...utils import validate_const import pydantic from pydantic import model_serializer @@ -21,13 +26,19 @@ class Namespaced(BaseModel): ] = "baz" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["namespace"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/pet.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/pet.py index e092cead4..4582fae24 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/pet.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/baz/pet.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from datetime import datetime import pydantic from pydantic import model_serializer @@ -27,13 +32,19 @@ class Pet(BaseModel): adopted_at: Annotated[Optional[datetime], pydantic.Field(alias="adoptedAt")] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["adoptedAt"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/binaryandstringuploadop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/binaryandstringuploadop.py index 49f215714..8b3c4ca06 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/binaryandstringuploadop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/binaryandstringuploadop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -18,13 +18,19 @@ class BinaryAndStringUploadRequest(BaseModel): string: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["binary", "string"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/boole.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/boole.py index ca54083e8..0ff71cc5e 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/boole.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/boole.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info import pydantic from pydantic import model_serializer from typing import Optional @@ -16,13 +16,19 @@ class Boole(BaseModel): bool_: Annotated[Optional[bool], pydantic.Field(alias="bool")] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["bool"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatagentrequest.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatagentrequest.py index a3183e6a8..461b0369b 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatagentrequest.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatagentrequest.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -33,13 +33,19 @@ class ChatAgentRequest(BaseModel): r"""Sampling temperature""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["stream", "max_tokens", "temperature"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatmodelrequest.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatmodelrequest.py index cfdad4c7f..1ab1bf7c3 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatmodelrequest.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatmodelrequest.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -35,13 +35,19 @@ class ChatModelRequest(BaseModel): r"""Sampling temperature""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["model", "stream", "max_tokens", "temperature"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatop.py index c8113adeb..ff38416c4 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/chatop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import eventstreaming from .chatagentrequest import ChatAgentRequest, ChatAgentRequestParam from .chatmodelrequest import ChatModelRequest, ChatModelRequestParam @@ -26,13 +26,19 @@ class Data(BaseModel): content: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["content"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -66,13 +72,19 @@ class ChatResponseBody(BaseModel): data: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["data"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/circle.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/circle.py index dc4994977..afd06263a 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/circle.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/circle.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -31,13 +31,19 @@ class Circle(BaseModel): r"""Optional color of the circle""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["color"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/createwithunionop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/createwithunionop.py index deaba197f..3baf45f95 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/createwithunionop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/createwithunionop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, QueryParamMetadata, RequestMetadata from .shape import Shape, ShapeParam from .shaperequest import ShapeRequest, ShapeRequestParam @@ -31,13 +31,19 @@ class CreateWithUnionRequest(BaseModel): r"""If true, validates without creating""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["dryRun"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -64,13 +70,19 @@ class CreateWithUnionResponse(BaseModel): r"""A discriminated union of shape types""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["id", "shape"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/exhaustiveobject.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/exhaustiveobject.py index 9651fc445..5fccce59a 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/exhaustiveobject.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/exhaustiveobject.py @@ -8,6 +8,8 @@ UNSET_SENTINEL, UnrecognizedInt, UnrecognizedStr, + current_exclude_none, + serialize_with_info, ) from ..utils import ( serialize_decimal, @@ -263,6 +265,9 @@ class ExhaustiveObject(BaseModel): hero_width: Annotated[Optional[HeroWidth], pydantic.Field(alias="heroWidth")] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -282,11 +287,14 @@ def serialize_model(self, handler): ] ) nullable_fields = set(["nullableIntEnum", "nullableStringEnum"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) is_nullable_and_explicitly_set = ( k in nullable_fields diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/file.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/file.py index a5676dc6d..fbf27c28b 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/file.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/file.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, MultipartFormMetadata import io import pydantic @@ -34,13 +34,19 @@ class File(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["contentType"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/cat.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/cat.py index 84f2b5fde..76ac012b9 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/cat.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/cat.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) import pydantic from pydantic import model_serializer from typing import Literal, Optional @@ -31,13 +36,19 @@ class Cat(BaseModel): ) @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["meowFrequency"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/dog.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/dog.py index b597f99a7..140adeaad 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/dog.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/dog.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) import pydantic from pydantic import model_serializer from typing import Literal, Optional @@ -29,13 +34,19 @@ class Dog(BaseModel): bark_volume: Annotated[Optional[int], pydantic.Field(alias="barkVolume")] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["barkVolume"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/organization.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/organization.py index a4d698eca..a13fb0839 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/organization.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/organization.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) import pydantic from pydantic import model_serializer from typing import List, Optional @@ -43,13 +48,19 @@ class Address(BaseModel): r"""Deeply nested inline object should also end up in foo namespace""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["location"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -94,13 +105,19 @@ class Organization(BaseModel): departments: Optional[List[Department]] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["departments"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/pet.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/pet.py index b40a20960..686b6cabd 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/pet.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/pet.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -52,13 +57,19 @@ class Pet(BaseModel): r"""A field name that often collides""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["models", "request", "operations", "errors", "utils"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/petowner.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/petowner.py index e371f3cce..f5b422142 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/petowner.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/foo/petowner.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from .pet import Pet, PetParam from pydantic import model_serializer from typing import List, Optional @@ -26,13 +31,19 @@ class PetOwner(BaseModel): pets: Optional[List[Pet]] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["pets"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getassetop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getassetop.py index eb186ffbb..f39d16e05 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getassetop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getassetop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, PathParamMetadata, QueryParamMetadata, eventstreaming from .assetresult import AssetResult, AssetResultTypedDict from pydantic import model_serializer @@ -25,13 +25,19 @@ class GetAssetRequest(BaseModel): ] = True @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["stream"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getduplicateexportcollisionop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getduplicateexportcollisionop.py index 429261fe4..f91d29340 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getduplicateexportcollisionop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getduplicateexportcollisionop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -19,13 +19,19 @@ class GetDuplicateExportCollisionResponse(BaseModel): result: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["result"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/geterroronlyexampleop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/geterroronlyexampleop.py index 0cfce81d8..9da2562b9 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/geterroronlyexampleop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/geterroronlyexampleop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -25,13 +25,19 @@ class GetErrorOnlyExampleResponse(BaseModel): status: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["status"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getfullyflattenedrequestop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getfullyflattenedrequestop.py index dbb50b70f..5de776fd5 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getfullyflattenedrequestop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getfullyflattenedrequestop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, QueryParamMetadata, RequestMetadata from pydantic import model_serializer from typing import Literal, Optional @@ -42,13 +42,19 @@ class GetFullyFlattenedRequestRequestBody(BaseModel): private: Optional[bool] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["emoji", "gif", "reply", "private"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -80,13 +86,19 @@ class GetFullyFlattenedRequestRequest(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["max_length"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getpolymorphismop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getpolymorphismop.py index 15e22a507..181b3fc21 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getpolymorphismop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getpolymorphismop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from .circularunion import CircularUnion, CircularUnionTypedDict from .exhaustiveobject import ExhaustiveObject, ExhaustiveObjectParam from .oneofwithfactoredoutproperties import ( @@ -44,13 +44,19 @@ class SimpleAllOf(BaseModel): r"""A boolean property.""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["str", "bool"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -90,15 +96,21 @@ class AllOfWithFactoredOutProperties(BaseModel): r"""An extra property.""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( ["anOverridingProperty", "anotherProperty", "anExtraProperty"] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -162,6 +174,9 @@ class GetPolymorphismResponse(BaseModel): r"""A form field schema that can be recursive - the array type variant contains an array of RecursiveFormField items.""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -173,11 +188,14 @@ def serialize_model(self, handler): "recursiveFormField", ] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getrequestbodyflattenedawayop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getrequestbodyflattenedawayop.py index 7f4c71334..b89ef1fca 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getrequestbodyflattenedawayop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/getrequestbodyflattenedawayop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, QueryParamMetadata import pydantic from pydantic import model_serializer @@ -21,13 +21,19 @@ class GetRequestBodyFlattenedAwayGlobals(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["loneQueryParam"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/internal/globals.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/internal/globals.py index 3a2855f14..8481577da 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/internal/globals.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/internal/globals.py @@ -1,7 +1,12 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ...types import BaseModel, UNSET_SENTINEL +from ...types import ( + BaseModel, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from ...utils import FieldMetadata, QueryParamMetadata import pydantic from pydantic import model_serializer @@ -58,6 +63,9 @@ class Globals(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -67,11 +75,14 @@ def serialize_model(self, handler): "loneQueryParam", ] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/listtest1op.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/listtest1op.py index ca14cbc10..cbefa57f9 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/listtest1op.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/listtest1op.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, HeaderMetadata, PathParamMetadata, QueryParamMetadata from .enum import EnumT import pydantic @@ -37,13 +37,19 @@ class ListTest1Globals(BaseModel): """ @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["queryParam1"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -124,13 +130,19 @@ class ListTest1Request(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["queryParam1"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -166,13 +178,19 @@ class ListTest1ResponseBody(BaseModel): type: Optional[EnumT] = "First" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["type"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadata.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadata.py index 550f864b0..ef971b1ff 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadata.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadata.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info import pydantic from pydantic import ConfigDict, model_serializer from typing import Dict, Optional @@ -29,13 +29,19 @@ def additional_properties(self, value): self.__pydantic_extra__ = value # pyright: ignore[reportIncompatibleVariableOverride] @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["allergies"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) serialized.pop(k, serialized.pop(n, None)) diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadataany.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadataany.py index 9e397163b..670b4b03a 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadataany.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/metadataany.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info import pydantic from pydantic import ConfigDict, model_serializer from typing import Any, Dict, Optional @@ -33,13 +33,19 @@ def additional_properties(self, value): self.__pydantic_extra__ = value # pyright: ignore[reportIncompatibleVariableOverride] @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["notes"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) serialized.pop(k, serialized.pop(n, None)) diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/objwithrenamedproperties.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/objwithrenamedproperties.py index 75e989a34..141788208 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/objwithrenamedproperties.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/objwithrenamedproperties.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from .aloof import Aloof, AloofParam from .baz import namespaced as baz_namespaced from .boole import Boole, BooleParam @@ -28,13 +28,19 @@ class ObjWithRenamedProperties(BaseModel): allof: Optional[Aloof] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["direct", "namespaced", "overridden", "allof"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/oneofwithfactoredoutproperties.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/oneofwithfactoredoutproperties.py index 148795c12..82f08ccf6 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/oneofwithfactoredoutproperties.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/oneofwithfactoredoutproperties.py @@ -8,6 +8,8 @@ UNSET_SENTINEL, UnrecognizedInt, UnrecognizedStr, + current_exclude_none, + serialize_with_info, ) from ..utils import ( serialize_decimal, @@ -46,13 +48,19 @@ class OneOfWithFactoredOutPropertiesSimpleObject(BaseModel): r"""An extra property.""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["anExtraProperty"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -318,6 +326,9 @@ class OneOfWithFactoredOutPropertiesExhaustiveObject(BaseModel): r"""An extra property.""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -338,11 +349,14 @@ def serialize_model(self, handler): ] ) nullable_fields = set(["nullableIntEnum", "nullableStringEnum"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) is_nullable_and_explicitly_set = ( k in nullable_fields diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/postfilewithencodingop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/postfilewithencodingop.py index 283b00ebd..3339ff735 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/postfilewithencodingop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/postfilewithencodingop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, MultipartFormMetadata import io import pydantic @@ -34,13 +34,19 @@ class PostFileWithEncodingFile(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["contentType"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -74,13 +80,19 @@ class Attachment(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["contentType"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -108,13 +120,19 @@ class PostFileWithEncodingMetadata(BaseModel): tags: Optional[List[str]] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["title", "description", "tags"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -168,13 +186,19 @@ class PostFileWithEncodingRequest(BaseModel): r"""JSON metadata about the file""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["attachment", "fileName", "filePurpose", "metadata"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -205,13 +229,19 @@ class PostFileWithEncodingResponse(BaseModel): metadata: Optional[Dict[str, Any]] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["contentType", "metadata"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/posttest2op.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/posttest2op.py index 1a4eb9c73..bf348209d 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/posttest2op.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/posttest2op.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, QueryParamMetadata, RequestMetadata from .test2request import Test2Request, Test2RequestParam import pydantic @@ -48,13 +48,19 @@ class PostTest2Globals(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["deprecatedQueryParam1", "deprecatedQueryParam2"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -95,13 +101,19 @@ class PostTest2Request(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["deprecatedQueryParam1", "deprecatedQueryParam2"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/rectangle.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/rectangle.py index 047dee555..4ee09ab2a 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/rectangle.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/rectangle.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from pydantic import model_serializer from typing import Optional from typing_extensions import NotRequired, TypedDict @@ -36,13 +36,19 @@ class Rectangle(BaseModel): r"""Optional color of the rectangle""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["color"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/recursiveformfield.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/recursiveformfield.py index 5a76ca419..f47a4a252 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/recursiveformfield.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/recursiveformfield.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import validate_const from ..utils.unions import parse_open_union from functools import partial @@ -33,13 +33,19 @@ class RecursiveFormFieldText(BaseModel): required: Optional[bool] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["required"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -70,13 +76,19 @@ class RecursiveFormFieldNumber(BaseModel): required: Optional[bool] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["required"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -112,13 +124,19 @@ class RecursiveFormFieldArray(BaseModel): required: Optional[bool] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["required"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/renderassetop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/renderassetop.py index be72e4dc4..4797ba356 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/renderassetop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/renderassetop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import eventstreaming from .assetresult import AssetResult, AssetResultTypedDict from pydantic import model_serializer @@ -26,13 +26,19 @@ class RenderAssetRequest(BaseModel): output_modalities: Optional[List[OutputModality]] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["output_modalities"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/security.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/security.py index f5ae7cfba..a51934eaa 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/security.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/security.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import FieldMetadata, SecurityMetadata import pydantic from pydantic import model_serializer @@ -215,6 +215,9 @@ class Security(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -227,11 +230,14 @@ def serialize_model(self, handler): "MyApiKey", ] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/shaperequest.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/shaperequest.py index c30ab3c12..5dd89128d 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/shaperequest.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/shaperequest.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from .shape import Shape, ShapeParam from pydantic import model_serializer from typing import Optional @@ -32,13 +32,19 @@ class ShapeRequest(BaseModel): r"""Optional description""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["description"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/templatebracestest.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/templatebracestest.py index 601822baf..a4b5fac62 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/templatebracestest.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/templatebracestest.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import validate_const import pydantic from pydantic import model_serializer @@ -84,6 +84,9 @@ class TemplateBracesTest(BaseModel): ] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -94,11 +97,14 @@ def serialize_model(self, handler): "fieldWithBracesInExample", ] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2request.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2request.py index b77378537..792e2fdb1 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2request.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2request.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from .exhaustiveobject import ExhaustiveObject, ExhaustiveObjectParam from pydantic import model_serializer from typing import Literal, Optional @@ -35,13 +35,19 @@ class Test2Request(BaseModel): type: Optional[Type] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["type"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2response.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2response.py index 4504360f5..16abd27db 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2response.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/test2response.py @@ -1,7 +1,15 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL +from ..types import ( + BaseModel, + Nullable, + OptionalNullable, + UNSET, + UNSET_SENTINEL, + current_exclude_none, + serialize_with_info, +) from ..utils import validate_const import pydantic from pydantic import model_serializer @@ -38,14 +46,20 @@ class Test2Response(BaseModel): ] = "someConstValue" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["test2", "someConst"]) nullable_fields = set(["test2", "requiredNullableField"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) is_nullable_and_explicitly_set = ( k in nullable_fields diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/user.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/user.py index d5ddfd298..98d096784 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/user.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/user.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from .gender import Gender from .metadata import Metadata, MetadataParam from .metadataany import MetadataAny, MetadataAnyParam @@ -52,6 +52,9 @@ class User(BaseModel): r"""A metadata object with additionalProperties true (any type) - should be flattened""" @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set( [ @@ -65,11 +68,14 @@ def serialize_model(self, handler): "metadataAny", ] ) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/validateop.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/validateop.py index 8d2382e39..7a6e21a75 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/validateop.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/validateop.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from datetime import datetime import pydantic from pydantic import model_serializer @@ -27,13 +27,19 @@ class ValidateResponse(BaseModel): last_login: Annotated[Optional[datetime], pydantic.Field(alias="lastLogin")] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["valid", "id", "lastLogin"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/variantrecord.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/variantrecord.py index 1b99ae130..17aaed268 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/variantrecord.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/models/variantrecord.py @@ -1,7 +1,7 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" from __future__ import annotations -from ..types import BaseModel, UNSET_SENTINEL +from ..types import BaseModel, UNSET_SENTINEL, current_exclude_none, serialize_with_info from ..utils import get_discriminator import pydantic from pydantic import Discriminator, Tag, model_serializer @@ -29,13 +29,19 @@ class ImageRecord(BaseModel): caption: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["caption"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: @@ -65,13 +71,19 @@ class TextRecord(BaseModel): note: Optional[str] = None @model_serializer(mode="wrap") + def _serialize_model_with_info(self, handler, info): + return serialize_with_info(self.serialize_model, handler, info) + def serialize_model(self, handler): optional_fields = set(["note"]) + exclude_none = current_exclude_none() serialized = handler(self) m = {} for n, f in type(self).model_fields.items(): - k = f.alias or n + k = f.alias if f.alias is not None else n + if k not in serialized and n not in serialized and exclude_none is False: + continue val = serialized.get(k, serialized.get(n)) if val != UNSET_SENTINEL: diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/__init__.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/__init__.py index faa268137..3a43a78ab 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/__init__.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/__init__.py @@ -3,22 +3,26 @@ from .base64fileinput import Base64EncodedString, Base64FileInput from .basemodel import ( BaseModel, + current_exclude_none, Nullable, OptionalNullable, UnrecognizedInt, UnrecognizedStr, UNSET, UNSET_SENTINEL, + serialize_with_info, ) __all__ = [ "Base64EncodedString", "Base64FileInput", "BaseModel", + "current_exclude_none", "Nullable", "OptionalNullable", "UnrecognizedInt", "UnrecognizedStr", "UNSET", "UNSET_SENTINEL", + "serialize_with_info", ] diff --git a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/basemodel.py b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/basemodel.py index 06c13bfcd..e4ae50e2c 100644 --- a/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/basemodel.py +++ b/zSDKs/sdk-pythonv2/src/speakeasy/new_openapi/types/basemodel.py @@ -1,9 +1,10 @@ """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.""" +from contextvars import ContextVar from pydantic import ConfigDict, model_serializer from pydantic import BaseModel as PydanticBaseModel from pydantic_core import PydanticSerializationUnexpectedValue, core_schema -from typing import TYPE_CHECKING, Any, Literal, Optional, Type, TypeVar, Union +from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Type, TypeVar, Union from typing_extensions import TypeAliasType, TypeAlias @@ -37,6 +38,24 @@ def __bool__(self) -> Literal[False]: ) +_exclude_none: ContextVar[Optional[bool]] = ContextVar("exclude_none", default=None) + + +def serialize_with_info( + serialize: Callable[[Any], Any], handler: Any, info: core_schema.SerializationInfo +) -> Any: + token = _exclude_none.set(info.exclude_none) + try: + return serialize(handler) + finally: + _exclude_none.reset(token) + + +def current_exclude_none() -> Optional[bool]: + """Return the exclude_none option of the enclosing serialize_with_info call, or None outside of one.""" + return _exclude_none.get() + + def _unrecognized_serialization(cls: Type[Union[str, int]]) -> core_schema.PlainSerializerFunctionSerSchema: def serialize(value: Any, info: core_schema.SerializationInfo) -> Any: # Decline other values so union serialization tries the remaining members