fix(python): keep two-argument serialize_model for overrides

The generated model serializer took a third `info` argument so it could
read `exclude_none`, which broke subclasses that delegate with
`super().serialize_model(handler)` and two-argument overrides under type
checking.

`serialize_model(self, handler)` keeps its previous signature and is no
longer the pydantic serializer itself. A new `_serialize_model_with_info`
wrap serializer receives `info`, exposes `exclude_none` through a context
variable for the duration of the call, and delegates to
`self.serialize_model`. Overrides decorated with `@model_serializer` that
call the parent get the previous behaviour; undecorated overrides keep the
include/exclude filtering.

Author: 2ynn

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",
 ]

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

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, info):
+    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,12 +94,13 @@ 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 if f.alias is not None else n
-            if k not in serialized and n not in serialized and not info.exclude_none:
+            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}}

templates/templates/pythonv2/tests/primary/test_model_dump_filters_additional.py

@@ -1,7 +1,7 @@
 import json
 from typing import List, Optional
 
-from pydantic import TypeAdapter
+from pydantic import TypeAdapter, model_serializer
 
 from openapi import utils
 from openapi.models import errors, shared
@@ -204,3 +204,29 @@ def test_value_kept_under_empty_api_name(self):
         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