2i_ UdZddlmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z ddlmZmZddlmZddlmZddlmZmZmZdd lmZdd lmZdd lmZmZmZdd l mZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l m,Z,ddl-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mm?Z?m@Z@ddlAmBZBmCZCmDZDddlEmFZFmGZGmHZHddlImJZJddlKmLZLddl mMZMddlNmOZOmPZPmQZQmRZRddlSmTZTmUZUddlVmWZWmXZXddlYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_ddlOm`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlddlmmnZnmoZoddlpmqZqdd lrmsZsmtZtmuZumvZvdd!lwmxZxdd"lRmyZydd#lzm{Z{erdd$l|m}Z}dd%l~mZdd&lmZdd'lwmZe jd(k\Zee3ed)fZe)ehedecfZe(d*e+Ze)eaeheaedeaecfZed?d@dAdBZdCedD< dYdEZdZdFZ d[dGZd\dHZd]dIZGdJdKe7ZddddddL d^dMZGdNdOZd_dPZGdQdRZy)`z-Convert python types to pydantic-core schema.) annotationsN)contextmanager)copydeepcopy)Enum)partial) Parameter_ParameterKind signature)chain) attrgetter) FunctionType LambdaType MethodType) TYPE_CHECKINGAnyCallableDict ForwardRefIterableIteratorMappingTypeTypeVarUnioncastoverload)warn) CoreSchemaPydanticUndefined core_schemato_jsonable_python) AnnotatedFinalLiteral TypeAliasType TypedDictget_args get_origin is_typeddict)GetCoreSchemaHandlerGetJsonSchemaHandler) ConfigDict JsonEncoder)PydanticSchemaGenerationErrorPydanticUndefinedAnnotationPydanticUserError) AliasChoices AliasPath FieldInfo)JsonSchemaValue) version_short)PydanticDeprecatedSince20) _decorators_discriminated_union_known_annotated_metadata _typing_extra) ConfigWrapperConfigWrapperStack)CoreMetadataHandlerbuild_metadata_dict),NEEDS_APPLY_DISCRIMINATED_UNION_METADATA_KEYCoreSchemaOrFielddefine_expected_missing_refsget_ref get_type_ref%is_list_like_schema_with_items_schema) ComputedFieldInfo DecoratorDecoratorInfosFieldSerializerDecoratorInfoFieldValidatorDecoratorInfoModelSerializerDecoratorInfoModelValidatorDecoratorInfoRootValidatorDecoratorInfoValidatorDecoratorInfoget_attribute_from_basesinspect_field_serializerinspect_model_serializerinspect_validator)collect_dataclass_fieldsget_type_hints_infer_globalns)PydanticRecursiveRef)get_standard_typevars_maphas_instance_in_typerecursively_defined_type_refs replace_types)CallbackGetCoreSchemaHandler) is_finalvar)lenient_issubclass BaseModel)FieldValidatorModes)StandardDataclass)GetJsonSchemaFunction) {FieldDecoratorInfoType)boundz list[type] TUPLE_TYPES LIST_TYPES SET_TYPESFROZEN_SET_TYPES DICT_TYPESc~t|ttfrd|jvry|jD] }||k(s yy)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. *TF) isinstancerPrLfields)infofield v_field_names Z/var/www/html/acx/venv/lib/python3.12/site-packages/pydantic/_internal/_generate_schema.py)check_validator_fields_against_field_namervpsG$/1LMN $++   5  c Zt|}|D]}t|jttfrd|jj vr<|jj durU|jj D].}||vstd|jd|jddy) 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. roFz*Decorators defined with incorrect fields: .zO (use check_fields=False if you're inheriting from the model and intended this)zdecorator-missing-fieldcodeN) setrprrrPrLrq check_fieldsr2cls_ref cls_var_name) decoratorsrqdecrss rucheck_decorator_fields_existrs[F  chh!79T U V[^bebjbjbqbq[q  88 E ) XX__ EF"'@ QsO_O_N`ef2  rwcZ|Dcgc]}t|j|s|c}Scc}wN)rvrr)validator_functionsrsrs ru$filter_field_decorator_info_by_fieldrs*/ mC2[\_\d\dfk2lC mm ms((ct|ddk(rt|d|||d<|St|r:|jdd}|tj}t ||||d<|S|ddk(r:|jdd}|tj}t ||||d<|S|rt d|d|S)Ntypenullableschema items_schemadict values_schemazO`@validator(..., each_item=True)` cannot be applied to fields with a schema of )apply_each_item_validatorsrGgetr! any_schemaapply_validators TypeError)reach_item_validators field_name inner_schemas rurrsf~#5fX6FH\^hix .v 6zz.$7  &113L!1,@TV`!a~ M 6 !zz/48  &113L"2d=f dud>Z?dvd?Z@ dvd@ZA dwdAZB dZ dxdBZC dydCZDy)zGenerateSchemaz\Generate core schema for a Pydantic model, dataclass and types like `str`, `datetime`, ... .)_config_wrapper_stack_types_namespace _typevars_map _needs_apply_discriminated_union_has_invalid_schemafield_name_stackdefsNct||_||_||_d|_d|_t |_t|_ yNF) r?rrrrr_FieldNameStackr _Definitionsr)selfconfig_wrappertypes_namespace typevars_maps ru__init__zGenerateSchema.__init__sE&8%G" /)05-#( / 1 N rwc|j|}||_||_||_d|_d|_t |_||_|Sr) __new__rrrrrrrr)rconfig_wrapper_stackrrrobjs ru __from_parentzGenerateSchema.__from_parent$sQkk#$8!.(/4,"'.0 rwc.|jjSr)rtailrs ru_config_wrapperzGenerateSchema._config_wrapper6s))...rwc|jjxst}|j|j|j |j |jSr)rschema_generatorr_GenerateSchema__from_parentrrrr)rrs ru_current_generate_schemaz'GenerateSchema._current_generate_schema:sM""33E~   & &  ! !    II   rwc.|jjSr)rarbitrary_types_allowedrs ru_arbitrary_typeszGenerateSchema._arbitrary_typesDs##;;;rwc*tjS)zGenerate a CoreSchema for `str`)r! str_schemars rurzGenerateSchema.str_schemaHs%%''rwcJtj|j|Sr)r! list_schemagenerate_schemarr items_types ru _list_schemazGenerateSchema._list_schemaNs&&t';';J'GHHrwcjtj|j||j|Sr)r! dict_schemar)rr keys_type values_types ru _dict_schemazGenerateSchema._dict_schemaQs,&&t';';I'FH\H\]hHijjrwcJtj|j|Sr)r! set_schemarrs ru _set_schemazGenerateSchema._set_schemaTs%%d&:&::&FGGrwcJtj|j|Sr)r!frozenset_schemarrs ru_frozenset_schemaz GenerateSchema._frozenset_schemaWs++D,@,@,LMMrwcJtj|j|Sr)r!tuple_variable_schemarrs ru_tuple_variable_schemaz%GenerateSchema._tuple_variable_schemaZs001E1Ej1QRRrwcr|Dcgc]}|j|}}tj|Scc}wr)rr!tuple_positional_schema)rr items_typesr items_schemass ru_tuple_positional_schemaz'GenerateSchema._tuple_positional_schema]s7LWXj--j9X X22=AAYs4ct|ts't|dtt j St j |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`.)rprr UserWarningr!ris_instance_schema)rrs ru_arbitrary_type_schemaz%GenerateSchema._arbitrary_type_schemaasL"d# &ZZ  ))+ +--b11rwc td|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.)r0rrs ru_unknown_type_schemaz#GenerateSchema._unknown_type_schemams#+:3'Bf f  rwc tj||S#tj$r>tj||d|vr d|dt<n tdi|d<d|_|cYSwxYw)NmetadataT)r;apply_discriminatorMissingDefinitionForUnionRefset_discriminatorrBr)rr discriminators ru_apply_discriminator_to_unionz,GenerateSchema._apply_discriminator_to_unionxs ';; $@@  2 2 V#SWz"#OP&RTX%Yz"48D 1M sAA)(A)c*td|jdd}|r||jj|<d|vrt j |d}t j |t|jjjS)N str | Noner) rrr definitionsr!definition_reference_schemadefinitions_schemalistvalues)rrrs rucollect_definitionsz"GenerateSchema.collect_definitionss|<E4!89 )/DII ! !# & F? <**3/F@fM  +5fdii>S>STO%%o7KL=d>R>R>`>`begmn44V< rwcN|jj|5\}}| |cdddS|j}|j}|j}t t |jj|jj|jjh|j|jt|jd}|j|}tt!t"|g} |j$j} d} |j'ddk(r|g|j(D]} |j*j'dd} | "t-| } | t.t0fvr t3d |j5|j*dd d }|t6usr|j9|} n|j:j=|5|j>}|j@r]|jCd |d |}|d}tE|| d}tGjH||tK|ddd tK|dd||| }n tGjL|jODcic]\}}||jQ|||c}}|jDcgc]}|jS||j c}| |jT}tW||jXjd}t[|t]}||}tE|| d}tGjH||tK|dddtK|dd||| }|j_||j`j}tE|| d}|jc||jjd|<tGjf|cdddcdddScc}}wcc}w#1swYnxYw dddy#1swYyxYw)z%Generate schema for a Pydantic model.NF)checkr js_functionsextra_fields_behaviorallow__pydantic_extra__zEThe type annotation for `__pydantic_extra__` must be `Dict[str, ...]`Trequiredr9rootrinner__pydantic_custom_init____pydantic_post_init__) custom_init root_model post_initconfigrr)computed_fields extras_schema model_nameouter)4rget_schema_or_ref model_fields__pydantic_decorators__r-rr field_validatorsr field_serializers validatorskeysr> model_config core_configrArrmodel_validatorsrr__annotations__r)rrr0 _get_args_resolving_forward_refsrrrpushr__pydantic_root_model___common_field_schemaapply_model_validatorsr! model_schemarmodel_fields_schemaitems_generate_md_field_schema_computed_field_schemarrroot_validatorsrDrZ_apply_model_serializersmodel_serializersrrr)rr model_ref maybe_schemarqrr-rr9rr:r.rextras_annotationextra_items_type root_fieldrrAkvd fields_schemanew_inner_schemars ru _model_schemazGenerateSchema._model_schemas: YY ( ( -U J1J)\'#U JU J%%F44J(88O (//66800779))002 :&++-9/"6"6"89  +3+;+;5IN(44S9K*AY_b9c8deH)::AAC  M677B--"B(+(;(;(?(?@TVZ([%(4'(9:dD\1"? g#,0+P+P//0DE%),Q,,(,36,0,@,@AQ,RM!" ++00@. J44..!%!:!:66&>S]!^J#-h#7L#9,HXZa#bL#.#;#;$$+C1KT$R#'")#/G"N*%!) $L=H<[<[Y_YeYeYghQUQRTUD::1aLLh&5%;%;%=) !!77:;W;WX)'4#&<<=M$4M:C]C]CdCdCfhl#mL'CLRoRq'r$'3'7 #9,HXZa#bL#.#;#;$$+C1KT$R#(")#/G"N*%!) $L66|ZEaEaEhEhEjk/8H'R373V3VW]3^ %%i0">>yI]. J. JOU JU Jri)'. J. J. JOU JU JU JsVPEP6AP/P5BP O:+P#P#DP' P: PP PP$cdd}|ddk(rB|jjj|dDcic] }||| c}|d}|Scc}w)zuUnpack all 'definitions' schemas into `GenerateSchema.defs.definitions` and return the inner schema. c |dS)Nr)ss rurEz1GenerateSchema._unpack_refs_defs..get_ref0s U8Orwrrr)rWrreturnstr)rrupdate)rrrErWs ru_unpack_refs_defsz GenerateSchema._unpack_refs_defs+sZ   &>] * II ! ! ( ( AV)WA'!*a-)W XH%F *XsAc|jj|5\}}| |cdddS ddd||urd}nd}t|dd}|\t|dd}|ytdtt j |Dcgc]}t j|c}} nSttj|jdk(r ||} n||t|j||} |j| } t| } | r=|j!| |jj"| <t j$| S|j!| } | S#1swY?xYwcc}w) a0Try to generate schema from either the `__get_pydantic_core_schema__` function or `__pydantic_core_schema__` property. Note: `__get_pydantic_core_schema__` takes priority so it can decide whether to use a `__pydantic_core_schema__` attribute, or generate a fresh schema. Nunpackzto-def__get_pydantic_core_schema____get_validators__zc`__get_validators__` is deprecated and will be removed, use `__get_pydantic_core_schema__` instead.r9)ref_mode)rr1rrr8r! chain_schema"with_info_plain_validator_functionlenrr parametersr\rr[rErrr) rrsource_rJr` get_schemar6rOrrs rurz-GenerateSchema._generate_schema_from_property8sxYY ( ( - $1B!\'# $ $' $ &=HHS"@$G   &:DAJ! u) !--jtjv.wef{/]/]^_/`.wxF7$$Z0;;<A#F+#89N9NPT_gh''/fo )-)L)LV)TDII ! !# &::3? ?44V< K $ $$/xsE+E8+E5c. tj||j}t |trt |jd||jrt||j}|S#t$r}t j ||d}~wwxYw)N)globalnsz%Unable to evaluate forward reference ) r=evaluate_fwd_refr NameErrorr1from_name_errorrpr__forward_arg__rr[)rres ru_resolve_forward_refz#GenerateSchema._resolve_forward_refgs H00t?T?TUC c: &-c.A.AEjknjoCpq q   T%7%78C  H-==a@a G Hs!A00 B9BBcyrrV)rrr$s rur<z/GenerateSchema._get_args_resolving_forward_refs} rwcyrrVrs rur<z/GenerateSchema._get_args_resolving_forward_refsrqrwc t|}|r|j|}|stS|dS)Nr)r<r)rrrus ru_get_first_arg_or_anyz$GenerateSchema._get_first_arg_or_anys#44S9JAwrwc|j|}|s ttfSt|dkrt|}t d|d|d|dfS)Nr+z Expected two type arguments for z, got 1rr9)r<rrcr)r)rrruorigins ru_get_first_two_args_or_anyz)GenerateSchema._get_first_two_args_or_anys[44S9:  t9q=_F>vhgNO OAwQrwcld|vr|d}|j|t<|St|ji|d<|S)Nr)rrB)rrrs rurz-GenerateSchema._post_process_generated_schemasL  j)HEIEjEjHA B  =d>c>c"F:  rwc|j}d|_|j}d|_|j|j|}|jxs||_|jxs||_|S)zJRecursively generate a pydantic-core schema for any supported python type.F)rrr_generate_schema_inner)rrhas_invalid_schemaneeds_apply_discriminated_unionrs rurzGenerateSchema._generate_schemass!55#( *.*O*O'05-44T5P5PQT5UV#'#;#;#Q?Q 040U0U0xYx- rwct|tr|j|St|tr|St|tr t |}t|t r |j |j|Sddlm }t||r|j|St|tr tj|jS|j!|S)Nr+r_) schema_ref)rp_AnnotatedType_annotated_schemarrYrrromainr`r^rSrWr!rtype_ref match_type)rrr`s rur~z%GenerateSchema._generate_schema_inners c> *))#. . c4 J c3 S/C c: &''(A(A#(FG G$ c9 -%%c* * c/ 0::cllS Ss##rwc|tur|jS|turtjS|t urtj S|turtjS|turtjS|tus|turtjS||tjurtj S|t"vr|j%|S|t&vr!|j)||j+|S|t,vr!|j/||j+|S|t0vr!|j3||j+|S|t4vr"|j6|g|j9|St;|t<r|j?|S|t@k(r|jCStjD|rtjFStjH|r|jK|StM|r|jO|dStjP|r|jS|dStjT|r|jW|jXS|tZj\k(r|j_|S|t`jbjdus|tfjdur|jiSt;|tfjjr|jm|Sto|r<|tpurtjS|jW|j+|St;|trtttvtxfr|j{|St}j~|r3t|tr#ddlBmC}|||jjStj|r|j|dS|j|d}||\}}|j||St|}||j||S|jr|j|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. Nr9)get_enum_core_schemarV)OrYrbytesr! bytes_schemaint int_schemafloat float_schemabool bool_schemarobjectrr=NoneType none_schemari _tuple_schemarjrrxrkrrlrrmrr{rpr&_type_alias_type_schemar _type_schemais_callable_typecallable_schemais_literal_type_literal_schemar*_typed_dict_schema is_namedtuple_namedtuple_schema is_new_typer __supertype__rePattern_pattern_schema collectionsabcHashabletyping_hashable_schemar_unsubstituted_typevar_schemar]r$rrrr_callable_schemarisclass issubclassr_std_types_schemarr config_dict is_dataclass_dataclass_schema0_get_prepare_pydantic_annotations_for_known_type_apply_annotationsr)_match_generic_typerrr)rrrres source_typerrzs rurzGenerateSchema.match_types #:??$ $ E\++- - CZ))+ + E\++- - D[**, , CZ3&=))+ + [C=#9#99**, , K %%c* * J $$S$*D*DS*IJ J I ##C)C)CC)HI I $ $))#t/I/I#/NO O J $4$$SP4+J+J3+OP P ] +//4 4 D[$$& &  + +C 0..0 0  * *3 /'', , # **35 5  ( ( -**35 5  & &s +''(9(9: : BJJ '', , KOO,, ,v0F((* * V^^ ,55c: :  e|"--//''**3/ lJ GL M((- - __S !jd&; ?'T-A-A-M-MN N  % %c *))#t4 4CCCL ?'* $K**; D DC  ++C8 8  ..s3 3((--rwcft|tr|j|Stj|r|j ||Stj |r|j||S|j||}||Stj|r|j|S|tvr|j|S|tvr!|j||j|S|t vr!|j#||j|S|t$vr!|j'||j|S|t(vr"|j*|g|j-|St/|r|j1||S|t2j4t6fvr|j9|S|t2j:t<j>j:hvr|jA|S|t2jBt<j>jBt2jDt<j>jDhvr|jG|S|tHjJt2jJfvr|jM|S|jNr|jQ|S|jS|Sr)*rpr&rr=rrrrrorigin_is_union _union_schemarirrjrrxrkrrlrrmrr{r*rrrr_subclass_schemaSequencerr_sequence_schemar Generator_iterable_schemarrrrrr)rrrzrs rurz"GenerateSchema._match_generic_type sR fm ,//4 4  % %f -))#v6 6  & &v .**37 7;;FCH  $  ( ( 0%%c* * { "%%c* * z !$$S$*D*DS*IJ J y ##C)C)CC)HI I ' '))#t/I/I#/NO O z !$4$$SP4+J+J3+OP P & !**37 7  T* *((- - )A)AB B((- - )A)A6CSCSU`UdUdUnUno o((- -  FNN3 3'', ,  ..v6 6((--rwr#c |j|||}tj|d|jsdn||d|d|d|dS)zAPrepare a TypedDictField to represent a model or typeddict field.rFserialization_excludevalidation_aliasserialization_aliasr)r$rrrr)r?r!typed_dict_field is_required)rname field_inforr$ common_fields ru_generate_td_field_schemaz(GenerateSchema._generate_td_field_schemaLsf00z:N ++  "","8"8":U"./F"G)*<= ,-B C!*-   rwc |j|||}tj|d|d|d|d|d|dS)z0Prepare a ModelField to represent a model field.rrrrfrozenrrrrrr)r?r! model_fieldrrrrrs rurDz(GenerateSchema._generate_md_field_schema_s^00z:N &&  ""./F"G)*<= ,-B C)!*-   rwc |j|||}tj||d|jxsd|jrdnd|d|d|d|d|d S) zJPrepare a DataclassField to represent the parameter/field, of a dataclass.rNFrrrrr) init_onlykw_onlyrrrrr)r?r!dataclass_fieldinit_varrrs ru_generate_dc_field_schemaz(GenerateSchema._generate_dc_field_schemaps|00z:N **   " ))1T&..DE"./F"G)*<= ,-B C)!*-  rwctjttfrj}j r[|xsij }|jj jDcic]\}}|j|c}}tjj|d}|jurt|ts|_jj} }d fd } jj|5j j#|| | } nj#|| } dddt%|j&j)|} t+| rd_| Dcgc]}|j.j0dus|} }| Dcgc] }|| vs| } }t3 | |} t5| t%| ||} t5| t%|j6j)||} j9s t;| } j=| t%|j>j)|} j@jBtEjFdjDcic] \}}| || c}}jHd fd }tK|g}jLjN}|rjjPjPdkrO||}tS|tstUd|d |jV|_,|_-|_.d_(tSjZt^t`frjZjc}n jZ}te| jfrdnd|j\jh| Scc}}w#1swYxYwcc}wcc}wcc}}w) Nc@j|j}|Sr)rr)rrrs rurz>GenerateSchema._common_field_schema..set_discriminators 77 @X@XYFMrw)transform_inner_schemaT)rrexamplesci||}ttr|jt|St r||Sr)rprrZr"callable)rrrjson_schema_extrajson_schema_updatess rujson_schema_update_funczDGenerateSchema._common_field_schema..json_schema_update_funcsXDWV_D0CDK+T2""#56G#HI +,!+. rwjs_annotation_functionsr9alias_generator  must return str, not rrrrXrrrCrr-rXr6)5rY annotationrrYrrrrZrCrr=eval_type_lenientrWrrr=rrrr6r $_validators_require_validate_defaultvalidate_defaultrr each_itemrrr4r wrap_default_apply_field_serializersr5rrr"rrrAralias_generatoralias_priorityrprraliasrrr3r4convert_to_aliases _common_fieldexcluder)rrrrrrNrO evaluatedrrrrthis_field_validatorsrrrrrrrrs` ` @@rur?z#GenerateSchema._common_field_schemas  5 5 C7H I"33O!!#2#8b">">"@&&$BTBTBZBZB\']$!Q A ']^%77 8M8M`deI 5 55>RS\^r>s(1 %#-#8#8*:M:M[   " " ' ' - ''300kbs0t00  !EZEZEZEaEaEcei j /0E F*.J '+@]aAFFDTDTX\D\]],A cqQNbEb c c+F4H$O!&*NOdfj*kmqr! 89T9T9[9[9]_cdfj %%'!*f5F.. 89U9U9\9\9^`de  %%%11*:+>+>?  1D0I0I0K]1q}q!t]&88 '@W?XY..>>  9 9 AZE^E^bcEc#D)EeS)"2?2CCYZ_ZiZiYj kll$J */J '-2J *()J % j11L)3L M)::MMO )::  *4*<*<$$- * > >$$   c(^   ^ c,^s69O 4OO,,O,6 O1O1) O64O6O)c^|j|d}g}d}|D]9}||tjurd}|j|j |;t |dk(r|d}t |tr|dn|}ntj|}|rtj|}|S)zGenerate schema for a Union.Tr#Fr9r) r<r=rrrrcrprtr! union_schemanullable_schema)r union_typeruchoicesrarg first_choicerWs rurzGenerateSchema._union_schemas44Z$4O=? :C{c]%;%;;t33C89  : w<1 "1:L#-lE#B Q A((1A ++A.Arwct|}|xs|}|jj|5\}}| |cdddS|jxsij }it j ||}|j}||_t|}t||}|j|} | ddk7sJ|| d<|xsd|_| |jj|<tj|cdddS#1swYyxYw)Nrrr)r)rr1rrr=get_cls_types_namespace __value__rXr[rrr!r) rrrzrrJ namespace new_namespacerrrs rurz&GenerateSchema._type_alias_type_schemasC3 YY ( ( 0 @4GS,'# @ @..4"::]2 22F5M$-$5D !)/DII ! !# &::3?! @ @ @sDB9DD cntj|}|s Jd|tj|S)zGenerate schema for a Literal.z(literal "expected" cannot be empty, obj=)r=all_literal_valuesr!literal_schema)r literal_typeexpecteds rurzGenerateSchema._literal_schemas8 33LARCL>RRx))(33rwc |jj|5\}}| |cdddSt|}||}ts%t |j dk(r t dd t|d}|jj|5|jj|}|j}|j}i} tj |} t#||j$dj'D]\} } t)| |} | |v} t+| t,j.k(rd} |j1| d d } n4t+| t,j2k(rd } |j1| d d } t5j6| }|j9| || | | | <t;t=t>| g| }tAjB| | jDjGDcgc]}|jI|| jJ c}|||}|jM|| jNjG}tQ|| jRjGd}|jU||jjV|<tAjX|cdddcdddS#t$rd}Y]wxYwcc}w#1swYnxYw dddy#1swYyxYw)aGenerate schema for a TypedDict. It is not possible to track required/optional keys in TypedDict without __required_keys__ since TypedDict.__new__ erases the base classes (it replaces them with just `dict`) and thus we can track usage of total=True/False __required_keys__ was added in Python 3.9 (https://github.com/miss-islington/cpython/blob/1e9939657dd1f8eb9f596f77c1084d2d351172fc/Doc/library/typing.rst?plain=1#L1546-L1548) however it is buggy (https://github.com/python/typing_extensions/blob/ac52ac5f2cb0e00e7988bae1e2a1b8257ac88d6d/src/typing_extensions.py#L657-L666). On 3.11 but < 3.12 TypedDict does not preserve inheritance information. Hence to avoid creating validators that do not do what users expect we only support typing.TypedDict on Python >= 3.12 or typing_extension.TypedDict on all versions NrzXPlease use `typing_extensions.TypedDict` instead of `typing.TypedDict` on Python < 3.12.ztyped-dict-versionrz__pydantic_config__T)localnsinclude_extrasr#rFr)rtyped_dict_cls)r-rrr,all)-rr1rX_SUPPORTS_TYPEDDICTr __module__r2rQAttributeErrorrr=rr9r__required_keys__rJbuildrVrrCr[r)r=Requiredr< NotRequiredr5from_annotationrrArrr!typed_dict_schemar-r rEr5rGrHr@r:rrr)rrrztyped_dict_refrJrr,r9 required_keysrqrrrr$rrrP td_schemars rurz!GenerateSchema._typed_dict_schemas) YY ( ( 8H O>~N 440>0P0P @B+11.A .K"D,A,ARV/%'*J "/z>~Nk5 O5 O'H OH O "  X%S5 O5 O5 O'H OH OH Os`K0:K0( K4K0E(K7#KBK0 K0 KK0KK0KK# K00K9c|jj|5\}}| |cdddSt|}||}t|d|j}|s|j Dcic] }|t  }}|r-|jD cic]\}} |t| |}}} tj|jD cgc]A\}} |j|| |jj|tjCc} }t!d} tj"| ||cdddScc}wcc} }wcc} }w#1swYyxYw)z!Generate schema for a NamedTuple.NT)rr)default)js_prefer_positional_arguments)r)r)rr1rXrVr_fieldsrrCr[r!arguments_schema_generate_parameter_schema_field_defaultsrr emptyrA call_schema) rnamedtuple_clsrznamedtuple_refrJrrrNrrrs rurz!GenerateSchema._namedtuple_schemarsv YY ( ( 8 a2C2C2E. J j, GG  +;; 3>2C2C2E / J33"J8V8V8Z8Z[egpgvgv8w4 -DQ  **+;^Q_`; a aG + a as;E7E$E2E E %EAE +EEEcN|tjurtj|}ntj||}|j Jd|j |j }}|jj|5|j||}ddd|js t|}tj|} ||| d<|j|j| d<| S|jj } | r | || d<| S#1swYxYw)zXPrepare a ArgumentsParameter to represent a field in a namedtuple or function signature.Nzz/GenerateSchema._tuple_schema..sR%= =Rsrr+rz&Variable tuples can only have one typer9rV) rXr<rtrir!rrEllipsisrcr ValueErrorrr)r tuple_typeparamsrs @rurzGenerateSchema._tuple_schemas1< 66zB FR6RRF[("88::#::2>> BZ8 #6{a22:vayII!!IJJ [A &)r/00R@ @00T&\J Jrwc`tjtjtddS)Nis_typezInput should be a typecustom_error_typecustom_error_message)r!custom_error_schemarrrs rurzGenerateSchema._type_schemas)..  * *4 0'!9  rwc |j|}|tk(r|jSt|tj r|j rtj|j S|jrMtj|jDcgc]$}|jtj|&c}S|jStjt|rV|j!|d}tj|Dcgc]$}|jtj|&c}Stj|Scc}wcc}w)z-Generate schema for a Type, e.g. `Type[int]`.Tr#)rxrrrprr __bound__r!is_subclass_schema__constraints__rrrr=rr)r<)rtype_ type_paramcrus rurzGenerateSchema._subclass_schemas"//6  $$& &  FNN 3##"55j6J6JKK++"//CMC]C]^aT))&++a.9^((**  * *:j+A B88d8SD++ae,fY]T-A-A&++dBS-T,fg g11*= =_ -gs )E")E'cX|j|}tj|j|}tjt j d}|tk7r1ddlm }tj|tj||g}tj||S)z5Generate schema for a Sequence, e.g. `Sequence[int]`.r)cls_reprr9)sequence_validator)r python_schema) rxr!rrrrrr _validatorsr<rano_info_wrap_validator_functionjson_or_python_schema)r sequence_type item_typerr=r<s rurzGenerateSchema._sequence_schemas..}= !--d.B.B9.MN #66vQ[\   7'44 K KL^`k lmM00[Xeffrwcl|j|}tj|j|S)z$Generate a schema for an `Iterable`.)rxr!generator_schemar)rr7rBs rurzGenerateSchema._iterable_schemas...u5 ++D,@,@,KLLrwcddlm}tdg}tjt ddtj }|tjk(s|tjk(r"tj|j||S|j|d d }|tk(r"tj|j||S|tk(r"tj|j ||St#d |d )Nr9)r>c dddS)Nstringregex)rformatrV)_1_2s ruz0GenerateSchema._pattern_schema..s XahDirwrpatternr)r return_schema)rrTr#rrry)r>rAr!rr rrrr no_info_plain_validator_functionpattern_either_validatorr<rYpattern_str_validatorrpattern_bytes_validatorr0)r pattern_typer>rserr's rurzGenerateSchema._pattern_schemas!&5i4jk>> y !V;CYCYC[  6>> )\RZZ-G??44CRZ 55 6    C<??11x e^??333QY 02^_k^nno0pq qrwctjtjtjj ddS)N is_hashablezInput should be hashabler/)r!r2rrrrrs rurzGenerateSchema._hashable_schemas3..  * *;??+C+C D+!;  rwc *jj|5\}}| |cdddSt|}||}t|dd}jj |5j j|}jddl m }||rIt|j} |rJ| jD]} | j|j nt!|j|} |j"j%dxst'j(|t+fd| j-Dd } t/|d } t/|d } t1j2|j4| j6jDcgc]}j9|j: c}| }t=|j>jd}j@j}tC||d }t1jD||| |tjF|D cgc]} | jHc} | |}jK|jLj}tC||d}jO|jjP|<t1jR|cdddcdddScc}wcc} w#1swYnxYw dddy#1swYyxYw)z Generate schema for a dataclass.Nrr+)is_pydantic_dataclass)rr3c3JK|]\}}j||ywr)r)r&rNrOrrs rur(z3GenerateSchema._dataclass_schema..Es$a$!QT33Aq*Eas #c(|jdduS)NrFr)rvs rurLz2GenerateSchema._dataclass_schema..Fs!%% "2%"?rw)key __post_init__ __slots__)r-collect_init_onlyr&)r+rrqslotsr,r0)*rr1rXrrr=rr9r dataclassesrYr__pydantic_fields__r apply_typevars_maprrU__dict__rrJr sortedrChasattrr!dataclass_args_schemarr-rEr5rrFr:r@dataclass_schemarqrrGrHrrr)r dataclassrz dataclass_refrJrr,r9rYrqrsru has_post_init has_slotsrP args_schemarr: dc_schemarrs` @rurz GenerateSchema._dataclass_schema"sYY ( ( 3@ N7T |'#@ N@ N5Y?L!" Y(=tDF++0087 N"22>>yI 44?(3%i&C&CDF#%+]]_ZE!44\4CXCXYZ6!--%1F '//334MNqR`RfRfgpRq aRXR^R^R`a?!( ? C #I{; )??&&",!;!;!B!B!D%33Az7S7ST%'4  0 Z=W=W=^=^=`bfg #-#>#>#E#E#G 5lDTV]^ '88 +%4?4F4Fy4QR5EJJR#& 66y*B^B^BeBeBgh/8H'R7;7Z7Z[a7b %%m4">>}Mo7 N7 N@ N@ NP%"Sa7 N7 N7 N@ N@ N@ NsIL 7L &D>K3$#K)A?K3K.A=K3 L ) K33K< 8L  Lct|}tj|}tjdtj dtj di}g}d}d}|jjD]\}} | j|jurt} n||} |j| j} | 0|j|| | j| } |j!| w| jtj"k(r|j%| }| jtj&k(sJ| j|j%| }d} |j(}|j*r$|jd}||j%|} t-j.t-j0||||j2|| S)zsGenerate schema for a Callable. TODO support functional validators once we support them in Config positional_onlypositional_or_keyword keyword_onlyNrX)var_args_schemavar_kwargs_schemapopulate_by_name)rN)r r=get_function_type_hintsr POSITIONAL_ONLYPOSITIONAL_OR_KEYWORD KEYWORD_ONLYrdrCrrrrkindrrrVAR_POSITIONALr VAR_KEYWORDrvalidate_returnr!rrrv)rfunctionsig type_hints mode_lookuparguments_listrtrurprparameter_mode arg_schemarNr return_hints rurzGenerateSchema._callable_schemahs !"::8D   % %'8  + +-D  " "Nr @B9=;?~~++- EGD!||syy( '- (__QVV4N)!<>6$($8$8$D! E 8< --  ) )$..2K& $ 4 4[ A &&  ( ( /"3!/!@!@   '  rwct|tjsJ|j}|j}t }t |d|}|dut|dk7z||uzdkDr td||ur|j|S|r"|jtj|S|r@|j|}tjdtj|d<|StjS)N __default__rr9zZPydantic does not support mixing more than one of TypeVar bounds, constraints and defaultsc||SrrV)xhs rurLz>GenerateSchema._unsubstituted_typevar_schema..s QqTrw)rr)rprrr4r6rrrcNotImplementedErrorrrrr!#wrap_serializer_function_ser_schemar)rtypevarrh constraintsnot_setrrs rurz,GenerateSchema._unsubstituted_typevar_schemas'6>>222!!-- ('=':  #k"2a"7 8G7.set_computed_field_metadatasX!&/K&*K #FFLLE ', G$&&,,K&-8 M* rwr)rNrrr)r:get_function_return_typefuncrr return_typerrkr1rlr r2r[rrrrr rrrrrprYrrrrAr!r) rrPr5rrnreturn_type_schemarrrrs ` rurEz%GenerateSchema._computed_field_schemas  H%>>qvvqvvGYGY[_[p[pqK + +#d5  $K1C1CD !11+>!::  01B1I1I1KQ^^ \; ..>>  5 5 =AVAVZ[A[#ANN3EeS)"2?2CCYZ_ZiZiYj kll AFFL$%AFF ! '@[?\])) NN*sqrwcttj|}j|t |}||\}}g}dfd }t |}|D]}|j |||}||} |r6t| j} | jdgj|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). cj||}|j|}n|}t||}|4t|jj }|j |||Sr)rrrrrrr)rrrrrrrs ru inner_handlerz8GenerateSchema._apply_annotations..inner_handler"s{ ??SIM$..s3&#DS&#Q #/"9&$))BWBW"X".))/;OP)&1 1rw pydantic_js_annotation_functionsrrrXr)rr<expand_grouped_metadatarrtr\_get_wrapped_inner_schemar@rr extendrrr) rrrrrrrget_inner_schemarrrs ` ` rurz!GenerateSchema._apply_annotationss4LL[YZ CCKQVWbQcd ?'* $KHJ( 28 tL% J!#== *.N   "+. +*62;;H    BB G N NOo p;Ds h *"*"3"3 O66v~N O%%1;;FHDZDZ[M &>Z 'JJx)?)?)ABE11%BE#(x M jj% ?[[]FaX/00G$))///yy,,W55#F5M F^/ /&Cdii+++..s388:!DN#3 44dii333990099 'u 8MMhX^XcXcXef  +' 'rwct|tr|jD]}|j||}i|jr|jd<|j r|j d<|j rt|j d<|jsrA dfd }t|jjdgj||S)Nrrrc||}|jttr|jt|St r||Sr)rZrprr"r)r!rrrjson_schema_updates rurzTGenerateSchema._apply_single_annotation_json_schema..json_schema_update_funcws_#*+"6K&&'9:!"3T:#**+=>O+PQ'&""34)+6&&rwr)r!rCrr-rXr6) rpr5r$_apply_single_annotation_json_schemarrrr"rr@r r)rrrrrrrs @@rurz3GenerateSchema._apply_single_annotation_json_schemafs h *"*"3"3 [BB6>Z [24 ~~.6nn"7+##4<4H4H"=1  1CHDUDU1V":. ( : : !%6 '!2 '=Q '$ '$F+44??@bdfgnn+ rwc\tddxsddfd }t|S)Nr^c||SrrV)rers rurLz:GenerateSchema._get_wrapped_inner_schema..s GFOrwc|}j|}j|}t|}|j||Sr)rrrr)rerrrrmetadata_get_schemarrs ru new_handlerz=GenerateSchema._get_wrapped_inner_schema..new_handlers\(1ABF226:FF>>vzRF#DZQW#X #/0778LMMrw)rerrXcore_schema.CoreSchema)rr\)rrrrrrs```` @rurz(GenerateSchema._get_wrapped_inner_schemas9 6=ZIgim5n6 3   ,K>>rwc|rt|}|ddk(r|d}|j|||d<|Stjd|j dd}|t j |}|d}t|j|jj|\}} tj|j|jj|j} | t$urd} n|j'| } |jjd k(r=t j(|j||| |jj* |d <|S|jjd k(sJt j,|j||| |jj* |d <|S#t$r} t!j"| | d} ~ wwxYw) z$Apply field serializers to a schema.rrrzstr|NonerNrrwrap)is_field_serializerinfo_argrNrrplain)rrrrrr!rrRrrrr r:rrrrkr1rlr rrrr) rr serializersrrr serializerrrrrnrNs rurz'GenerateSchema._apply_field_serializerss &\Ff~.%h/ #'#@#@{#[x  kk*fjj.EF?(DDSIF%RJ,D!5!5n- )  L)BBOOZ__%@%@$BWBW // $ $ 4 4[ A ##v-*5*Y*YOO(;%"/(oo77 +'  "++w666*5*Z*ZOO(;%"/(oo77 +' 3 L1AA!D!K Ls%?F.. G7G  Gc|jdd}|r!t|d}t|j|jj } t j|j|jj|j}|turd}n|j|}|jj dk(r8tj |j|||jj"} n7tj$|j|||jj"} | |d<|r||d<|S#t$r}tj||d}~wwxYw)z$Apply model serializers to a schema.rNrr)rrNrr)poprrSrrrr r:rrrrkr1rlr rr!rrr) rrrrrrrrnrN ser_schemas rurGz'GenerateSchema._apply_model_serializerss=!**UD1 k*2.J/ AUAUVH L)BBOOZ__%@%@$BWBW // $ $ 4 4[ A ##v-4?4c4cOO%"/(oo77 5 )MMOO%"/(oo77  '1F? # F5M 3 L1AA!D!K Ls?E E$ EE$r)rr>rdict[str, Any] | Nonerdict[Any, Any] | NonerXNone) rr?rrrrrrrXr)rXr>)rXr)rXr)rXr)rrrrrXr)rrrrrrrXr)rrr list[Any]rXr)rrrXrr)rrrrrXrr)rrrCallable[..., Any]rXr)T)rrrrrXr)rztype[BaseModel]rXr)rrrerrXzcore_schema.CoreSchema | None)rrrXr)rrr$z Literal[True]rXtuple[Any, ...])rrrXtuple[Any, ...] | None)F)rrr$rrXr)rrrXztuple[Any, Any])rrrXr)rrrXr)rrrzrrXr) rrYrr5rrJr$rrXzcore_schema.TypedDictField)rrYrr5rrJrXzcore_schema.ModelField)rrYrr5rrJrXzcore_schema.DataclassField)rrYrr5rrJrX _CommonField)rrrXr)rrrXr)rrrzrrXr)rrrzrrXr) rrYrz type[Any]rrr zJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | NonerXzcore_schema.ArgumentsParameter)r+rrXr)rXr)r7rrXr)rArrXr)r7rrXzcore_schema.GeneratorSchema)rTrrXr)rjztype[StandardDataclass]rzztype[StandardDataclass] | NonerXr)rrrXzcore_schema.CallSchema)rztyping.TypeVarrXr)rPzDecorator[ComputedFieldInfo]r5z2dict[str, Decorator[FieldSerializerDecoratorInfo]]rXzcore_schema.ComputedField)rrrXr)rrrrrXztuple[Any, list[Any]] | None)rrrrrz"Callable[[CoreSchema], CoreSchema]rXr)rrrrrXr)rr,rrrzlist[GetJsonSchemaFunction]rXr\)rrrz-list[Decorator[FieldSerializerDecoratorInfo]]rrrXr)rrrz1Iterable[Decorator[ModelSerializerDecoratorInfo]]rXr)Err  __qualname__rr_r classmethodrpropertyrrrrrrrrrrrrrr rrrSr[rrorr<rxr{rrr~rrrrDrr?rrrrrr rrrrrrrrrrrrrErrrrrrrrGrVrwrurrsfI/3 #% #/ #, #  #0/,     "//  <<( IkHNSB 2  &   6-1/ /&*/ /bWJr -^,       $0U.n*.d    #     $ &   #   "   #  $  (_ B*@ @ @04 XOtaJ![_      Y  (  >K< >( gM r8 DN0DN:XDN DNL3 j,45 '5 N5  # 5 n %4 %.FQ -u-u-u!C -u  -u^&P,8; B?.??+F ? & ?4 % 5&5C5 5 5n&,&;l& &rwrc.tj||Sr)r!!no_info_before_validator_functionfrrfs rurLrLs 0]0]^_ag0hrwc.tj||Sr)r! no_info_after_validator_functionrs rurLrLs{/[/[\]_e/frwc,tj|Sr)r!rP)rrJrKs rurLrLsK,X,XYZ,[rwc.tj||Sr)r!r?rs rurLrLsk.Y.YZ[]c.drwc2tj|||SN)r)r!#with_info_before_validator_functionrrrs rurLrLs;;j;j 6j<rwc2tj|||Sr)r!"with_info_after_validator_functionrs rurLrLs+:h:h 6j;rwc0tj||Sr)r!rb)rrfrs rurLrL s[5c5c j6rwc2tj|||Sr)r!!with_info_wrap_validator_functionrs rurLrLs9f9f 6j:rw))beforeno-info)afterr)rr)rr)r with-info)rr)rr)rrzMapping[tuple[FieldValidatorModes, Literal['no-info', 'with-info']], Callable[[Callable[..., Any], core_schema.CoreSchema, str | None], core_schema.CoreSchema]]_VALIDATOR_F_MATCHc|D]b}t|j|jj}|rdnd}t |jj|f|j||}d|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. rr)rTrrrr r)rr6r validatorrval_types rurrsg" i $Y^^Y^^5H5HI"*; #Y^^%8%8($CDY^^U[]gh i MrwcB|D]}|jjsyy)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)rralways)r6rs rurr-s(  >>  rwc\|jdd}|D]}|dk(r|jjdk7r#|dk(r|jjdk(rBt|j|jj}|jjdk(rF|r"t j |j|}t j|j|}|jjdk(rH|r#t j|j|} t j|j|},|jjdk(sJ|r#t j|j|}lt j|j|}|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. rNr&rr0r)rrr) rrrr rTrr!rr?rrrr)rr6r rrrs rur@r@=sc&jj-Cn 7?y~~22h>  7?y~~22h> $Y^^Y^^5H5HI >>  & ($FFPYP^P^gmn$DDinnekl ^^ H ,$HHR[R`R`iop$FFPYP^P^gmn>>&&'1 11$GGQZQ_Q_hno$EEy~~flm+n, u Mrwc|jr,tj||j|jS|jt ur,tj||j|jS|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`. )default_factoryr)rr)rr!with_default_schemarrr )rrs rurrlsr!!.. J$>$>Q[QlQl     #4 4.. J..A\A\   rwcFt|dd}t|dr@ddlm}|duxr%|jj |t|ddfv}|s t dd t|d r8t|tttd fst|j|S|y|S) z`Extract `__get_pydantic_json_schema__` from a type, handling the deprecated `__modify_schema__`.__get_pydantic_json_schema__N__modify_schema__rr___func__zkThe `__modify_schema__` method is not supported in Pydantic v2. Use `__get_pydantic_json_schema__` instead.zcustom-json-schemarz __origin__ placeholder) rrgpydanticr`rrr2rprr#rrr)rrjs_modify_functionr`has_custom_v2_modify_js_funcs rurrs %CTJr&'& d * W66??&0BJPT(UVW % ,#>) r< BYsMGY=Z8[)\0GG! rwcJeZdZUded<ded<ded<ded<ded <d ed <y ) rrr4str | list[str | int] | list[list[str | int]] | Nonerrr bool | Nonerrzdict[str, Any]rN)rr rr;rVrwrurrs& ""JJ##&& rwr)rrrrrc||||||dS)NrrrrrrrVrs rurrs ,2!6  rwc*eZdZdZddZeddZy)rz*Keeps track of references and definitions.c0t|_i|_yr)r|seenrrs rurz_Definitions.__init__s!e >@rwc#HKt|}||jvs||jvr|tj|fy|jj | |df|jj |y#|jj |wxYww)aoGet 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: - BaseModel - Dataclasses - TypedDict - TypeAliasType N)rFrrr!radddiscard)rrrs rur1z_Definitions.get_schema_or_refs(2 $)) sd&6&66 ??DE E IIMM#  'Dk! !!#& !!#&sAB" B&B"BB"NrXr)rrrXz3Iterator[tuple[str, None] | tuple[str, CoreSchema]])rr rrrrr1rVrwrurrs4A''rwrcZ|ddk(r|j|ddS|ddk(r|dS|S)Nrrrrrr\)rrs rurrsA f~))vl3T:: = (h rwc2eZdZdZddZeddZddZy) r_stackcg|_yrr rs rurz_FieldNameStack.__init__s !# rwc#~K|jj|d|jjywr)r rr)rrs rur=z_FieldNameStack.pushs) :&  s;=c:|jr|jdSy)Nrr rs rurz_FieldNameStack.gets ;;;;r? "rwNr)rrYrXzIterator[None])rXr)rr rr_rrr=rrVrwrurrs%I$ rwr)rrFieldDecoratorInforsrYrXr)rzIterable[AnyFieldDecorator]rqz Iterable[str]rXr)rz+Iterable[Decorator[FieldDecoratorInfoType]]rsrYrXz'list[Decorator[FieldDecoratorInfoType]])rrrz'list[Decorator[ValidatorDecoratorInfo]]rrrXr)rrCrr-rrrXr6)rzJsonEncoders | NonerrrrrXr)rrr6zIterable[Decorator[RootValidatorDecoratorInfo]] | Iterable[Decorator[ValidatorDecoratorInfo]] | Iterable[Decorator[FieldValidatorDecoratorInfo]]rrrXr)r6z+Iterable[Decorator[ValidatorDecoratorInfo]]rXr)rrr6z0Iterable[Decorator[ModelValidatorDecoratorInfo]]r z Literal['inner', 'outer', 'all']rXr)rr5rrrXr)rrrrrXzGetJsonSchemaFunction | None)rrrrrrrrrrrrrXr)rrrzdict[str, CoreSchema]rXzCoreSchema | None)r __future__r _annotationscollections.abcrrbrrsysrr contextlibrrrenumr functoolsrr r r itertoolsr operatorr typesrrrrrrrrrrrrrrrrr pydantic_corerr r!r"typing_extensionsr#r$r%r&r'r(r)r*annotated_handlersr,r-r,r.r/errorsr0r1r2rqr3r4r5rr6versionr7r8rOr:r;r<r=_configr>r?_core_metadatar@rA _core_utilsrBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrrUrV _forward_refrW _genericsrXrYrZr[_schema_generation_sharedr\r]_utilsr^rr`r6ra _dataclassesrbrc version_inforrrrrrgAnyFieldDecoratorModifyCoreSchemaWrapHandlerGetCoreSchemaFunctionrtTuplerir;rListrMutableSequencerjr|Set MutableSetrk frozenset FrozenSetrlrMutableMappingrmrvrrrr JsonEncodersrrrrrr@rrrrrrrrVrwrur3s 32 %8866XXuuuK,bb77)#0YY6M.tt'& 0/@&&'1iS)*13NPllm !9AST $% )* *+- 3 #'B!C[E[E[![\!&,,/ Z/ [__-L-LM JMfjj+//*D*DE :E )6+;+;[__=P=PQ*Q [__-K-K[__MdMde Je   ,6nDnMPn,n  "A @&1EOR8DI{*+ &,/9CDrrr/if[d. "7    2  , ",@, +, ,^,<9NR&*)- "K$  '   &$'$'Nrw