Padznich python sdk anyof allof root model

modules/openapi-generator/src/main/resources/python/api_client.mustache

@@ -724,7 +724,7 @@ class ApiClient:
                 content_disposition
             )
             assert m is not None, "Unexpected 'content-disposition' header value"
-            filename = m.group(1)
+            filename = os.path.basename(m.group(1))  # Strip any directory traversal
             path = os.path.join(os.path.dirname(path), filename)
 
         with open(path, "wb") as f:

modules/openapi-generator/src/main/resources/python/model_anyof.mustache

@@ -1,6 +1,4 @@
 from __future__ import annotations
-from inspect import getfullargspec
-import json
 import pprint
 import re  # noqa: F401
 {{#vendorExtensions.x-py-other-imports}}
@@ -11,167 +9,57 @@ import re  # noqa: F401
 {{/vendorExtensions.x-py-model-imports}}
 from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict
 from typing_extensions import Literal, Self
-from pydantic import Field
+from pydantic import Field, RootModel
 
 {{#lambda.uppercase}}{{{classname}}}{{/lambda.uppercase}}_ANY_OF_SCHEMAS = [{{#anyOf}}"{{.}}"{{^-last}}, {{/-last}}{{/anyOf}}]
 
-class {{classname}}({{#parent}}{{{.}}}{{/parent}}{{^parent}}BaseModel{{/parent}}):
+
+class {{classname}}(RootModel[Union[{{#anyOf}}{{.}}{{^-last}}, {{/-last}}{{/anyOf}}]]):
     """
     {{{description}}}{{^description}}{{{classname}}}{{/description}}
     """
 
-{{#composedSchemas.anyOf}}
-    # data type: {{{dataType}}}
-    {{vendorExtensions.x-py-name}}: {{{vendorExtensions.x-py-typing}}}
-{{/composedSchemas.anyOf}}
-    if TYPE_CHECKING:
-        actual_instance: Optional[Union[{{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}}]] = None
-    else:
-        actual_instance: Any = None
-    any_of_schemas: Set[str] = { {{#anyOf}}"{{.}}"{{^-last}}, {{/-last}}{{/anyOf}} }
-
-    model_config = {
-        "validate_assignment": True,
-        "protected_namespaces": (),
-    }
-{{#discriminator}}
+    root: Union[{{#anyOf}}{{.}}{{^-last}}, {{/-last}}{{/anyOf}}{{#isNullable}}, None{{/isNullable}}] = Field(
+        {{#isNullable}}None{{/isNullable}}{{^isNullable}}...{{/isNullable}}{{#discriminator}}, discriminator="{{discriminatorName}}"{{/discriminator}}
+    )
 
-    discriminator_value_class_map: Dict[str, str] = {
-{{#children}}
-        '{{^vendorExtensions.x-discriminator-value}}{{name}}{{/vendorExtensions.x-discriminator-value}}{{#vendorExtensions.x-discriminator-value}}{{{vendorExtensions.x-discriminator-value}}}{{/vendorExtensions.x-discriminator-value}}': '{{{classname}}}'{{^-last}},{{/-last}}
-{{/children}}
-    }
-{{/discriminator}}
+    def __getattr__(self, name):
+        """
+        Delegate attribute access to the root model if the attribute
+        doesn't exist on the main class.
+        """
 
-    def __init__(self, *args, **kwargs) -> None:
-        if args:
-            if len(args) > 1:
-                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
-            if kwargs:
-                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
-            super().__init__(actual_instance=args[0])
-        else:
-            super().__init__(**kwargs)
+        if name in self.__dict__:
+            return super().__getattribute__(name)
 
-    @field_validator('actual_instance')
-    def actual_instance_must_validate_anyof(cls, v):
-        {{#isNullable}}
-        if v is None:
-            return v
+        root = self.__dict__.get('root')
+        if root is not None:
+            return getattr(root, name)
 
-        {{/isNullable}}
-        instance = {{{classname}}}.model_construct()
-        error_messages = []
-        {{#composedSchemas.anyOf}}
-        # validate data type: {{{dataType}}}
-        {{#isContainer}}
-        try:
-            instance.{{vendorExtensions.x-py-name}} = v
-            return v
-        except (ValidationError, ValueError) as e:
-            error_messages.append(str(e))
-        {{/isContainer}}
-        {{^isContainer}}
-        {{#isPrimitiveType}}
-        try:
-            instance.{{vendorExtensions.x-py-name}} = v
-            return v
-        except (ValidationError, ValueError) as e:
-            error_messages.append(str(e))
-        {{/isPrimitiveType}}
-        {{^isPrimitiveType}}
-        if not isinstance(v, {{{dataType}}}):
-            error_messages.append(f"Error! Input type `{type(v)}` is not `{{{dataType}}}`")
-        else:
-            return v
-
-        {{/isPrimitiveType}}
-        {{/isContainer}}
-        {{/composedSchemas.anyOf}}
-        if error_messages:
-            # no match
-            raise ValueError("No match found when setting the actual_instance in {{{classname}}} with anyOf schemas: {{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}}. Details: " + ", ".join(error_messages))
-        else:
-            return v
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
 
     @classmethod
     def from_dict(cls, obj: Dict[str, Any]) -> Self:
-        return cls.from_json(json.dumps(obj))
+        """Returns the object represented by the Dict"""
+        return cls.model_validate(obj, strict=True)
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:
         """Returns the object represented by the json string"""
-        instance = cls.model_construct()
-        {{#isNullable}}
-        if json_str is None:
-            return instance
-
-        {{/isNullable}}
-        error_messages = []
-        {{#composedSchemas.anyOf}}
-        {{#isContainer}}
-        # deserialize data into {{{dataType}}}
-        try:
-            # validation
-            instance.{{vendorExtensions.x-py-name}} = json.loads(json_str)
-            # assign value to actual_instance
-            instance.actual_instance = instance.{{vendorExtensions.x-py-name}}
-            return instance
-        except (ValidationError, ValueError) as e:
-            error_messages.append(str(e))
-        {{/isContainer}}
-        {{^isContainer}}
-        {{#isPrimitiveType}}
-        # deserialize data into {{{dataType}}}
-        try:
-            # validation
-            instance.{{vendorExtensions.x-py-name}} = json.loads(json_str)
-            # assign value to actual_instance
-            instance.actual_instance = instance.{{vendorExtensions.x-py-name}}
-            return instance
-        except (ValidationError, ValueError) as e:
-            error_messages.append(str(e))
-        {{/isPrimitiveType}}
-        {{^isPrimitiveType}}
-        # {{vendorExtensions.x-py-name}}: {{{vendorExtensions.x-py-typing}}}
-        try:
-            instance.actual_instance = {{{dataType}}}.from_json(json_str)
-            return instance
-        except (ValidationError, ValueError) as e:
-             error_messages.append(str(e))
-        {{/isPrimitiveType}}
-        {{/isContainer}}
-        {{/composedSchemas.anyOf}}
-
-        if error_messages:
-            # no match
-            raise ValueError("No match found when deserializing the JSON string into {{{classname}}} with anyOf schemas: {{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}}. Details: " + ", ".join(error_messages))
-        else:
-            return instance
+        return cls.model_validate_json(json_str)
 
     def to_json(self) -> str:
         """Returns the JSON representation of the actual instance"""
-        if self.actual_instance is None:
-            return "null"
-
-        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
-            return self.actual_instance.to_json()
-        else:
-            return json.dumps(self.actual_instance)
+        return self.model_dump_json(by_alias=True, exclude_none=True)
 
-    def to_dict(self) -> Optional[Union[Dict[str, Any], {{#anyOf}}{{.}}{{^-last}}, {{/-last}}{{/anyOf}}]]:
+    def to_dict(self) -> Dict[str, Any]:
         """Returns the dict representation of the actual instance"""
-        if self.actual_instance is None:
-            return None
-
-        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
-            return self.actual_instance.to_dict()
-        else:
-            return self.actual_instance
+        return self.model_dump(by_alias=True)
 
     def to_str(self) -> str:
         """Returns the string representation of the actual instance"""
-        return pprint.pformat(self.model_dump())
+        return pprint.pformat(self.model_dump(by_alias=True, mode="json"))
+
 
 {{#vendorExtensions.x-py-postponed-model-imports.size}}
 {{#vendorExtensions.x-py-postponed-model-imports}}

modules/openapi-generator/src/main/resources/python/model_doc.mustache

@@ -19,14 +19,14 @@ from {{modelPackage}}.{{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}} im
 # TODO update the JSON string below
 json = "{}"
 # create an instance of {{classname}} from a JSON string
-{{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_instance = {{classname}}.from_json(json)
+{{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_instance = {{classname}}.model_validate_json(json)
 # print the JSON string representation of the object
-print({{classname}}.to_json())
+print({{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_instance.model_dump_json(by_alias=True, exclude_unset=True))
 
 # convert the object into a dict
-{{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_dict = {{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_instance.to_dict()
+{{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_dict = {{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_instance.model_dump(by_alias=True)
 # create an instance of {{classname}} from a dict
-{{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_from_dict = {{classname}}.from_dict({{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_dict)
+{{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_from_dict = {{classname}}.model_validate({{#lambda.snakecase}}{{classname}}{{/lambda.snakecase}}_dict)
 ```
 {{/isEnum}}
 {{#isEnum}}