o ɝi9 @s"UdZddlmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZmZmZmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZmZm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)ddl*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mZ>ddl?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZIddl?mJZJmKZKmLZLmMZMmNZNddlOmPZPddlQmRZRmSZSmTZTddlUmVZVmWZWddlXmYZYmZZZddl[m\Z\m]Z]m^Z^m_Z_ddl`maZambZbmcZcddldmeZemfZfmgZgmhZhmiZiddljmkZkddllmmZmddlmnZnmoZompZpmqZqd d!lrmsZsmtZtmuZumvZvmwZwd d"lxmyZymzZzd d#l{m|Z|m}Z}d d$l~mZmZmZd d%lsmZmZmZmZmZmZmZmZmZmZmZmZd d&lmZd d'lmZmZmZmZmZd d(lmZd d)lmZmZd d*lmZmZd d+lmZd d,lmZmZd d-lmZmZd d.lmZd d/lmZmZe1rdd0lmZmZdd1lmZdd2l,mZd d3lmZd d4lmZe jd5kZe8eeefZe7d6ed7Ze8eeeeeefZeYZd8ed9<e3e2egeHjBfZd8ed:<d;Zd8ed<<e jegZd=ed><e jeejjgZd=ed?<e jeejjgZd=ed@<e jeejjgZd=edA<e jegZd=edB<e"e#e$e%e&e'gZd=edC<e jejjgZd=edD<e jejje jejjgZd=edE<e jegZd=edF<e je jgZd=edG<e je je je je je jgZd=edH<e je jejjejjeje?je jejgZeje jgZeje jgZd=edI<e8e/e-e0efZeLeZdJdKdLdMeFfdNdOdPdQdRdSdTdUdVg ZdWedX< efeeeheidYZdZed[<ddbdcZddidjZddndoZddtduZddxdyZeee2e^fZdddZGdddeZGdddZdddddddddddddddddZded<dddZdddZdddZdddZdddZdddZdddZdddZGdddZGdddZGdddZdS)z-Convert python types to pydantic-core schema.) annotationsN) GeneratorIterableIteratorMapping)contextmanagercopy)Decimal)Enum)Fraction)partial) Parameter_ParameterKind signature) IPv4Address IPv4Interface IPv4Network IPv6Address IPv6Interface IPv6Network)chain) attrgetter) FunctionType GenericAlias LambdaType MethodType) TYPE_CHECKINGAnyCallableFinal ForwardRefLiteralTypeVarUnioncastoverload)UUID)ZoneInfo) MISSING CoreSchema MultiHostUrlPydanticCustomError$PydanticSerializationUnexpectedValuePydanticUndefinedUrl core_schemato_jsonable_python) TypeAlias TypeAliasTypeget_args get_origin is_typeddict)typing_objects)AnnotationSourceget_literal_valuesis_union_origin) AliasChoices AliasPath)GetCoreSchemaHandlerGetJsonSchemaHandler) ConfigDictJsonDict JsonEncoderJsonSchemaExtraCallable)PydanticSchemaGenerationErrorPydanticUndefinedAnnotationPydanticUserError)AfterValidatorBeforeValidatorFieldValidatorModesPlainValidator WrapValidator)JsonSchemaValue) version_short)ArbitraryTypeWarningPydanticDeprecatedSince20TypedDictExtraConfigWarning UnsupportedFieldAttributeWarning) _decorators_discriminated_union_known_annotated_metadata_repr _typing_extra) ConfigWrapperConfigWrapperStack) CoreMetadataupdate_core_metadata)get_ref get_type_ref%is_list_like_schema_with_items_schema) DecoratorDecoratorInfosFieldSerializerDecoratorInfoFieldValidatorDecoratorInfoModelSerializerDecoratorInfoModelValidatorDecoratorInfoRootValidatorDecoratorInfoValidatorDecoratorInfoget_attribute_from_basesinspect_field_serializerinspect_model_serializerinspect_validator)extract_docstrings_from_cls)collect_dataclass_fieldsrebuild_dataclass_fieldsrebuild_model_fieldstakes_validated_data_argumentupdate_field_from_config)PydanticRecursiveRef)get_standard_typevars_map replace_types)import_cached_base_modelimport_cached_field_info)MockCoreSchema)NamespacesTuple NsResolver)MissingDefinitionErrorgather_schemas_for_cleaning)CallbackGetCoreSchemaHandler)lenient_issubclasssmart_deepcopy)ComputedFieldInfo FieldInfo BaseModel) Discriminator)StandardDataclass)GetJsonSchemaFunction) FieldDecoratorInfoType)boundr2ModifyCoreSchemaWrapHandlerGetCoreSchemaFunctionz1Callable[[int, str, Any], Literal['skip'] | None]ParametersCallbackz list[type] TUPLE_TYPES LIST_TYPES SET_TYPESFROZEN_SET_TYPES DICT_TYPESIP_TYPESSEQUENCE_TYPESITERABLE_TYPES TYPE_TYPES PATTERN_TYPES PATH_TYPES DEQUE_TYPES)aliasN)validation_aliasN)serialization_aliasNdefault)default_factoryN)excludeN) deprecatedN)reprT)validate_defaultN)frozenN)initN)init_varN)kw_onlyNlist[tuple[str, Any]]+UNSUPPORTED_STANDALONE_FIELDINFO_ATTRIBUTES)beforeafterplainwrapzbdict[FieldValidatorModes, type[BeforeValidator | AfterValidator | PlainValidator | WrapValidator]]_mode_to_validatorinfoFieldDecoratorInfofieldstrreturnboolcCs|j}d|vp ||vS)zCheck if field name is in validator fields. Args: info: The field info. field: The field name to check. Returns: `True` if field name is in validator fields, `False` otherwise. *)fields)rrrr_/var/www/html/ocr-read/venv/lib/python3.10/site-packages/pydantic/_internal/_generate_schema.py)check_validator_fields_against_field_names r decoratorsIterable[AnyFieldDecorator]r Iterable[str]NonecCsft|}|D]*}d|jjvrq|jjdurq|jjD]}||vr/td|jd|jdddqqdS) avCheck if the defined fields in decorators exist in `fields` param. It ignores the check for a decorator if the decorator has `*` as field or `check_fields=False`. Args: decorators: An iterable of decorators. fields: An iterable of fields name. Raises: PydanticUserError: If one of the field names does not exist in `fields` param. rFz*Decorators defined with incorrect fields: .zO (use check_fields=False if you're inheriting from the model and intended this)zdecorator-missing-fieldcodeN)setrr check_fieldsrFcls_ref cls_var_name)rrdecrrrrcheck_decorator_fields_exists    rvalidator_functions+Iterable[Decorator[FieldDecoratorInfoType]]'list[Decorator[FieldDecoratorInfoType]]csfdd|DS)Ncsg|] }t|jr|qSr)rr).0rrrr z8filter_field_decorator_info_by_field..r)rrrrr$filter_field_decorator_info_by_fieldsrschemacore_schema.CoreSchemaeach_item_validators'list[Decorator[ValidatorDecoratorInfo]]cCs|s|S|ddkrt|d||d<|S|ddkr3|d}dur1t|d|||d|<|St|rH|dt}t|||d<|S|ddkr_|dt}t|||d<|Std |d) Ntypenullablertuplevariadic_item_index items_schemadict values_schemazO`@validator(..., each_item=True)` cannot be applied to fields with a schema of )apply_each_item_validatorsgetapply_validatorsr^r0 any_schema TypeError)rrr inner_schemarrrrs.      rFieldInfo | ComputedFieldInfoAtuple[JsonDict | None, JsonDict | JsonSchemaExtraCallable | None]cCsL|j|jt|jp|jdkpdt|jd}dd|D}|p"d|jfS)N)title descriptionrexamplescSi|] \}}|dur||qSNrrkvrrr "z=_extract_json_schema_info_from_field_info..)rrrrr1ritemsjson_schema_extra)rjson_schema_updatesrrr)_extract_json_schema_info_from_field_infosr json_encodersJsonEncoders | Nonetprr*cCs|s|Sd|vr |S|gt|d|jjddRD]#}||}|dur&qtdtdttj |dd|d<|S|S) aIterate over the json_encoders and add the first matching encoder to the schema. Args: json_encoders: A dictionary of types and their encoder functions. tp: The type to check for a matching encoder. schema: The schema to add the encoder to. serialization__mro__Nz=`json_encoders` is deprecated. See https://docs.pydantic.dev/zZdd?d@ZddDdEZddGdHZddKdLZddMdNZddQdRZddSdTZeddXdYZ edd[dYZ ddd]dYZ dd^d_Z!d dadbZ"ddcddZ#ddedfZ$d dhdiZ%djdkd dsdtZ&d dvdwZ'd dydzZ(dd|d}Z)dddZ*dddZ+dddZ,dddZ-dddZ.e/j0dfdddZ1e/j0fdddZ2dddZ3dddZ4dddZ5dddZ6dddZ7dddZ8dddZ9dddZ:dddZ;dddZ<dddZ= ddddZ> dd ddZ?d!ddńZ@d"dd̄ZAd#ddτZBddфdjfd$ddلZC jd%d&dd܄ZDd'ddބZEd(ddZF \dd)ddZGd*ddZHd+ddZIZJS(,GenerateSchemaz\Generate core schema for a Pydantic model, dataclass and types like `str`, `datetime`, ... .)_config_wrapper_stack _ns_resolver _typevars_mapfield_name_stackmodel_type_stackdefsNconfig_wrapperrX ns_resolverNsResolver | None typevars_mapMapping[TypeVar, Any] | NonerrcCs8t||_|p t|_||_t|_t|_t |_ dSr) rYrrxrr_FieldNameStackr_ModelTypeStackr  _Definitionsr )selfr r rrrr__init__[s   zGenerateSchema.__init__csttjdtdddS)NzeSubclassing `GenerateSchema` is not supported. The API is highly subject to change in minor versions.r;) stacklevel)super__init_subclass__rr UserWarning)clsrrrris  z GenerateSchema.__init_subclass__cC|jjSr)rtailrrrr_config_wrapperqzGenerateSchema._config_wrapperrwcCrr)rtypes_namespacerrrr_types_namespaceurzGenerateSchema._types_namespacercCrr)rarbitrary_types_allowedrrrr_arbitrary_typesyrzGenerateSchema._arbitrary_types items_typerr*cCt||Sr)r0 list_schemagenerate_schemarr$rrr _list_schemazGenerateSchema._list_schema keys_type values_typecCst||||Sr)r0 dict_schemar')rr+r,rrr _dict_schemaszGenerateSchema._dict_schemacCr%r)r0 set_schemar'r(rrr _set_schemar*zGenerateSchema._set_schemacCr%r)r0frozenset_schemar'r(rrr_frozenset_schemar*z GenerateSchema._frozenset_schema enum_type type[Enum]csNtjtjsdntj}|dkrd}j|dddDdt t r:dt d}n!t t rGdt d}nt trTdt d}nt dd }rdfdd }tjddtjju}t j|rxdnjd|gid}|jjrt jtd||d}|Sdfdd }t jd|gidS)NzAn enumeration.)rrcSrrrrrrrrrz/GenerateSchema._enum_schema..intrfloatcS|Srrxrrrz-GenerateSchema._enum_schema..rr*handlerr?rrLcs ||}||}||Sr)resolve_ref_schemaupdate)rr< json_schemaoriginal_schema) js_updatesrrget_json_schemas  z4GenerateSchema._enum_schema..get_json_schema__func__pydantic_js_functions)sub_typemissingrefmetadatavalue)rcs.|tjd}||}||S)N)rErG)r0 enum_schemar=r>)_r<r?r@casesenum_refr3rArErrget_json_schema_no_casess  z=GenerateSchema._enum_schema..get_json_schema_no_casesrH)rr*r<r?rrL)r<r?rrL)list __members__valuesr]rinspectcleandocrr issubclassr5r0simple_ser_schemarr6rr _missing_r rCrJruse_enum_values no_info_after_validator_functionris_instance_schema)rr3rvalue_ser_typerBdefault_missingrJrOrrLr _enum_schemasN           zGenerateSchema._enum_schemarc sddlm}m}tdtdtdtdtdtdidfdd }t j t |t j t t t dt j|ddddfddgidS)NrR)IP_VALIDATOR_LOOKUPIpTypeipv4 ipv4network ipv4interfaceipv6 ipv6network ipv6interfaceiprrcore_schema.SerializationInfor str | IpTypecDt|tfstddt|d|d|jdkr|St|SNz Expected `z ` but got `z` with value `'z-'` - serialized value may not be as expected.python isinstancerr-rmode)rgrrrrser_ip z)GenerateSchema._ip_schema..ser_ipr? python_schemaTalwaysinfo_argrrDcsddS)Nstringrformatr_1_2ip_type_json_schema_formatrrrr:z+GenerateSchema._ip_schema.. lax_schema strict_schemarrH)rgrrrhrri) _validatorsr_r`rrrrrrr0lax_or_strict_schema no_info_plain_validator_functionjson_or_python_schemarZ str_schemar[r)rrr_r`rqrr~r _ip_schemas&  zGenerateSchema._ip_schema path_typec stjurtthvrtstdddtjurtjntur*t j ddnt j dd}tur8t nt }dfd d }dfdd }t j t ||t d}t jt j|t ||gddd|t j|ddddddgid}|S)Nz;`os.PathLike` can only be used with `str`, `bytes` or `Any`zschema-for-unknown-typerTstrict input_value str | bytesros.PathLike[Any]c sz6tur(t|tr#z|}Wn!ty"}ztdd|d}~wwtddt|ts2tdd|WStyH}ztdd|d}~ww)N bytes_typezInput must be valid byteszInput must be bytesrzInput is not a valid path)bytesrndecodeUnicodeDecodeErrorr,rr)re)path_constructorrrrpath_validators"        z3GenerateSchema._path_schema..path_validatorpathrrrhstr | os.PathLike[Any]crjrkrm)rrrprrser_pathrrz-GenerateSchema._path_schema..ser_pathrsrzInput is not a valid path for custom_error_typecustom_error_messagerurvrDcSsi||ddiS)Nrzrr)sourcer<rrrr:*z-GenerateSchema._path_schema..r)rrrr)rrrrhrr)osPathLikerrr7is_anyrFpathlibPurePathr0 bytes_schemarrrZr[r union_schemar) rrrstrict_inner_schemalax_inner_schemarrinstance_schemarr)rrrr _path_schemas6     zGenerateSchema._path_schemacCs|ddlm}ddlm}||}tj|dd}tj|tjt j ddd}t ||}tj |t ||gtj||d d d S) NrRserialize_sequence_via_list)deque_validatorFrDequecls_reprrsTrrwrrr) _serializersrrrr'r0r&rr[ collectionsdequeno_info_wrap_validator_functionr chain_schema#wrap_serializer_function_ser_schema)rr$rritem_type_schemar&check_instancerrrr _deque_schema.s     zGenerateSchema._deque_schemacCsddlm}m}m}||}||}ttjdtd||} Wdn1s.wYt j || dd} |t urC| } | St j | t |d} |tjura||} tt jt|| d}ntt j|}|| }t | |g}t j||t jd d | dd d } | S) NrR)MAPPING_ORIGIN_MAPdefaultdict_validator'get_defaultdict_default_default_factoryignorecategoryFrrs)default_default_factorycSs||Srr)rhrrrr:osz0GenerateSchema._mapping_schema..rr)rrrrr'rcatch_warnings simplefilterrQr0r-rrr[r defaultdictr rrZrrr)rrr+r,rrr mapped_origin keys_schemarr-rrrcoerce_instance_wraprrrrr_mapping_schemaGs@        zGenerateSchema._mapping_schemacCsLddlm}tjt|tjt|ttdtjdddddgid S) z7Support for [`fractions.Fraction`][fractions.Fraction].rR)fraction_validatorrsrurrDcS dddS)Nrxfractionryrr{rrrr: z1GenerateSchema._fraction_schema..r) rrr0rrrr[r to_string_ser_schema)rrrrr_fraction_schemaus   zGenerateSchema._fraction_schemacCs.t|tst|dttSt|S)Na is not a Python type (it may be an instance of an object), Pydantic will allow any object with no validation since we cannot even enforce that the input is an instance of the given type. To get rid of this error wrap the type with `pydantic.SkipValidation`.)rnrrrrNr0rr[)rrrrr_arbitrary_type_schemas  z%GenerateSchema._arbitrary_type_schemaobjcCstd|d)N,Unable to generate pydantic-core schema for a. Set `arbitrary_types_allowed=True` in the model_config to ignore this error or implement `__get_pydantic_core_schema__` on your type to fully support it. If you got this error by calling handler() within `__get_pydantic_core_schema__` then you likely need to call `handler.generate_schema()` since we do not call `__get_pydantic_core_schema__` on `` otherwise to avoid infinite recursion.)rDrrrrr_unknown_type_schemas z#GenerateSchema._unknown_type_schemar discriminatorstr | Discriminator | NonecCsF|dur|Sz t|||jjWStjy"t|||YSwr)rTapply_discriminatorr  _definitionsMissingDefinitionForUnionRefset_discriminator_in_metadata)rrrrrr_apply_discriminator_to_unionsz,GenerateSchema._apply_discriminator_to_unioncC |j|Sr)r finalize_schema)rrrrr clean_schemas zGenerateSchema.clean_schemametadata_schema js_functionCallable[..., Any]cCs6|di}|dg}||vr||||d<dS)NrHrD)r setdefaultappend)rrrrHrDrrr_add_js_functions    zGenerateSchema._add_js_functionrcCs^|||}|dur||}t|}|dur%t||j}|r%|||t|jj||}|S)aXGenerate core schema. Args: obj: The object to generate core schema for. Returns: The generated core schema. Raises: PydanticUndefinedAnnotation: If it is not possible to evaluate forward reference. PydanticSchemaGenerationError: If it is not possible to generate pydantic-core schema. TypeError: - If `alias_generator` returns a disallowed type (must be str, AliasPath or AliasChoices). - If V1 style validator with `each_item=True` applied on a wrong field. PydanticUserError: - If `typing.TypedDict` is used instead of `typing_extensions.TypedDict` on Python < 3.12. - If `__modify_schema__` method is used instead of `__get_pydantic_json_schema__`. N) '_generate_schema_from_get_schema_method_generate_schema_inner!_extract_get_pydantic_json_schemaresolve_original_schemar rrrr)rrrmetadata_js_functionrrrrr's    zGenerateSchema.generate_schemartype[BaseModel]c s\t}j|\}}|dur|WdS|jd}|durQt|tsQ|ddkr5j|}t|}|rHj |WdS|WdSt |j dd}j |j |jj|jd}|jsw||ur~t|di} n3d|jvrt|jd |jd d zt|jjjpid } Wnty} zt| | d} ~ ww|jj} ttjjj h| !| !j"} d} d}|d dkrZ|j#d|usJ|j#dt$usJ|j#ddD]^}t|didd}|durYt|t%r"t&j't&j(|dddgj)R}t*|}|t+vr/t,dj-|dd\}}|t%urB.|}t/0|sM.|} |dusW| durYnqt|did}|j1r2d| d\}}t3|| d}t4j5|||t|dddt|dd||d}nBt4j6fdd| 7Dfd d!| D| ||jd"}t8|j9}t3|| d}t4j5|||t|dddt|dd||d}:|j;}t3|| d#}j |WdWdWdS1swYWdn1swYWddSWddS1s'wYdS)$z%Generate schema for a Pydantic model.N__pydantic_core_schema__r definitionsF)checkr__pydantic_fields__zClass z is not defined)namemessager r rextra_fields_behaviorallowrr__annotations____pydantic_extra__T) is_argumentis_classzEThe type annotation for `__pydantic_extra__` must be `dict[str, ...]`required__pydantic_generic_metadata__originrootinner__pydantic_custom_init____pydantic_post_init__)generic_origin custom_init root_model post_initconfigrGcs i|] \}}|||qSr)_generate_md_field_schemarrrrrrXs z0GenerateSchema._model_schema..cg|] }|jqSr_computed_field_schemafield_serializersrdrrrrY z0GenerateSchema._model_schema..)computed_fields extras_schemaextras_keys_schema model_nameouter).)rtrr:rCr rr{rrr\r pydantic.v1rrVrrrrrOr0r) rrrr/ get_schemais_base_model_get_schemarKr1r<rrGr  BaseModelV1rrrrysL        z6GenerateSchema._generate_schema_from_get_schema_methodc Cspz tj|g|jR}Wnty}zt||d}~wwt|tr-t|jd||j r6t ||j }|S)Nz%Unable to evaluate forward reference ) rWr$r!rrErrnr!__forward_arg__rrs)rrrrrr_resolve_forward_refs   z#GenerateSchema._resolve_forward_refr Literal[True]tuple[Any, ...]cCdSrr)rrrrrrr&z/GenerateSchema._get_args_resolving_forward_refstuple[Any, ...] | NonecCrJrrrrrrr&rKFcsVt|}|rt|trdd|D}tfdd|D}|S|r)td|d|S)Ncss(|]}t|trt|n|VqdSr)rnrrWr%rarrr &zBGenerateSchema._get_args_resolving_forward_refs..c3s(|]}t|tr|n|VqdSr)rnr!rGrMrrrrOrPz Expected z+ to have generic parameters but it had none)r4rnrrr)rrrargsrrrr&s cCs||}|s tS|dS)Nr)r&r)rrrQrrr_get_first_arg_or_anys z$GenerateSchema._get_first_arg_or_anytuple[Any, Any]cCsJ||}|s ttfSt|dkrt|}td|d|d|dfS)Nr;z Expected two type arguments for z, got 1rrR)r&rlenr5r)rrrQrrrr_get_first_two_args_or_anys  z)GenerateSchema._get_first_two_args_or_anycCst|r ||}tt|r||St|tr|St|tr&t |}t|t r3| | |St }t ||rV|j| ||WdS1sQwYt|trbtj|jdS||S)N) schema_ref)r7is_selfr8 is_annotatedr5_annotated_schemarnrrr!r'rGrtr|r rr7rqr0definition_reference_schematype_ref match_type)rrrrrrrs$         z%GenerateSchema._generate_schema_innercCs|turtS|turtS|turtS|tur tS|t ur(t S|t ur0t St |s9|tur=tS|tjurFtS|tjurOtS|tjurXtS|tjuratS|turitS|turqtS|turytS|tur| S|t!urt"S|dus|t#j$urt%S|t&urt'S|t(vr|)|S|t*vr|+|S|t,vr|-t.S|t/vr|0t.S|t1vr|2t.S|t3vr|4t.S|t5vr|6|S|t7vr|8t.t.S|t9vr|:|t.S|t;vr||t.t.S|t?vr|>|t.tSt @|r|A|S|tBur&|CSt#D|r0tESt FtG|r=|H|StI|rH|J|dSt#K|rT|L|dSt M|r`|N|jOS|tPvrj|Q|St#R|rt|SStT|tUjVr|W|St#X|r|tYurtS|N|Z|StT|t[r|\|St]^|rt_|t`r|a|S|tbur|cStde|r|f|dStG|}|dur|g||S|jhr|i|S|j|S)aMain mapping of types to schemas. The general structure is a series of if statements starting with the simple cases (non-generic primitive types) and then handling generics and other more complex cases. Each case either generates a schema directly, calls into a public user-overridable method (like `GenerateSchema.tuple_variable_schema`) or calls into a private method that handles some boilerplate before calling into the user-facing method (e.g. `GenerateSchema._tuple_schema`). The idea is that we'll evolve this into adding more and more user facing methods over time as they get requested and we figure out what the right API for them is. N)krr0rrrr5 int_schemar6 float_schemar bool_schemacomplexcomplex_schemar7rr#rdatetimedate date_schemadatetime_schematime time_schema timedeltatimedelta_schemar decimal_schemar' uuid_schemar/ url_schemar rr+multi_host_url_schemarWNoneType none_schemar)missing_sentinel_schemarrr _tuple_schemarr)rrr0rr2r_sequence_schemar_iterable_schemarr.rrrr MAPPING_TYPESr COUNTER_TYPESis_typealiastype_type_alias_type_schemar _type_schema is_callablecallable_schema is_literalr5_literal_schemar6_typed_dict_schema is_namedtuple_namedtuple_schema is_newtyper' __supertype__r_pattern_schema is_hashable_hashable_schemarntypingr#_unsubstituted_typevar_schema is_finalvarr rRVALIDATE_CALL_SUPPORTED_TYPES _call_schemarTisclassrVr r^r(_zoneinfo_schema dataclasses is_dataclass_dataclass_schema_match_generic_typer#rr)rrrrrrr\s                                            zGenerateSchema.match_typercCst|r |||St|r|||S|||}|dur"|St|r,| |St |r5| |S|t vr>| |S|tvrJ|||S|tvrV|||S|tvrb|||S|tvrn|j||S|tvr{||||S|tvr|||S|tvr|j|g||RS|tvr||||tSt |r|!||S|t"vr|#|S|t$vr|%||S|t&vr|'|S|t(vr|)|S|j*r|+|S|,|Sr)-rrrrWr~rrr7rvrwr: _union_schemarrqrr)rRrr0rr2rr.rUrrrrrtrrur5r6r}r_subclass_schemarrrrrsrrr#rr)rrrrrrrr~sT               z"GenerateSchema._match_generic_typeTrrr field_inforrr`core_schema.TypedDictFieldc CsB||||\}}tj||sdn||jt|j|j|j|dS)zAPrepare a TypedDictField to represent a model or typeddict field.F)rserialization_excluderrserialization_exclude_ifrH) r(r0typed_dict_field is_requiredr_convert_to_aliasesrr exclude_if)rrrrrrrHrrr_generate_td_field_schemas z(GenerateSchema._generate_td_field_schemacore_schema.ModelFieldc Cs8||||\}}tj||jt|j|j|j|j|dS)z0Prepare a ModelField to represent a model field.)rrrrrrH) r(r0 model_fieldrrrrrrrrrrrrHrrrrsz(GenerateSchema._generate_md_field_schemacore_schema.DataclassFieldc CsR||||\}}tj|||j|jpd|jrdnd|jt|j|j |j |j |d S)zJPrepare a DataclassField to represent the parameter/field, of a dataclass.NF) r init_onlyrrrrrrrH) r(r0dataclass_fieldrrrrrrrrrrrrr_generate_dc_field_schemas z(GenerateSchema._generate_dc_field_schema!tuple[CoreSchema, dict[str, Any]]c s6jj}}d fdd }ddt|j|D}j| jdur3j||||d}n|||}Wdn1sEwYt|j |} t | rYd _ d d| Dfd d| D} t |}t || }s|t|}|t|j|}t\} } i} t| | | d || fS)Nrr*rcs|j}|Sr)rr)r)rrrrset_discriminatorsz>GenerateSchema._common_field_schema..set_discriminatorcSsg|] }t|jj|qSr)rrro_from_decorator)r decoratorrrrrsz7GenerateSchema._common_field_schema..)transform_inner_schemaTcSsg|] }|jjdur|qST)r each_itemr@rrrrrcsg|]}|vr|qSrrr@)rrrrspydantic_js_updatespydantic_js_extrarr*rr*) annotationrHrrrSrrr_apply_annotationsr $_validators_require_validate_defaultrrrr wrap_default_apply_field_serializersr rr[) rrrr source_typerrvalidators_from_decoratorsrthis_field_validatorsrr core_metadatar)rrrrr(sD      z#GenerateSchema._common_field_schema union_typec Cs|j|dd}g}d}|D]}|dus|tjurd}q |||q t|dkr/|d}n)g}|D]}tt|did} | durM||| fq3||q3t |}|r_t |}|S) zGenerate schema for a Union.TrFNrRrrHpydantic_internal_union_tag_key) r&rWrnrr'rTr%rZrr0rnullable_schema) rrrQchoicesrargschoices_with_tagschoicetagrrrr&s&     zGenerateSchema._union_schemar3c Cs|j|s\}}|dur|WdSt|p|}t|}|j|>z tj|jg|j R}Wnt yF}zt ||d}~wwt ||}||}|ddksYJ||d<Wdn1sgwY|j|WdS1s|wYdS)NrrrG)r rr5rrrrrW eval_type __value__r!rrErrsr'r) rrrGr1rrrrrrrrrwAs(      $z&GenerateSchema._type_alias_type_schema literal_typecCs\tt|ddd}|sJd|t|}|jjr,tdd|Dr,tdd|}|S) zGenerate schema for a Literal.Feager) type_checkunpack_type_aliasesz(literal "expected" cannot be empty, obj=css|]}t|tVqdSr)rnr r@rrrrOZz1GenerateSchema._literal_schema..cSst|tr|jS|Sr)rnr rI)rrrrr:\rz0GenerateSchema._literal_schema..)rQr9r0literal_schemarrYanyrZ)rrexpectedrrrrr|Ts zGenerateSchema._literal_schematyped_dict_clscst}j|j|\}}|dur)|WdWdSt|}|dur3|}tsBt|jdkrBt dddzt |d}Wn t yTd}Ynwj |qj j|jd}|j} i} t|j j jrt|dd } nd} z tj|jd } Wnty} zt| | d} ~ wwg}| D]O\}}|j|tjd }t |j!||_!|| vpd |j"vod |j"v}d|j"vr|#|| dur|j$dur|| vr| ||_$t%j ||j&|||d| |<q|r&d'dd|D}t(|dk}t)*d|rdndd|d|jd|rdndd t+d}d}t,t-|dd}t-|dt.j/}|rAd }d}nt01|sQd!}2t ||}j j3}d"vr|ro|d!krot)j*d#|j4d$t5d%nt01|s|d krt)j*d#|j4d&t5d%n|}t6j7| |fd'd(j89D||||d)}:|j;9}t<|j=9d*}j>|WdWdWdS1swYWdn1swYWddSWddS1swYdS)+a,Generate a core schema for a `TypedDict` class. To be able to build a `DecoratorInfos` instance for the `TypedDict` class (which will include validators, serializers, etc.), we need to have access to the original bases of the class (see https://docs.python.org/3/library/types.html#types.get_original_bases). However, the `__orig_bases__` attribute was only added in 3.12 (https://github.com/python/cpython/pull/103698). For this reason, we require Python 3.12 (or using the `typing_extensions` backport). NrzXPlease use `typing_extensions.TypedDict` instead of `typing.TypedDict` on Python < 3.12.ztyped-dict-versionr__pydantic_config__rT) use_inspectr _sourcer not_required read_onlyr, cs|]}t|VqdSrr)rfrrrrOz4GenerateSchema._typed_dict_schema..r;Itemrr z on TypedDict class areiszk using the `ReadOnly` qualifier. Pydantic will not protect items from any mutation on dictionary instances.r __closed__F__extra_items__forbidr)rrzTypedDict class zk is closed, but 'extra' configuration is set to `'allow'`. The 'extra' configuration value will be ignored.rzu allows extra items, but 'extra' configuration is set to `'forbid'`. The 'extra' configuration value will be ignored.crrr r rrrrrz5GenerateSchema._typed_dict_schema..)rrextra_behaviorrrGrall)?rur rr rrr_SUPPORTS_TYPEDDICTrrrFrgAttributeErrorrrrr__required_keys__r`buildupdate_from_configuse_attribute_docstringsrkrWget_cls_type_hintsrrrErrfrom_annotationr8 TYPED_DICTrsr _qualifiersrrrprjoinrTrrrrrtyping_extensions NoExtraItemsr7is_noextraitemsr'extrarrPr0typed_dict_schemarrSr-r.r)r"r)rrrrtyped_dict_refr1rrr required_keysrfield_docstringsrrreadonly_fields field_namerrr fields_reprpluralrr is_closed extra_items config_extra td_schemarrrrr}as                     Tz!GenerateSchema._typed_dict_schemanamedtuple_clsc sTjj\}}|dur$|WdWdSt|dur.|z tjjd}WntyJ}zt ||d}~ww|sTt j t}rafdd|D}tjfdd|Dddid }tj||d }j|WdWdS1swYWddS1swYdS) z!Generate schema for a NamedTuple.Nrcsi|] \}}|t|qSrrsrrrrrrrs z5GenerateSchema._namedtuple_schema..c s0g|]\}}j||tjj|tjdqS))rr)_generate_parameter_schemar8 NAMED_TUPLE_field_defaultsrremptyr)rrrrr sz5GenerateSchema._namedtuple_schema..'pydantic_js_prefer_positional_argumentsTrP)rG)r rr rrrrWrrrrErrfromkeys_fieldsrrr0arguments_schema call_schemar) rrrnamedtuple_refr1rrrrr)rrrrrsD        Rz!GenerateSchema._namedtuple_schemar type[Any]r8rroJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Nonecore_schema.ArgumentsParameterc Cst}|tjur|j||d}n|j|||d}|jdus!Jdt|j|||j ||j |j|gdd}Wdn1sCwY| sQt ||}t j|||t|jd} | S)zGenerate the definition of a field in a namedtuple or a parameter in a function signature. This definition is meant to be used for the `'arguments'` core schema, which will be replaced in V3 by the `'arguments-v3`'. rNz.r)rrr;z&Variable tuples can only have one typerRrcsg|]}|qSr)r'rrrrrrAz0GenerateSchema._tuple_schema..) rrr&rrr0 tuple_schemarEllipsisrTr' ValueError)rrparamsr)rrrrqws     zGenerateSchema._tuple_schemacCstjttdddS)Nis_typezInput should be a typer)r0custom_error_schemar[rrrrrrxs zGenerateSchema._type_schemacCs.ddlm}dddgi}tj|t|dS)z/Generate schema for a zone_info.ZoneInfo objectrR)validate_str_is_valid_iana_tzrDcSr)Nrxzoneinforyrr{rrrr:rz1GenerateSchema._zoneinfo_schema..rrH)rrr0rr)rrrHrrrrs zGenerateSchema._zoneinfo_schemacs&j|dd}tfdd|DS)z*Generate schema for `type[Union[X, ...]]`.Trcg|] }t|qSrr'r)rrQrrrrz.)r&r0r)rrrQrrr_union_is_subclass_schemasz(GenerateSchema._union_is_subclass_schematype_cs0|}t|p |}t|rSt|r"t|j St |rQ|j r=t t |j r7|j St|j S|jrMtfdd|jDSSt t |r\|St|rf|}t|r}td|dtt |dddt|s|durttjStd|t|S) z-Generate schema for a type, e.g. `type[int]`.cr rr!)rcrrrrr"z3GenerateSchema._subclass_schema..z`Subscripting `type[]` with an already parametrized type is not supported. Instead of using type[z ], use type[z].NrzExpected a class, got )rRrWannotated_typer7rrxrvr'rr is_typevar __bound__r:r5r#r0is_subclass_schema__constraints__rrWr8is_generic_aliasrFrVdisplay_as_typerTrrnr)rr$ type_paramrrrrs@               zGenerateSchema._subclass_schemac Csddlm}||}t|}t|}tjtjdd}t |s2ddl m }t |t||g}tj||dd}tj|||dS) z5Generate schema for a Sequence, e.g. `Sequence[int]`.rRrSequencer)sequence_validatorTr)r?rtr)rrr'r0r&r}r[rr.r7rrr/rrrr) rr$rrr&r?rtr/rrrrrrs     zGenerateSchema._sequence_schemacore_schema.GeneratorSchemacCs||}t||S)z$Generate a schema for an `Iterable`.)rRr0generator_schemar')rr$ item_typerrrrss zGenerateSchema._iterable_schema pattern_typecCsddlm}dddgi}tjtddtd}|tjus#|tjur,tj |j ||d S|j |d d d }|t urBtj |j ||d S|turOtj |j||d Std |d)NrR)rrDcSr)Nrxregexryrr{rrrr:rz0GenerateSchema._pattern_schema..patternr)r return_schemarTrrrr)rrr0rrrrPatternrerpattern_either_validatorr&rpattern_str_validatorrpattern_bytes_validatorrD)rr3rrHserrrrrrs0 zGenerateSchema._pattern_schemacCs<tjtjttttjjgttjjddddS)NrsrzInput should be hashable)rrr) r0rrrrr[rabcHashablerrrrr s zGenerateSchema._hashable_schema dataclasstype[StandardDataclass]type[StandardDataclass] | Nonecsj|j|\}}|dur&|WdWdS|jd}|durkt|tsk|ddkrAj|}t |}|r[j |WdWdS|WdWdSt |}|duru|}t |dd}ddl m} j|2j|| |r|rdd |jD} |r| D] } | j|gjRqn)zt|jj|pid } Wnty} zt| | d} ~ wwt||jd } jjd kr| D]\} } | jd urtd| dddq|jddurt !|"jt#fdd| Dddd}t$|d}t$|d}t%j&|j'|fddj(D|d}t)|j*}j+}t,||d}jj-|j'd}t%j.|||||ddt /|D||jj0j1d }2|j3}t,||d!}j |WdWdWdWdS1swYWdn 1swYWdn1swYWddSWddS1swYdS)"z Generate schema for a dataclass.Nrrrrr;)is_pydantic_dataclasscSsi|] \}}|t|qSrr)rf_namerrrrrBsz4GenerateSchema._dataclass_schema..r)rr rFzField zd has `init=False` and dataclass has config setting `extra="allow"`. This combination is not allowed.z dataclass-init-false-extra-allowrrc3s"|] \}}||VqdSr)rrrrrrOjs z3GenerateSchema._dataclass_schema..cSs|dduS)NrF)r)rNrrrr:krz2GenerateSchema._dataclass_schema..)key __post_init__ __slots__crrr r rrrrsrz4GenerateSchema._dataclass_schema..)rcollect_init_onlyrrcSsg|]}|jqSr)r)rrrrrrs)rrrGrslotsrrr)4r rr rrrrnrvrr\rrrrrrBrrrrrrSapply_typevars_mapr!rmrrrErrlrrrFr`rrsortedhasattrr0dataclass_args_schemarrrr,r"r)rdataclass_schemarrrr-r.)rr?r dataclass_refr1rrGrrrBrrrrrQ has_post_init has_slots args_schemarr"r dc_schemarrrrs                          2Tz GenerateSchema._dataclass_schemafunctionValidateCallSupportedTypescore_schema.CallSchemac Csn||}d}|j}|jr/t|}|j}||jur/|j\}}tj|||dhd} | | d}t j |||dS)zsGenerate schema for a Callable. TODO support functional validators once we support them in Config Nr)globalnslocalns include_keys)r6) _arguments_schemarvalidate_returnrreturn_annotationrr!rWget_function_type_hintsr'r0r) rrSrr6r sig return_hintrVrW type_hintsrrrrs"    zGenerateSchema._call_schemaparameters_callbackParametersCallback | Nonecore_schema.ArgumentsSchemac Cstjdtjdtjdi}t|}|j\}}tj|||d}g}d} d} d} t|j D]\} \} }|j |j ur>t tt}n|| }|durQ|| | |}|dkrQq+||j}|durl|| |tj|j|}||q+|jtjkrx||} q+|jtjksJ|jt|}|durt|p|}t|std|dd d d |j D}||j}|rtd |j d t!|dkrdnddd"ddt#|Ddd d} |$|t|} q+d} ||} q+t%j&|| | | |j'j(dS)z Generate schema for a Signature.positional_onlypositional_or_keyword keyword_onlyrVrWNskip7Expected a `TypedDict` class inside `Unpack[...]`, got unpack-typed-dictrcS h|] \}}|jtjkr|qSrkindrPOSITIONAL_ONLYrrprrr z3GenerateSchema._arguments_schema..Typed dictionary  overlaps with parameterr;rrrrcsrrrrrorrrrOrz3GenerateSchema._arguments_schema..overlapping-unpack-typed-dictzunpacked-typed-dictuniform)var_args_schemavar_kwargs_modevar_kwargs_schemavalidate_by_name))rrmPOSITIONAL_OR_KEYWORD KEYWORD_ONLYrr!rWr\ enumerate parametersrrrrr%rrrlrr8FUNCTIONrrVAR_POSITIONALr' VAR_KEYWORD unpack_typer5r6rF intersectionrrrTrrJr}r0rrrz)rrSr` mode_lookupr]rVrWr_arguments_listrwryrxirrorresultparameter_mode arg_schemarrnon_pos_only_param_namesoverlapping_paramsrrrrYsx            z GenerateSchema._arguments_schemacore_schema.ArgumentsV3Schemac Cstjdtjdtjdtjdi}t|}|j\}}tj|||d}g}t |j D]\} \} } |dur>|| | | j } | dkr>q(| j tj urKttt} n|| } || j}|dur| jtjksdJ| jt| }|durt|pr|}t|std|dd d d |j D}||j}|rtd |jd t|dkrdndddddt|Ddd d}|} nd}||j| | t j!|| j"dq(t#j$||j%j&dS)Nrcrdvar_argsrerfrgrhrircSrjrrkrnrrrrprqz6GenerateSchema._arguments_v3_schema..rrrsr;rrrrcsrrrrtrrrrO'rz6GenerateSchema._arguments_v3_schema..ruvar_kwargs_unpacked_typed_dictvar_kwargs_uniform)r)rz)'rrmr{rr|rr!rWr\r}r~rrrrr%rrrlrrr5r6rFrrrrTrrJrrr8rrr0arguments_v3_schemarrz)rrSr`rr]rVrWr_parameters_listrrrorrrrrrrrrr_arguments_v3_schemasl       z#GenerateSchema._arguments_v3_schematypevartyping.TypeVarcCsxz|}Wn tyYn w|r||jS|j}r%|tj|S|j}r8||}t d|d<|St S)Nrr) has_defaultrr' __default__r*rrr$r(r0rWr)rrr constraintsrrrrrr:s      z,GenerateSchema._unsubstituted_typevar_schemar Decorator[ComputedFieldInfo]r 2dict[str, Decorator[FieldSerializerDecoratorInfo]]core_schema.ComputedFieldc Cs|jjtur |jj}nz tj|j|jjd}Wnty)}zt ||d}~ww|tur4t dddt ||j }tj|j|d|_||}||t||j}t|j\}}i}t|ddi|rf|ni|dtj|j||jj|d S) NrWzComputed field is missing return type annotation or specifying `return_type` to the `@computed_field` decorator (e.g. `@computed_field(return_type=int | str)`)zmodel-field-missing-annotationr) return_typereadOnlyTr)r6rrH)rrr.rSget_callable_return_typefuncr!localsrrErrFrsrrreplacer'rrrSrrr[r0computed_fieldr) rr r rrreturn_type_schemarrrrrrr Ns<     z%GenerateSchema._computed_field_schemar&cCsFt}|j|dd^}}|||}|D] }t||r t||}q|S)zdGenerate schema for an Annotated type, e.g. `Annotated[int, Field(...)]` or `Annotated[int, Gt(0)]`.Tr)rur&rrnr)rr&rrrrrrrrrYzs   z GenerateSchema._annotated_schemacCr7rrr8rrrr:r;zGenerateSchema.rr list[Any]r"Callable[[CoreSchema], CoreSchema]r c stt|}g}d fdd }t|}|D]}|dur qj||||d}q|} |r<| d i} t| |d tjj | S) aApply arguments from `Annotated` or from `FieldInfo` to a schema. This gets called by `GenerateSchema._annotated_schema` but differs from it in that it does not expect `source_type` to be an `Annotated` object, it expects it to be the first argument of that (in other words, `GenerateSchema._annotated_schema` just unpacks `Annotated`, this process it). rrrr*csV|}|dur|}t|}|dur't|j}|dur'|||Sr)rrrrr r)rrrrrrrrr inner_handlers    z8GenerateSchema._apply_annotations..inner_handlerNr rH) pydantic_js_annotation_functionsrrrr*) rQrUexpand_grouped_metadatar{_get_wrapped_inner_schemarr[rrr) rrrrr rrget_inner_schemarrrrrrrs$    z!GenerateSchema._apply_annotationsrHc Cst}t||r\|rBt||urB||}D]\}}tjd|d|d|dtdq|jrB|j durBd|vrBtjdtd|j D]}| ||}qE|j durZ| ||j }|S|dd krx| d t} | | |} | rv| |d <|S|} | d } | dur|}| d t|} |j| } dur| S| |d <n1|dd kr|d} |j| }dur|}| d t|} |j| } dur| S| |d <t||}|dur|S| S)NzThe z attribute with value zY was provided to the `Field()` function, which has no effect in the context it was used. a is field-specific metadata, and can only be attached to a model field using `Annotated` metadata or by assignment. This may have happened because an `Annotated` type alias using the `type` statement was used, or if the `Field()` function was attached to a single member of a union type.rdefaut_factoryzA 'default_factory' taking validated data as an argument was provided to the `Field()` function, but no validated data is available in the context it was used.rrrrGrKdefinition-refrV)rurnr&_get_unsupported_field_info_attributesrrrQ$default_factory_takes_validated_datar rrH_apply_single_annotationrrr0rr rr get_schema_from_refrUapply_known_metadata)rrrHr runsupported_attributesattrrIfield_metadatarr@rGnew_refexistingreferenced_schemamaybe_updated_schemarrrrsf           z'GenerateSchema._apply_single_annotationcCsRt}t||r'|jD]}|||}q t|\}}|di}t|||d|S)NrHr)rurnrH$_apply_single_annotation_json_schemarrr[)rrrHrrrrrrrrr s    z3GenerateSchema._apply_single_annotation_json_schemarcCs^g}tD](\}}t||}|ur,|dvs|jdur,|dvs%d|jvr,|||fq|S)zoGet the list of unsupported `FieldInfo` attributes when not directly used in `Annotated` for field annotations.)rrN)rrr)rrr r_attributes_setr)rrunused_metadataunused_metadata_name unset_valueunused_metadata_valuerrrr s  z5GenerateSchema._get_unsupported_field_info_attributesrr>rlist[GetJsonSchemaFunction]r{cs.tdddfdd }t|S) Nr:rrrrcsVdur |}n|}j|d}|}t}|dur)||S)Nr )rrrr)rrrrannotation_get_schemar rrrrr new_handler2 s   z=GenerateSchema._get_wrapped_inner_schema..new_handler)rrrr)rr{)rrrrr rrrrr) s  z(GenerateSchema._get_wrapped_inner_schema serializers-list[Decorator[FieldSerializerDecoratorInfo]]c Cs0|rt|}|ddkr|d}||||d<|Sd|vr$|j|}|d}t|j|jj\}}|jjt ur=|jj}nz t j |j|j j d}Wnty[}zt||d}~ww|t urcd} n||} |jjdkrtj|j||| |jjd |d <|S|jjd ksJtj|j||| |jjd |d <|S) z$Apply field serializers to a schema.rrrrGrrNr)is_field_serializerrwr6rrr)r rr rrhrrrorr.rSrr!rrrErr'r0rrr) rrrr serializerrrwrrr6rrrrE sR           z'GenerateSchema._apply_field_serializers1Iterable[Decorator[ModelSerializerDecoratorInfo]]c Cs|dd}|rot|d}t|j|jj}|jjtur!|jj}nz tj |j|j j d}Wnt y?}zt ||d}~ww|turGd}n||}|jjdkr_tj|j|||jjd} n tj|j|||jjd} | |d<|ru||d<|S)z$Apply model serializers to a schema.rGNrrr)rwr6rr)poprQrirrrorr.rSrr!rrrErr'r0rrr) rrrrGrrwrrr6 ser_schemarrrr-} sD         z'GenerateSchema._apply_model_serializers)NN)r rXr r rrrrrr)rrX)rrw)rr)r$rrr*)r+rr,rrr*)r3r4rr*)rrrr*)rrrrrr*)rrr+rr,rrr*)rr*r)rr*rrrr*r)rr*rrrr)rrrr)rrrr)rrrr)rrrrrr9)rrrrHrrI)rrrrL)F)rrrrrrL)rrrrS)rrrrrr*) rrrrrr`rrrr)rrrrrr`rr)rrrrrr`rr)rrrrrr`rr)rrrr)rr3rr*)rrrr*)rrrrrr)rrrrrr) rrrrrr8rrror rr ) rrrrrr8rorrrrr)rrrr)rr)r$rrr)r$rrr)r$rrr0)r3rrr)r?r@rrArr)rSrTrrUr)rSrTr`rarrb)rSrTr`rarr)rrrr)r rr rrr)r&rrr) rrrrrrr rrr*r)rrrHrr rrr)rrrHrrr)rrrr) rr>rrrrr rrr{)rrrrrr)rrrrrr)KrrrrrFrrpropertyrr!r#r)r.r0r2r^rrrrrrrrrrr'r7r8rrGr&r&rRrUrr\rrrrr(rrwr|r}rrrrrrqrxrr#rrrrsrrrrrYrrr rYrrrrrrr- __classcell__rrrrrOs           H ! :  .    '   ;   x9    9    1: 2    '    zL D  ,4 J  8rcC t||Sr)r0!no_info_before_validator_functionrrrrrr:  r:cCrr)r0rZrrrrr: rcC t|Sr)r0rrrKrrrr: rcCrr)r0rrrrrr: rcCrr)r0#with_info_before_validator_functionrrrrr: rcCrr)r0"with_info_after_validator_functionrrrrr: rcCrrr>rrrrr: rcCrr)r0!with_info_wrap_validator_functionrrrrr: r))rno-info)rr)rr)rr)r with-info)rr)rr)rrzMapping[tuple[FieldValidatorModes, Literal['no-info', 'with-info']], Callable[[Callable[..., Any], core_schema.CoreSchema], core_schema.CoreSchema]]_VALIDATOR_F_MATCHr Iterable[Decorator[RootValidatorDecoratorInfo]] | Iterable[Decorator[ValidatorDecoratorInfo]] | Iterable[Decorator[FieldValidatorDecoratorInfo]]cCsF|D]}t|j|jjdd}|rdnd}t|jj|f|j|}q|S)aApply validators to a schema. Args: schema: The schema to apply validators on. validators: An iterable of validators. field_name: The name of the field if validators are being applied to a model field. Returns: The updated schema. rrorrr)rjrrror)rr  validatorrwval_typerrrr s  r+Iterable[Decorator[ValidatorDecoratorInfo]]cCs|D] }|jjr dSqdS)a?In v1, if any of the validators for a field had `always=True`, the default value would be validated. This serves as an auxiliary function for re-implementing that logic, by looping over a provided collection of (v1-style) ValidatorDecoratorInfo's and checking if any of them have `always=True`. We should be able to drop this function and the associated logic calling it once we drop support for v1-style validator decorators. (Or we can extend it and keep it if we add something equivalent to the v1-validator `always` kwarg to `field_validator`.) TF)rru)r rrrrr s  rr%str | AliasChoices | AliasPath | None4str | list[str | int] | list[list[str | int]] | NonecCst|ttfr |S|Sr)rnr<r=convert_to_aliases)rrrrr sr0Iterable[Decorator[ModelValidatorDecoratorInfo]]ro Literal['inner', 'outer', 'all']cCs|dd}|D]q}|dkr|jjdkrq|dkr |jjdkr qt|j|jjdd}|jjdkrD|r;tj|j|d }qtj|j|d }q|jjdkr^|rUtj|j|d }qtj |j|d }q|jjd ksfJ|rqtj |j|d }qtj |j|d }q|r||d<|S) aApply model validators to a schema. If mode == 'inner', only "before" validators are applied If mode == 'outer', validators other than "before" are applied If mode == 'all', all validators are applied Args: schema: The schema to apply validators on. validators: An iterable of validators. mode: The validator mode. Returns: The updated schema. rGNrrrmodelrr)rSrr) rrrorjrr0rrrrrrZ)rr rorGrrwrrrr) s,   r)rrcCsD|jrtj||jt|j|jdS|jtur tj||j|jdS|S)a Wrap schema with default schema if default value or `default_factory` are available. Args: field_info: The field info object. schema: The schema to apply default on. Returns: Updated schema by default value or `default_factory`. )rdefault_factory_takes_datar)rr)rr0with_default_schemarorrr.)rrrrrr s   rGetJsonSchemaFunction | NonecCst|dd}t|dr8t}|duo|jj|t|ddfv}|s8t|dd}td|r0d|dnd d d d t|}durDt|S|durJdS|S) z`Extract `__get_pydantic_json_schema__` from a type, handling the deprecated `__modify_schema__`.__get_pydantic_json_schema__N__modify_schema__rCrzjThe `__modify_schema__` method is not supported in Pydantic v2. Use `__get_pydantic_json_schema__` insteadz in class ``rrzcustom-json-schemar)rrKrtrrCrFr5r)rjs_modify_functionrhas_custom_v2_modify_js_funccls_namerrrrr9 s*   rrrCoreSchema | NonecCs2|ddkr ||dS|ddkr|dS|S)NrrrVrr)rrrrrrrY s  rdef_ref%core_schema.DefinitionReferenceSchema.Literal['inline', 'keep', 'preserve_metadata']cCs:d|vrdS|d}|sdSt|dkrd|vrdSdS)aDetermine the inlining behavior of the `'definition-ref'` schema. - If no `'serialization'` schema and no metadata is attached, the schema can safely be inlined. - If it has metadata but only related to the deferred discriminator application, it can be inlined provided that such metadata is kept. - Otherwise, the schema should not be inlined. Doing so would remove the `'serialization'` schema or metadata. rkeeprHinlinerR%pydantic_internal_union_discriminatorpreserve_metadata)rrT)rrHrrr_inlining_behaviorb s  rc@speZdZUdZded< ded< d#dd Zed$d dZd%ddZd&ddZ d'ddZ d(ddZ d)d d!Z d"S)*rz*Keeps track of references and definitions.zset[str]_recursively_seenz!dict[str, core_schema.CoreSchema]rrrcCst|_i|_dSr)rrrrrrrr s z_Definitions.__init__rrCGenerator[tuple[str, core_schema.DefinitionReferenceSchema | None]]c csjt|}||jvs||jvr|t|fVdS|j|z|dfVW|j|dS|j|w)aGet a definition for `tp` if one exists. If a definition exists, a tuple of `(ref_string, CoreSchema)` is returned. If no definition exists yet, a tuple of `(ref_string, None)` is returned. Note that the returned `CoreSchema` will always be a `DefinitionReferenceSchema`, not the actual definition itself. This should be called for any type that can be identified by reference. This includes any recursive types. At present the following types can be named/recursive: - Pydantic model - Pydantic and stdlib dataclasses - Typed dictionaries - Named tuples - `TypeAliasType` instances - Enums N)r]rrr0rZadddiscard)rrrGrrrr s  z_Definitions.get_schema_or_refrGrrcCr)z,Resolve the schema from the given reference.)rr)rrGrrrr s z _Definitions.get_schema_from_refrr*rcCs|d}||j|<t|S)zStore the schema as a definition and return a `'definition-reference'` schema pointing to it. The schema must have a reference attached to it. rG)rr0rZ)rrrGrrrr s  z/_Definitions.create_definition_reference_schemacore_schema.DefinitionsSchemacCs$|dD] }||j|d<q|dS)zZStore the definitions of the `'definitions'` core schema and return the inner core schema.rrGr)r)rr def_schemarrrr s z_Definitions.unpack_definitionsc Cs<|j}zt||d}Wnty}zt|d}~wwi}|dD]E\}}|dur`t|}dkr`|dkrE|||||q#|dkr_| d} |||||| |d<q#|||||<q#|dD]!} | d d d} | dur|qmt | | |} | | | qm|rt j|g|d }|S) zFinalize the core schema. This traverses the core schema and referenced definitions, replaces `'definition-ref'` schemas by the referenced definition if possible, and applies deferred discriminators. )rNcollected_referencesrrrrHdeferred_discriminator_schemasrr)rrzryrrrclearr>_resolve_definitionrrTrr r0definitions_schemarS) rrr gather_resultrremaining_defsrGinlinable_def_refinlining_behaviormetacsrappliedrrrr sB    z_Definitions.finalize_schemardict[str, CoreSchema]cCs||}|ddkr |St}|ddkrAt|dkrA|d}||vr,t|ddd||||}|ddkrAt|dksi|d|iS) NrrrrVz) contains a circular reference to itself.zcircular-reference-schemarrG)rrrFr)rrGr definitionvisitedrVrrrr s   z _Definitions._resolve_definitionNr)rrrr)rGrrr)rr*rr)rrrr*r)rGrrr rr*) rrrrrrrrrrrrrrrrrrv s      :c@2eZdZdZdddZedd d Zdd d ZdS)r_stackrrcC g|_dSrrrrrrr  z_FieldNameStack.__init__rrIterator[None]cc"|j|dV|jdSrrrr)rrrrrr  z_FieldNameStack.push str | NonecC|jr|jdSdSNrrrrrrr  z_FieldNameStack.getNr)rrrr)rrrrrrFrrrrrrrrr   rc@r)rrrrcCrrrrrrrr& rz_ModelTypeStack.__init__type_objrrccrrr)rrrrrr) rz_ModelTypeStack.push type | NonecCrrrrrrrr/ rz_ModelTypeStack.getNr)rrrr)rrrrrrrr# rr)rrrrrr)rrrrrr)rrrrrr)rrrrrr)rrrr)rrrrrr*rr*)rrr rrr)r rrr)rrrr)rrr rrorrr)rrrrrr)rrrr)rr*rrrr)rrrr(r __future__r _annotationscollections.abcrrrbrTrrr8sysrrrrrr contextlibrr decimalr enumr fractionsr functoolsr rrr ipaddressrrrrrr itertoolsroperatorrtypesrrrrrrrr r!r"r#r$r%r&uuidr'rr(r pydantic_corer)r*r+r,r-r.r/r0r1r2r3r4r5r6typing_inspectionr7typing_inspection.introspectionr8r9r:aliasesr<r=annotated_handlersr>r?rr@rArBrCerrorsrDrErFfunctional_validatorsrGrHrIrJrKr?rLversionrMrNrOrPrQrrSrTrUrVrW_configrXrY_core_metadatarZr[ _core_utilsr\r]r^r_r`rarbrcrdrerfrgrhrirj_docs_extractionrkrrlrmrnrorp _forward_refrq _genericsrrrs _import_utilsrtru _mock_val_serrv_namespace_utilsrwrx_schema_gatherryrz_schema_generation_sharedr{_utilsr|r}rr~rmainrr _dataclassesrr version_inforrrAnyFieldDecoratorrrrrTuplerrListrQr=MutableSequencerSetr MutableSetr FrozenSet frozensetrDictrrrr.rrTyperrr7rrPathr PosixPath PurePosixPathPureWindowsPathrMutableMapping OrderedDict DefaultDictrrtCounterrurrrrTrrrrrrrr JsonEncodersr Exceptionrrrrrrr)rrrrrrrrrrrsZ          0 ,   8                       # "r    /