5jqSrSSKJr SSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK J r Jr SSKJr SSKJrJrJrJrJr SSKrSSKJrJr SS KJrJr S S KJrJr S S KJ r S S KJ!r!J"r" SSK#J$r$ SSK%J&r&J'r'J(r(J)r) SSK*J+r+J,r,J-r- SSK.J/r/ SSK0J1r1J2r2 SSK3J4r4J5r5 SSK6J7r7 SSK8J9r9 SSK:J;r; SSKr>J?r?J@r@JArAJBrB SSKCJDrDJErE SSKFJGrG \R(aS SKIJJrK S SKIJLrLJMrM S SKIJNrO S SKPJQrQ O\"rR\S"5rK\S"5rO\SRrU"SS \V5rWS!S".S9S#jjrX\"S$\K\O\X4S%9"S&S'\ 55rYS:S(jrZS;S)jr[SS,jr^S?S-jr_S$SS..S@S/jjr`SAS0jra"S1S25rb"S3S45rcSBS5jrdSBS6jre\ "SS79SCS8j5rfg)Dz"Private logic for creating models.) annotationsN)ABCMeta) lru_cachepartial) FunctionType)AnyCallableGenericLiteralNoReturn)PydanticUndefinedSchemaSerializer)dataclass_transform deprecated)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_name)GenerateSchema)PydanticGenericMetadataget_model_typevars_map)import_cached_base_modelimport_cached_field_info)set_model_mocks)CallbackGetCoreSchemaHandler)generate_pydantic_signature)_make_forward_refeval_type_backport is_annotated is_classvarmerge_cls_and_parent_nsparent_frame_namespace)ClassAttributeSafeGetItemProxy)ValidateCallWrapper)Field) FieldInfoModelPrivateAttr) PrivateAttr) BaseModelc0^\rSrSrSrSU4SjjrSrU=r$)_ModelNamespaceDict:zsA dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. c>URUS5nU(aJX#LaF[U[5(a1[R"SUSUR R S35 [TU]!X5$)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarndecorator_infodecorator_reprsuper __setitem__)selfkvexisting __class__s e/root/lseg-credit/backend/venv/lib/python3.13/site-packages/pydantic/_internal/_model_construction.pyrB_ModelNamespaceDict.__setitem__?sbD) )jCZ.[.[ MMAaS B8CZCZCiCiBjjuv ww"1(()rDstrrEobjectreturnNone)__name__ __module__ __qualname____firstlineno____doc__rB__static_attributes__ __classcell__rGs@rHr7r7:s))rJr7Finitcg)zOnly for typing purposes. Used as default value of `__pydantic_fields_set__`, `__pydantic_extra__`, `__pydantic_private__`, so they could be ignored when synthesizing the `__init__` signature. NrKrXs rH NoInitFieldr[GsrJT)kw_only_defaultfield_specifiersc^\rSrSrS SU4Sjjjr\R (dSSjr\SSj5r SU4Sjjr \ SSj5r \ \"SSS 9SS j55rSU4S jjrS rU=r$)ModelMetaclassQNc  >^ ^!^"U(GaURU5upn [R"X#U5n U RUS'[ X;R X5n U (dU (a$[ X25m T b S%U 4Sjjn XS'O [US'XS'0U EU EUS'[T#U]$"XX#40UD6n[5nURn[U;aFUR[5URU5:a[R"[!S5SS 9 [#UR$S S 5(+UlUR(UR(LaSOSUl[,R."U5UlU(aXNlGOv[#US 05R5S S5m"[#USS5=(d T"m!T!(Ga0T"(Ga([7U!4SjT"55(Gd SSKJn [=U"4SjT!55nUT";aUUT!;aOSR?UVs/sHnUR@PM sn5nUR@SUSUR@SUS3nOT"U-nSR?UVs/sHn[CU5PM sn5nSUS3nSUS3n[U;aFSR?UVs/sHnUR@PM snU/-5nUSUR@SUS3- n[EU5eSST!S.UlS Ul#U RI5HunnURKUU5 M U(a[M[O55Ul([#US S5nU5(a [WU5nUU5n[[XU U5 U R\(aS!U;a [_X5 [aUUU S UUS"9 UR0RbRI5VVs0sHunnUURd_M snnUl3[iU5 [X]"S0UD6 U$S#HnURmUS5 M UR5S$05Ro5 [T#U]$"XX#40UD6$s snfs snfs snfs snnf)&a-Metaclass for creating Pydantic models. Args: cls_name: The name of the class to be created. bases: The base classes of the class to be created. namespace: The attribute dictionary of the class to be created. __pydantic_generic_metadata__: Metadata for generic models. __pydantic_reset_parent_namespace__: Reset parent namespace. _create_model_module: The module of the class to be created, if created by `create_model`. **kwargs: Catch-all for any other keyword arguments. Returns: The new class created by the metaclass. model_configNc,>[X5 T"X5 g)z`We need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rCcontextoriginal_model_post_inits rHwrapped_model_post_init7ModelMetaclass.__new__..wrapped_model_post_init{s0>0?rJmodel_post_init__class_vars____private_attributes__zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly.r stacklevel__pydantic_base_init__F__pydantic_generic_metadata__ parametersrK__parameters__c3,># UH oT;v M g7fNrK).0xrps rH )ModelMetaclass.__new__..s?kYjTUZYjs)RootModelRootTypec36># UHoT;dM Uv M g7frsrK)rtruparent_parameterss rHrvrws.c*QQbHbqq*s  z, zS is a subclass of `RootModel`, but does not include the generic type identifier(s) zL in its parameters. You should parametrize RootModel directly, e.g., `class z (RootModel[z ]): ...`.ztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .z- Note: `typing.Generic` must go last: `class (z): ...`))originargsrp__pydantic_parent_namespace____hash__) raise_errorstypes_namespacecreate_model_module)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rCr5rerrNrO)8_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrdrA__new__r#__mro__r indexr=r>rgetattr__init____pydantic_custom_init__ri__pydantic_post_init__rbuild__pydantic_decorators__ror;all root_modelrxtuplejoinrPrL TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr-rr<dictunpack_lenient_weakvaluedictr,set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fieldsinfomodel_computed_fieldsset_deprecated_descriptors__pydantic_init_subclass__popclear)$mcscls_namebases namespacero#__pydantic_reset_parent_namespace___create_model_modulekwargsbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrgclsr5mrorxmissing_parametersruparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjparent_namespacerrDrE instance_slotrfrprzrGs$ @@@rHrModelMetaclass.__new__Ss6 DGD[D[\aDb A *A*44UvNN(6(B(BIn %!277" "%<+>y+P(+7@4K/03JI/0*4& '2c5L2cPb2cI. /#(7?3%#]V\#]C02I++C#~#))G"4syy7K"K 1B ! 07s||E]_d/e+eC (141D1D HaHa1agxC &*8*>*>s*CC '-4Q1$+C1PRT$U$Y$YZfhj$k!$S*:DAVEV "3C?kYj?k)..c*.c)c&(,==BS[eBe*.HZ3[HZ1AJJHZ3[)\"||n,-./WWZWcWcVddop~o@IJ& /@BT.T+)-DW3XDWqCFDW3X)Y/>~>Na-P*88J7K1N&#%/ )- u2Mu!1::u2MQcPd2d(eI)"OPSP\P\~]^_h^iiq rM$M22#",51 ).C %0557 c  d+834OPfPh4i1&s,KTR *D11#?@P#Q 5c;KLO S I$$9)D%c1 " /$8  @C?Z?Z?j?j?p?p?r(s?rtq!AFF?r(sC % &s + # 6 @ @J"i  !"i MM+R 0 6 6 87?3%MfM M]4\4Y3NT)tsQ2)Q7*Q<&RcnURRS5nU(a X;aX!$[U5e)zNThis is necessary to keep attribute access working for class attribute access.rk)__dict__r;AttributeError)rCitemrs rH __getattr__ModelMetaclass.__getattr__s4!%!2!23K!L !d&@)// & &rJc[5$rs)r7)rrrs rH __prepare__ModelMetaclass.__prepare__s "$$rJcH>[US5=(a [TU] U5$)zcAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrrA__instancecheck__)rCinstancerGs rHr ModelMetaclass.__instancecheck__ s# x!9:buw?XYa?bbrJcL[5n[5n[5n0nUH{n[XQ5(dMXQLdMUR[ US05R 55 URUR 5 URUR5 M} X#U4$)N model_fields)r#set issubclassupdaterkeysrjrk)rr5 field_namesrrbases rHr"ModelMetaclass._collect_bases_datas,. # "u :<D$**t/D""74#D#I#I#KL!!$"5"56"))$*E*EF  (:::rJEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorycP[R"S[5 UR$)Nr)r=r>rrrCs rH __fields__ModelMetaclass.__fields__"s$  SUn    rJcd>[[TU] 55nSU;aURS5 U$)Nr)listrA__dir__remove)rC attributesrGs rHrModelMetaclass.__dir__*s0%'/+, : %   l +rJrK)NTN)rrLrtuple[type[Any], ...]rdict[str, Any]rozPydanticGenericMetadata | Nonerboolr str | NonerrrNtype)rrLrNr)rrrrrNzdict[str, object])rrrNr)rrrNz6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rNzdict[str, FieldInfo])rNz list[str])rPrQrRrSrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrUrVrWs@rHr_r_QsIM48+/iNiN%iN" iN (F iN .2 iN)iNiN iNiNV    '%%c ; ;Wbfg!h! rJr_c[USS5cR0nURR5H$up4UR5nU[LdM XRU'M& [ USU5 gg)zThis function is meant to behave like a BaseModel method to initialise private attributes. It takes context as an argument since that's what pydantic-core passes when calling it. Args: self: The BaseModel instance. context: The context. rN)rrkr get_defaultr object_setattr)rCrepydantic_privater private_attrdefaults rHrdrd1skt+T2:"&"="="C"C"E D"..0G//)0&#F t35EF ;rJcfSU;aUS$[5n[US5nX2RLaU$g)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.riN)r#rri)rrr5ris rHrrCsBI%*++(*I.u6GHO7778rJc ,^SSKJmJn [5nU[ 5-n0nUR S05nSU;dSU;a [ S5e[5n [UR55GHupU S:XdU S:XaM[U [5(a>U RUS:Xa+S U;a%U RRUS 5(aMg[X5(dU RRS :XaU R!U 5 M[U T5(aVU RS 5(a[#S U <S 35e[%U 5(a[#SSU -<SU <S 35eXU 'X GM [X5(a>[%U 5(d.U R'S5=(d Sn [#SU <SU <S 35eU RS 5(aGMr[)U 5(a'X;d[+X5(d U"U S9Xz'X GMGMX;aGMX;dGMX;a[-SU <S3SS9e[X5(a[-SU <S3SS9e[-SU SU <SU S3SS9e UR5Hup[)U 5(dMX;dMX;dM%[+U5(aM7X;dM>[/USS5S :wdMQ[U[05(aB[2R4"S5nUb)[7[9USS S!9UR:UR<S"9n[?U5(a7[@RB"U5tnn[EU4S#jU5S5nUbUX}'MU"5X}'M U$!["[ 4a Nhf=f)$aIterate over the namespace and: * gather private attributes * check for items which look like fields but are not (e.g. have no annotation) and warn. Args: namespace: The attribute dictionary of the class to be created. ignored_types: A tuple of ignore types. base_class_vars: A set of base class class variables. base_class_fields: A set of base class fields. Returns: A dict contains private attributes info. Raises: TypeError: If there is a `__root__` field in model. NameError: If private attribute name is invalid. PydanticUserError: - If a field does not have a type annotation. - If a field on base class was overridden by a non-annotated attribute. r)r3r4r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rbrrQrR functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of r|zJPrivate attributes must not use valid field names; use sunder names, e.g. _z instead of my_fieldz>Fields must not use names with leading underscores; e.g., use )rzField z defined on a base class was overridden by a non-annotated attribute. All field definitions, including overrides, require a type annotation.zmodel-field-overridden)codez requires a type annotationzmodel-field-missing-annotationz)A non-annotated attribute was detected: `z = z3`. All model fields require a type annotation; if `z` is not meant to be a field, you may be able to resolve this error by annotating it as a `ClassVar` or updating `model_config['ignored_types']`.NFT) is_argumentis_class)globalnslocalnsc3N># UHn[UT5(dMUv M g7frs)r<)rtrEr3s rHrv$inspect_namespace..s$\1JqJZ<[QQs% %)#fieldsr3r4r$default_ignored_typesr;rrrrr<rrQrR startswithrGadd NameErrorrlstriprr+rrrLsys _getframer)r( f_globalsf_localsr*typing_extensionsget_argsnext)rrbase_class_varsbase_class_fieldsr4r2all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarr3s @rHrrOs47(*I%(=(??68mm$5r:O_$ i(?opp!eM  12 ~ %5I)I  ud # #  Il$;;)+""--i.GHH   1 1U__5O5OS^5^   h '  / 0 0""4((BBJQP%X..//2X~.@ XLXY[,1x (#  ) )2Eh2O2O%__S1?ZN,/|H make_hash_func..s^_rJc>[T"UR55$![a' [T"[UR555s$f=frs)hashrKeyErrorr/)rCgetters rH hash_func!make_hash_func..hash_funcsJ At}}-. . A / >?@ @  As.AA)rCrrNint)roperator itemgetterr)rr0r/s @rHr%r%s;>A>N>NX #"2"2"7"7"9 :T_FA rJc [U5n[XX#US9upVXPlURR U5 UHOnUR R US5nUcM$UR[LdM9[XUR5 MQ g)aCollect and set `cls.model_fields` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. bases: Parents of the class, generally `cls.__bases__`. config_wrapper: The config wrapper instance. types_namespace: Optional extra namespace to look for types in. ) typevars_mapN) r"rrrjrrkrrr setattr) rrrrr6r rrDrs rHrrs~*#.L-c.htuFj) **..q$7  6G!G CEMM *rJ)rrc [U5n[UUU5n[[URSS9USS9nUR (aSUR ;a [X5 gURX5n URU5n URU 5n Xl[U UU=(d UR UR"U(aSOS U UR$5Ul[)X5UlS Ul[/S [1UR2UR4US 95Ulg ![a,n U(ae[XSU RS35 Sn A gSn A ff=f!URa [X5 gf=f) aFinish building a model class. This logic must be called after class has been created since validation functions must be bound and `get_type_hints` requires a class object. Args: cls: BaseModel or dataclass. cls_name: The model or dataclass name. config_wrapper: The config wrapper instance. raise_errors: Whether to raise errors. types_namespace: Optional extra namespace to look for types in. create_model_module: The module of the class to be created, if created by `create_model`. Returns: `True` if the model is successfully completed, else `False`. Raises: PydanticUndefinedAnnotation: If `PydanticUndefinedAnnotation` occurs in`__get_pydantic_core_schema__` and `raise_errors=True`. F)from_dunder_get_core_schemaunpack)ref_modemodelr:N create_modelr5T __signature__)rYr r)r"r r&rgenerate_schema defer_buildexperimental_defer_build_moder%__get_pydantic_core_schema__rr core_config clean_schemaCollectedInvalid__pydantic_core_schema__rrQrRplugin_settingsrr__pydantic_serializer__rr.r'rrr>) rrrrrrr6 gen_schemahandlerschemaerCs rHrrs}:*#.LJ + **NG !!g1]1]&]&11#?!,,S1K((0 $* !8 -s~~ -;&&"C#36"GC $C'#c>N>N_mnC E '  166(!}5   & &&s*$D*E#* E 4"EE #FFcURR5H>upUR=ncM[U5nUR X5 [ XU5 M@ UR R5HnupUR=ncM[[UR5S5(aM<[X5R5nUR X5 [ XU5 Mp g)z8Set data descriptors on the class for deprecated fields.N__deprecated__) rrdeprecation_message_DeprecatedFieldDescriptorrr7rrrwrapped_property)rfield field_infomsgdesccomputed_field_infos rHrrgs --33511 1C >-c2D   c ) C % 6 '*&?&?&E&E&G"';; ;S H34G4X4XY[kll-c3W3WXD   c ) C %'HrJcT\rSrSr%SrS\S'S S SjjrS SjrS SSjjrSS jr S r g)rPiza9Data descriptor used to emit a runtime deprecation warning before accessing a deprecated field. Attributes: msg: The deprecation message to be emitted. wrapped_property: The property instance if the deprecated field is a computed field, or `None`. field_name: The name of the field being deprecated. rL field_nameNcXlX lgrs)rTrQ)rCrTrQs rHr#_DeprecatedFieldDescriptor.__init__s  0rJcX lgrs)rX)rCrrs rHr'_DeprecatedFieldDescriptor.__set_name__srJcUc[UR5e[R"UR[ R SS9 URbURRX5$URUR$)Nrrl) rrXr=r>rTbuiltinsDeprecationWarningrQ__get__r)rCrobj_types rHr`"_DeprecatedFieldDescriptor.__get__sf ; 1 1 dhh ; ;J  ,((00? ?||DOO,,rJc,[UR5ers)rrX)rCrrs rH__set__"_DeprecatedFieldDescriptor.__set__sT__--rJ)rXrTrQrs)rTrLrQzproperty | NonerNrO)rtype[BaseModel]rrLrNrO)rzBaseModel | Noneraztype[BaseModel] | NonerNr)rrrrrNr ) rPrQrRrSrTrrrr`rdrUrKrJrHrPrPzs"O1-.rJrPc6\rSrSrSrSSjrS SjrS SjrSrg) _PydanticWeakRefiaWrapper for `weakref.ref` that enables `pickle` serialization. Cloudpickle fails to serialize `weakref.ref` objects due to an arcane error related to abstract base classes (`abc.ABC`). This class works around the issue by wrapping `weakref.ref` instead of subclassing it. See https://github.com/pydantic/pydantic/issues/6763 for context. Semantics: - If not pickled, behaves the same as a `weakref.ref`. - If pickled along with the referenced object, the same `weakref.ref` behavior will be maintained between them after unpickling. - If pickled without the referenced object, after unpickling the underlying reference will be cleared (`__call__` will always return `None`). cPUcSUlg[R"U5Ulgrs)_wrweakrefref)rCrs rHr_PydanticWeakRef.__init__s ;DH{{3'DHrJc>URcgUR5$rsrjrs rH__call___PydanticWeakRef.__call__s 88 88: rJc[U"544$rs)rhrs rH __reduce___PydanticWeakRef.__reduce__s$&**rJroN)rr)rNr)rNz4tuple[Callable, tuple[weakref.ReferenceType | None]]) rPrQrRrSrTrrprsrUrKrJrHrhrhs ( +rJrhcUcg0nUR5Hup#[U5nXAU'M U$![a UnNf=f)aHTakes an input dictionary, and produces a new value that (invertibly) replaces the values with weakrefs. We can't just use a WeakValueDictionary because many types (including int, str, etc.) can't be stored as values in a WeakValueDictionary. The `unpack_lenient_weakvaluedict` function can be used to reverse this operation. N)rrhr)dresultrDrEproxys rHrrsX y F  $Q'Eq  M E s 2 AAcUcg0nUR5H0up#[U[5(aU"5nUbX1U'M*M,X1U'M2 U$)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr<rh)rvrwrDrEs rHrrsWy F  a) * *A}q 1I  MrJ)maxsizecPSSKJn [[[[ [ U[4$)NrComputedFieldInfo)r r}rrrrrr0r|s rHr r s&*  rJ)rYzLiteral[False]rNrr)rrrrrNzCallable[..., Any] | None) rrrrrset[str]rr~rNzdict[str, ModelPrivateAttr])rrfrrrNrO)rrfrNr) rrfrrrrrrrNrO)rrfrrLrrrrrdict[str, Any] | NonerrrNr)rrfrNrO)rvrrNr)rNr)grT __future__r _annotationsr^r3rrr=rkabcrrrrtypesrrr r r r r pydantic_corer rrrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsrrr_generate_schemar _genericsr!r" _import_utilsr#r$ _mock_val_serr%_schema_generation_sharedr& _signaturer' _typing_extrar(r)r*r+r,r-_utilsr.r/_validate_callr0rr r1PydanticModelFieldr2r3r4PydanticModelPrivateAttrmainr5r_rM __setattr__rrr7r[r_rdrrrr%rrrrPrhrrr rKrJrHrs(2 (<<==C>O"ssYY,FM*C35/ 44@ 3%x## )$ )!  T=OQikv