[python-fastapi] support pydantic v2 models

Previously, the generated `additional_properties` field showed up within
the response of the generated API as opposed marshaling the model so that its fields are added to the root object.
Apparently that is because pydantic v2 does not honour the generated `to_dict` methods anymore (which would have mapped the object to the correct representation) but, instead, supports additional properties natively by specifying `extra=allow` within the `model_config`.

Correspondingly, the following changes have been applied:
* To allow additional fields, specify `extra=allow` within the `model_config`.
* Don't generate the `additional_properties` field - users can use pydantic's built-in `model.extra_fields` instead.
* Let the `{to|from}_{dict|json}` methods delegate to Pydantic's `model_dump[_json]` methods.

Author: mgoltzsche

modules/openapi-generator/src/main/resources/python-fastapi/model_generic.mustache

@@ -24,9 +24,6 @@ class {{classname}}({{#parent}}{{{.}}}{{/parent}}{{^parent}}BaseModel{{/parent}}
 {{#vars}}
     {{name}}: {{{vendorExtensions.x-py-typing}}}
 {{/vars}}
-{{#isAdditionalPropertiesTrue}}
-    additional_properties: Dict[str, Any] = {}
-{{/isAdditionalPropertiesTrue}}
     __properties: ClassVar[List[str]] = [{{#allVars}}"{{baseName}}"{{^-last}}, {{/-last}}{{/allVars}}]
 {{#vars}}
     {{#vendorExtensions.x-regex}}
@@ -84,296 +81,38 @@ class {{classname}}({{#parent}}{{{.}}}{{/parent}}{{^parent}}BaseModel{{/parent}}
         "populate_by_name": True,
         "validate_assignment": True,
         "protected_namespaces": (),
+{{#isAdditionalPropertiesTrue}}
+        "extra": "allow",
+{{/isAdditionalPropertiesTrue}}
     }
 
-
-{{#hasChildren}}
-{{#discriminator}}
-    # JSON field name that stores the object type
-    __discriminator_property_name: ClassVar[List[str]] = '{{discriminator.propertyBaseName}}'
-
-    # discriminator mappings
-    __discriminator_value_class_map: ClassVar[Dict[str, str]] = {
-        {{#mappedModels}}'{{{mappingName}}}': '{{{modelName}}}'{{^-last}},{{/-last}}{{/mappedModels}}
-    }
-
-    @classmethod
-    def get_discriminator_value(cls, obj: Dict) -> str:
-        """Returns the discriminator value (object type) of the data"""
-        discriminator_value = obj[cls.__discriminator_property_name]
-        if discriminator_value:
-            return cls.__discriminator_value_class_map.get(discriminator_value)
-        else:
-            return None
-
-{{/discriminator}}
-{{/hasChildren}}
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.model_dump(by_alias=True))
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return self.model_dump_json(by_alias=True)
 
     @classmethod
     def from_json(cls, json_str: str) -> {{^hasChildren}}Self{{/hasChildren}}{{#hasChildren}}{{#discriminator}}Union[{{#children}}Self{{^-last}}, {{/-last}}{{/children}}]{{/discriminator}}{{^discriminator}}Self{{/discriminator}}{{/hasChildren}}:
         """Create an instance of {{{classname}}} from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
+        return cls.parse_obj(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        {{#vendorExtensions.x-py-readonly}}
-        * OpenAPI `readOnly` fields are excluded.
-        {{/vendorExtensions.x-py-readonly}}
-        {{#isAdditionalPropertiesTrue}}
-        * Fields in `self.additional_properties` are added to the output dict.
-        {{/isAdditionalPropertiesTrue}}
-        """
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude={
-                {{#vendorExtensions.x-py-readonly}}
-                "{{{.}}}",
-                {{/vendorExtensions.x-py-readonly}}
-                {{#isAdditionalPropertiesTrue}}
-                "additional_properties",
-                {{/isAdditionalPropertiesTrue}}
-            },
-            exclude_none=True,
-        )
-        {{#allVars}}
-        {{#isContainer}}
-        {{#isArray}}
-        {{#items.isArray}}
-        {{^items.items.isPrimitiveType}}
-        # override the default output from pydantic by calling `to_dict()` of each item in {{{name}}} (list of list)
-        _items = []
-        if self.{{{name}}}:
-            for _item in self.{{{name}}}:
-                if _item:
-                    _items.append(
-                         [_inner_item.to_dict() for _inner_item in _item if _inner_item is not None]
-                    )
-            _dict['{{{baseName}}}'] = _items
-        {{/items.items.isPrimitiveType}}
-        {{/items.isArray}}
-        {{^items.isArray}}
-        {{^items.isPrimitiveType}}
-        {{^items.isEnumOrRef}}
-        # override the default output from pydantic by calling `to_dict()` of each item in {{{name}}} (list)
-        _items = []
-        if self.{{{name}}}:
-            for _item in self.{{{name}}}:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['{{{baseName}}}'] = _items
-        {{/items.isEnumOrRef}}
-        {{/items.isPrimitiveType}}
-        {{/items.isArray}}
-        {{/isArray}}
-        {{#isMap}}
-        {{#items.isArray}}
-        {{^items.items.isPrimitiveType}}
-        # override the default output from pydantic by calling `to_dict()` of each value in {{{name}}} (dict of array)
-        _field_dict_of_array = {}
-        if self.{{{name}}}:
-            for _key in self.{{{name}}}:
-                if self.{{{name}}}[_key] is not None:
-                    _field_dict_of_array[_key] = [
-                        _item.to_dict() for _item in self.{{{name}}}[_key]
-                    ]
-            _dict['{{{baseName}}}'] = _field_dict_of_array
-        {{/items.items.isPrimitiveType}}
-        {{/items.isArray}}
-        {{^items.isArray}}
-        {{^items.isPrimitiveType}}
-        {{^items.isEnumOrRef}}
-        # override the default output from pydantic by calling `to_dict()` of each value in {{{name}}} (dict)
-        _field_dict = {}
-        if self.{{{name}}}:
-            for _key in self.{{{name}}}:
-                if self.{{{name}}}[_key]:
-                    _field_dict[_key] = self.{{{name}}}[_key].to_dict()
-            _dict['{{{baseName}}}'] = _field_dict
-        {{/items.isEnumOrRef}}
-        {{/items.isPrimitiveType}}
-        {{/items.isArray}}
-        {{/isMap}}
-        {{/isContainer}}
-        {{^isContainer}}
-        {{^isPrimitiveType}}
-        {{^isEnumOrRef}}
-        # override the default output from pydantic by calling `to_dict()` of {{{name}}}
-        if self.{{{name}}}:
-            _dict['{{{baseName}}}'] = self.{{{name}}}.to_dict()
-        {{/isEnumOrRef}}
-        {{/isPrimitiveType}}
-        {{/isContainer}}
-        {{/allVars}}
-        {{#isAdditionalPropertiesTrue}}
-        # puts key-value pairs in additional_properties in the top level
-        if self.additional_properties is not None:
-            for _key, _value in self.additional_properties.items():
-                _dict[_key] = _value
-
-        {{/isAdditionalPropertiesTrue}}
-        {{#allVars}}
-        {{#isNullable}}
-        # set to None if {{{name}}} (nullable) is None
-        # and model_fields_set contains the field
-        if self.{{name}} is None and "{{{name}}}" in self.model_fields_set:
-            _dict['{{{baseName}}}'] = None
-
-        {{/isNullable}}
-        {{/allVars}}
-        return _dict
+        """Return the dictionary representation of the model using alias"""
+        return self.model_dump(by_alias=True)
 
     @classmethod
     def from_dict(cls, obj: Dict) -> {{^hasChildren}}Self{{/hasChildren}}{{#hasChildren}}{{#discriminator}}Union[{{#children}}Self{{^-last}}, {{/-last}}{{/children}}]{{/discriminator}}{{^discriminator}}Self{{/discriminator}}{{/hasChildren}}:
         """Create an instance of {{{classname}}} from a dict"""
-        {{#hasChildren}}
-        {{#discriminator}}
-        # look up the object type based on discriminator mapping
-        object_type = cls.get_discriminator_value(obj)
-        if object_type:
-            klass = globals()[object_type]
-            return klass.from_dict(obj)
-        else:
-            raise ValueError("{{{classname}}} failed to lookup discriminator value from " +
-                             json.dumps(obj) + ". Discriminator property name: " + cls.__discriminator_property_name +
-                             ", mapping: " + json.dumps(cls.__discriminator_value_class_map))
-        {{/discriminator}}
-        {{/hasChildren}}
-        {{^hasChildren}}
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
             return cls.model_validate(obj)
 
-        {{#disallowAdditionalPropertiesIfNotPresent}}
-        {{^isAdditionalPropertiesTrue}}
-        # raise errors for additional fields in the input
-        for _key in obj.keys():
-            if _key not in cls.__properties:
-                raise ValueError("Error due to additional fields (not defined in {{classname}}) in the input: " + _key)
-
-        {{/isAdditionalPropertiesTrue}}
-        {{/disallowAdditionalPropertiesIfNotPresent}}
-        _obj = cls.model_validate({
-            {{#allVars}}
-            {{#isContainer}}
-            {{#isArray}}
-            {{#items.isArray}}
-            {{#items.items.isPrimitiveType}}
-            "{{{baseName}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}}
-            {{/items.items.isPrimitiveType}}
-            {{^items.items.isPrimitiveType}}
-            "{{{baseName}}}": [
-                    [{{{items.items.dataType}}}.from_dict(_inner_item) for _inner_item in _item]
-                    for _item in obj.get("{{{baseName}}}")
-                ] if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}}
-            {{/items.items.isPrimitiveType}}
-            {{/items.isArray}}
-            {{^items.isArray}}
-            {{^items.isPrimitiveType}}
-            {{#items.isEnumOrRef}}
-            "{{{baseName}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}}
-            {{/items.isEnumOrRef}}
-            {{^items.isEnumOrRef}}
-            "{{{baseName}}}": [{{{items.dataType}}}.from_dict(_item) for _item in obj.get("{{{baseName}}}")] if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}}
-            {{/items.isEnumOrRef}}
-            {{/items.isPrimitiveType}}
-            {{#items.isPrimitiveType}}
-            "{{{baseName}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}}
-            {{/items.isPrimitiveType}}
-            {{/items.isArray}}
-            {{/isArray}}
-            {{#isMap}}
-            {{^items.isPrimitiveType}}
-            {{^items.isEnumOrRef}}
-            {{#items.isContainer}}
-            {{#items.isMap}}
-            "{{{baseName}}}": dict(
-                (_k, dict(
-                    (_ik, {{{items.items.dataType}}}.from_dict(_iv))
-                        for _ik, _iv in _v.items()
-                    )
-                    if _v is not None
-                    else None
-                )
-                for _k, _v in obj.get("{{{baseName}}}").items()
-            )
-            if obj.get("{{{baseName}}}") is not None
-            else None{{^-last}},{{/-last}}
-            {{/items.isMap}}
-            {{#items.isArray}}
-            "{{{baseName}}}": dict(
-                (_k,
-                        [{{{items.items.dataType}}}.from_dict(_item) for _item in _v]
-                        if _v is not None
-                        else None
-                )
-                for _k, _v in obj.get("{{{baseName}}}").items()
-            ){{^-last}},{{/-last}}
-            {{/items.isArray}}
-            {{/items.isContainer}}
-            {{^items.isContainer}}
-            "{{{baseName}}}": dict(
-                (_k, {{{items.dataType}}}.from_dict(_v))
-                for _k, _v in obj.get("{{{baseName}}}").items()
-            )
-            if obj.get("{{{baseName}}}") is not None
-            else None{{^-last}},{{/-last}}
-            {{/items.isContainer}}
-            {{/items.isEnumOrRef}}
-            {{#items.isEnumOrRef}}
-            "{{{baseName}}}": dict((_k, _v) for _k, _v in obj.get("{{{baseName}}}").items()){{^-last}},{{/-last}}
-            {{/items.isEnumOrRef}}
-            {{/items.isPrimitiveType}}
-            {{#items.isPrimitiveType}}
-            "{{{baseName}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}}
-            {{/items.isPrimitiveType}}
-            {{/isMap}}
-            {{/isContainer}}
-            {{^isContainer}}
-            {{^isPrimitiveType}}
-            {{^isEnumOrRef}}
-            "{{{baseName}}}": {{{dataType}}}.from_dict(obj.get("{{{baseName}}}")) if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}}
-            {{/isEnumOrRef}}
-            {{#isEnumOrRef}}
-            "{{{baseName}}}": obj.get("{{{baseName}}}"){{#defaultValue}} if obj.get("{{baseName}}") is not None else {{defaultValue}}{{/defaultValue}}{{^-last}},{{/-last}}
-            {{/isEnumOrRef}}
-            {{/isPrimitiveType}}
-            {{#isPrimitiveType}}
-            {{#defaultValue}}
-            "{{{baseName}}}": obj.get("{{{baseName}}}") if obj.get("{{{baseName}}}") is not None else {{{defaultValue}}}{{^-last}},{{/-last}}
-            {{/defaultValue}}
-            {{^defaultValue}}
-            "{{{baseName}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}}
-            {{/defaultValue}}
-            {{/isPrimitiveType}}
-            {{/isContainer}}
-            {{/allVars}}
-        })
-        {{#isAdditionalPropertiesTrue}}
-        # store additional fields in additional_properties
-        for _key in obj.keys():
-            if _key not in cls.__properties:
-                _obj.additional_properties[_key] = obj.get(_key)
-
-        {{/isAdditionalPropertiesTrue}}
-        return _obj
-        {{/hasChildren}}
+        return cls.parse_obj(obj)
 
 {{#vendorExtensions.x-py-postponed-model-imports.size}}
 {{#vendorExtensions.x-py-postponed-model-imports}}

samples/server/petstore/python-fastapi/src/openapi_server/models/api_response.py

@@ -42,38 +42,22 @@ class ApiResponse(BaseModel):
         "protected_namespaces": (),
     }
 
-
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
         return pprint.pformat(self.model_dump(by_alias=True))
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return self.model_dump_json(by_alias=True)
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:
         """Create an instance of ApiResponse from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
+        return cls.parse_obj(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude={
-            },
-            exclude_none=True,
-        )
-        return _dict
+        """Return the dictionary representation of the model using alias"""
+        return self.model_dump(by_alias=True)
 
     @classmethod
     def from_dict(cls, obj: Dict) -> Self:
@@ -84,11 +68,6 @@ def from_dict(cls, obj: Dict) -> Self:
         if not isinstance(obj, dict):
             return cls.model_validate(obj)
 
-        _obj = cls.model_validate({
-            "code": obj.get("code"),
-            "type": obj.get("type"),
-            "message": obj.get("message")
-        })
-        return _obj
+        return cls.parse_obj(obj)