from __future__ import annotations import pprint import re # noqa: F401 import json {{#vendorExtensions.x-py-other-imports}} {{{.}}} {{/vendorExtensions.x-py-other-imports}} {{#vendorExtensions.x-py-model-imports}} {{{.}}} {{/vendorExtensions.x-py-model-imports}} from pydantic import TypeAdapter from typing import Optional, Set from typing_extensions import Self {{#hasChildren}} {{#discriminator}} {{! If this model is a super class, importlib is used. So import the necessary modules for the type here. }} from typing import TYPE_CHECKING if TYPE_CHECKING: {{#mappedModels}} from {{packageName}}.models.{{model.classFilename}} import {{modelName}} {{/mappedModels}} {{/discriminator}} {{/hasChildren}} _JSON_ADAPTER = TypeAdapter(Dict[str, Any]) class {{classname}}({{#parent}}{{{.}}}{{/parent}}{{^parent}}BaseModel{{/parent}}): """ {{#description}}{{{description}}}{{/description}}{{^description}}{{{classname}}}{{/description}} """ # noqa: E501 {{#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}} @field_validator('{{{name}}}') def {{{name}}}_validate_regular_expression(cls, value): """Validates the regular expression""" {{^required}} if value is None: return value {{/required}} {{#required}} {{#isNullable}} if value is None: return value {{/isNullable}} {{/required}} if not re.match(r"{{{.}}}", value{{#vendorExtensions.x-modifiers}} ,re.{{{.}}}{{/vendorExtensions.x-modifiers}}): raise ValueError(r"must validate the regular expression {{{vendorExtensions.x-pattern}}}") return value {{/vendorExtensions.x-regex}} {{#isEnum}} @field_validator('{{{name}}}') def {{{name}}}_validate_enum(cls, value): """Validates the enum""" {{^required}} if value is None: return value {{/required}} {{#required}} {{#isNullable}} if value is None: return value {{/isNullable}} {{/required}} {{#isContainer}} {{#isArray}} for i in value: if i not in set([{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}}]): raise ValueError("each list item must be one of ({{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}})") {{/isArray}} {{#isMap}} for i in value.values(): if i not in set([{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}}]): raise ValueError("dict values must be one of enum values ({{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}})") {{/isMap}} {{/isContainer}} {{^isContainer}} if value not in set([{{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}}]): raise ValueError("must be one of enum values ({{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}})") {{/isContainer}} return value {{/isEnum}} {{/vars}} model_config = ConfigDict( populate_by_name=True, validate_assignment=True, protected_namespaces=(), ) {{#hasChildren}} {{#discriminator}} # JSON field name that stores the object type __discriminator_property_name: ClassVar[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, Any]) -> Optional[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""" return _JSON_ADAPTER.dump_json(self.to_dict()).decode() @classmethod def from_json(cls, json_str: str) -> Optional[{{^hasChildren}}Self{{/hasChildren}}{{#hasChildren}}{{#discriminator}}Union[{{#mappedModels}}{{{modelName}}}{{^-last}}, {{/-last}}{{/mappedModels}}]{{/discriminator}}{{^discriminator}}Self{{/discriminator}}{{/hasChildren}}]: """Create an instance of {{{classname}}} from a JSON string""" return cls.from_dict(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}} """ excluded_fields: Set[str] = set([ {{#vendorExtensions.x-py-readonly}} "{{{.}}}", {{/vendorExtensions.x-py-readonly}} {{#isAdditionalPropertiesTrue}} "additional_properties", {{/isAdditionalPropertiesTrue}} ]) _dict = self.model_dump( by_alias=True, exclude=excluded_fields, 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_{{{name}}} in self.{{{name}}}: if _item_{{{name}}}: _items.append( [_inner_item.to_dict() for _inner_item in _item_{{{name}}} 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_{{{name}}} in self.{{{name}}}: if _item_{{{name}}}: _items.append(_item_{{{name}}}.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_{{{name}}} in self.{{{name}}}: if self.{{{name}}}[_key_{{{name}}}] is not None: _field_dict_of_array[_key_{{{name}}}] = [ _item.to_dict() for _item in self.{{{name}}}[_key_{{{name}}}] ] _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_{{{name}}} in self.{{{name}}}: if self.{{{name}}}[_key_{{{name}}}]: _field_dict[_key_{{{name}}}] = self.{{{name}}}[_key_{{{name}}}].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 {{#hasChildren}} @classmethod def from_dict(cls, obj: Dict[str, Any]) -> Optional[{{#discriminator}}Union[{{#mappedModels}}{{{modelName}}}{{^-last}}, {{/-last}}{{/mappedModels}}]{{/discriminator}}{{^discriminator}}Self{{/discriminator}}]: """Create an instance of {{{classname}}} from a dict""" {{#discriminator}} # look up the object type based on discriminator mapping object_type = cls.get_discriminator_value(obj) {{#mappedModels}} if object_type == '{{{modelName}}}': return import_module("{{packageName}}.models.{{model.classFilename}}").{{modelName}}.from_dict(obj) {{/mappedModels}} 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}} @classmethod def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: """Create an instance of {{{classname}}} from a dict""" 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}} "{{{name}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}} {{/items.items.isPrimitiveType}} {{^items.items.isPrimitiveType}} "{{{name}}}": [ [{{{items.items.dataType}}}.from_dict(_inner_item) for _inner_item in _item] for _item in obj["{{{baseName}}}"] ] if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}} {{/items.items.isPrimitiveType}} {{/items.isArray}} {{^items.isArray}} {{^items.isPrimitiveType}} {{#items.isEnumOrRef}} "{{{name}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}} {{/items.isEnumOrRef}} {{^items.isEnumOrRef}} "{{{name}}}": [{{{items.dataType}}}.from_dict(_item) for _item in obj["{{{baseName}}}"]] if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}} {{/items.isEnumOrRef}} {{/items.isPrimitiveType}} {{#items.isPrimitiveType}} "{{{name}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}} {{/items.isPrimitiveType}} {{/items.isArray}} {{/isArray}} {{#isMap}} {{^items.isPrimitiveType}} {{^items.isEnumOrRef}} {{#items.isContainer}} {{#items.isMap}} "{{{name}}}": 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}} "{{{name}}}": 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}} "{{{name}}}": dict( (_k, {{{items.dataType}}}.from_dict(_v)) for _k, _v in obj["{{{baseName}}}"].items() ) if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}} {{/items.isContainer}} {{/items.isEnumOrRef}} {{#items.isEnumOrRef}} "{{{name}}}": dict((_k, _v) for _k, _v in obj.get("{{{baseName}}}").items()) if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}} {{/items.isEnumOrRef}} {{/items.isPrimitiveType}} {{#items.isPrimitiveType}} "{{{name}}}": obj.get("{{{baseName}}}"){{^-last}},{{/-last}} {{/items.isPrimitiveType}} {{/isMap}} {{/isContainer}} {{^isContainer}} {{^isPrimitiveType}} {{^isEnumOrRef}} "{{{name}}}": {{{dataType}}}.from_dict(obj["{{{baseName}}}"]) if obj.get("{{{baseName}}}") is not None else None{{^-last}},{{/-last}} {{/isEnumOrRef}} {{#isEnumOrRef}} "{{{name}}}": obj.get("{{{baseName}}}"){{#defaultValue}} if obj.get("{{baseName}}") is not None else {{defaultValue}}{{/defaultValue}}{{^-last}},{{/-last}} {{/isEnumOrRef}} {{/isPrimitiveType}} {{#isPrimitiveType}} {{#defaultValue}} "{{{name}}}": obj.get("{{{baseName}}}") if obj.get("{{{baseName}}}") is not None else {{{defaultValue}}}{{^-last}},{{/-last}} {{/defaultValue}} {{^defaultValue}} "{{{name}}}": 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}} {{#vendorExtensions.x-py-postponed-model-imports.size}} {{#vendorExtensions.x-py-postponed-model-imports}} {{{.}}} {{/vendorExtensions.x-py-postponed-model-imports}} # TODO: Rewrite to not use raise_errors {{classname}}.model_rebuild(raise_errors=False) {{/vendorExtensions.x-py-postponed-model-imports.size}}