fL iL UddlZddlZddlZddlZddlmZddlmZddlmZm Z m Z mZ m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZm Z m!Z!m"Z#m$Z% ddlm&Z' ddlm*Z+ dd l,m-Z.ej^d kr d ed e de de fdZ0n(ej^dkr d ed e de de fdZ0n d ed e de de fdZ0ej^d kreZ1n dTde d e de de fdZ1edZ2e de fZ3e ge fZ4e de2fZ5ddhZ6e!hZ7ee e8d<e9edre7juejBej^dkrdee deee fdZ;nddlm;Z<d ee deee fd!Z;ej^dkrdd"lm=Z=dee dee dffd#Z>n&dd$lm>Z?d ee dee dffd%Z@d ee dee dffd&Z>ej^d krd ee dee fd'ZAnd ee dee fd(ZAej^d)krd eee deBfd*ZCe+fZDn9ddl,Z,ddlZd eee deBfd+ZCejze,jTe,jZfZDeeEefZFerldd,lGmHZHeeeEe fddfZIe eEe fZJe e e fZKeeEZLeeEZMeeNeEfZOe eOZPe eOe fZQeeOe fZRee3ddfZSeeeeEe fZTd-ZUeUreVe ZWneVe e e fZWd.ZXdjZZdeZe!dfZ[ee e e fe8d/<ej^dkr d e deBfd0Z\n#ej^dd1dk(r d e deBfd2Z\nd e deBfd3Z\d4ee deEfd5Z]d6e eEee fd7eeEde eEee ffd8Z^d ee deBfd9Z_d ee deBfd:Z`d ee dee dffd;Zad ee dee dffd<Zbd ee deBfd=Zcd ee deBfd>Zdd e deBfd?Zed e deBfd@ZfedAeEZgd ee deBfdBZhd ee dee fdCZid4eee deBfdDZjd4eee deBfdEZkdFee deBfdGZldFee deBfdHZmdIdJd e de ddfdKZn dUdLee dMedJdNe eee eEefe3fddOdPeeeodfddf dQZpd ee dedeBee ffdRZqd e dee fdSZry#e($r ddlm)Z'YwxYw#e($rd Z+YwxYw#e($rd Z.YwxYw)VN)Callable)PathLike) TYPE_CHECKING AbstractSetAnyrClassVarDict ForwardRef GeneratorIterableListMappingNewTypeOptionalSequenceSetTupleTypeTypeVarUnion _eval_typecastget_type_hints) AnnotatedFinalLiteral NotRequiredRequired) _TypingBase)_Final) GenericAlias) UnionType type_globalnslocalnsreturnc&|j||SN) _evaluater'r(r)s X/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/pydantic/v1/typing.pyevaluate_forwardrefr0<sx11)r% cVtt|j||tS)N)recursive_guardrrr-setr.s r/r0r0As% C))(GSU)SSr1cXtt|j||dtS)Nr") type_paramsr5r6r.s r/r0r0Js)C))(G]`]b)ccr1objc t|||dS)NT)include_extras)r)r:r(r)s r/get_all_type_hintsr=Xsc8WTJJr1_T. AnnotatedMeta_AnnotatedAlias LITERAL_TYPESrr%tct|jtvrttt t St|ddS)N __origin__)type__name__AnnotatedTypeNamesrrrrgetattr)rDs r/ get_originrKqs5 7  1 1S 9- -q,--r1)rKtpct|jtvrttt t St|xs t|ddS)a4 We can't directly use `typing.get_origin` since we need a fallback to support custom generic classes like `ConstrainedList` It should be useless once https://github.com/cython/cython/issues/3537 is solved and https://github.com/pydantic/pydantic/pull/1753 is merged. rFN) rGrHrIrrrr_typing_get_originrJrLs r/rKrKzsA 8   2 2S 9- -!"%H\4)HHr1) _GenericAliasc$t|jtvr|j|jzSt |t r@|j}|jtur |r|dturt|dd|df}|St|ddS)zCompatibility version of get_args for python 3.7. Mostly compatible with the python 3.8 `typing` module version and able to handle almost all use cases. rN__args__r") rGrHrIrS __metadata__ isinstancerPrFrEllipsislistrJ)rDress r/get_argsrYs 7  1 1::. . a '**C||x'CCF(4JCH~s2w/Jq*b))r1rYct|drtf|jzS |tdk(stj dk\r |t dk(ryy#t$rYywxYw)aI In python 3.9, `typing.Dict`, `typing.List`, ... do have an empty `__args__` by default (instead of the generic ~T for example). In order to still support `Dict` for example and consider it as `Dict[Any, Any]`, we retrieve the `_nparams` value that tells us how many parameters it needs. _nparamsr"r$r")hasattrrr\rsys version_infotuple TypeErrorrOs r/_generic_get_argsrcse 2z "6BKK' ' U2Y#"2"2f"<uRy   s+A AAct|jtvr|j|jzSt |xst |ddxs t|S)aGet type arguments with all substitutions performed. For unions, basic simplifications used by Union constructor are performed. Examples:: get_args(Dict[str, int]) == (str, int) get_args(int) == () get_args(Union[int, Union[T, int], str][int]) == (int, str) get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int]) get_args(Callable[[], T][int]) == ([], int) rSr")rGrHrIrSrT_typing_get_argsrJrcrOs r/rYrYsO 8   2 2;;0 0#[wr:r'B[FWXZF[[r1c|S)zPython 3.9 and older only supports generics from `typing` module. They convert strings to ForwardRef automatically. Examples:: typing.List['Hero'] == typing.List[ForwardRef('Hero')] r"rOs r/convert_genericsrgs  r1ct}|r tdsSt}|turtt |dg|ddSt fd|D}||k(rSt tr t||St tr$tjtj|S td|S#t$rYSwxYw)a Recursively searches for `str` type hints and replaces them with ForwardRef. Examples:: convert_generics(list['Hero']) == list[ForwardRef('Hero')] convert_generics(dict['Hero', 'Team']) == dict[ForwardRef('Hero'), ForwardRef('Team')] convert_generics(typing.Dict['Hero', 'Team']) == typing.Dict[ForwardRef('Hero'), ForwardRef('Team')] convert_generics(list[str | 'Hero'] | int) == list[str | ForwardRef('Hero')] | int rSrNc3K|]:}t|trttr t|n t |<ywr,)rUstrTypingGenericAliasr rg).0argrLs r/ z#convert_generics..s<  *#s3 2GY8ZJsO`pqt`u u sAA)rKr^rYrrgrarUrlTypesUnionType functoolsreduceoperatoror_setattrAttributeError)rLoriginargs converteds` r/rgrgsBWR4I| Y .tAw7C$qr(CD D    I . /%fi8 8 N +##HLL)< < J 2I" I s8 C CCr% c|tuSr,)rrOs r/is_unionr}s U{r1c:|tuxs|tjuSr,)rtypesr#rOs r/r}r}sU{3bEOO33r1) ModelFieldF)' AnyCallableNoArgAnyCallableNoneType is_none_typedisplay_as_typeresolve_annotationsis_callable_typeis_literal_typeall_literal_values is_namedtuple is_typeddictis_typeddict_special is_new_typenew_type_supertype is_classvar is_finalvarupdate_field_forward_refsupdate_model_forward_refsTupleGenerator DictStrAnyDictAnySetStrListStrIntStrAbstractSetIntStr DictIntStrAnyCallableGeneratorReprArgsAnyClassMethodr WithArgsTypesrYrK get_sub_types typing_baser=r}StrPathMappingIntStrAny NONE_TYPESc|tvSr,rr's r/rrX  ""r1cXtD]}||usyt|rt|dk(Sy)NTr,F)rrr)r' none_types r/rr]s9# I !  5 !%e,7 7r1c|tvSr,rrs r/rrjrr1vc t|ts,t|tst|ts |j}t t |r,ddjttt|dSt|trt|jddS |jS#t$rt|jddcYSwxYw)NzUnion[z, ]ztyping.)rUrrrG __class__r}rKjoinmaprrYrkreplacerHrvrs r/rrns a %jM.JS]^_aeSf KK 1  #ox{"CDEQGG!]#1v~~i,,-zz -1v~~i,,-s) B55$CCraw_annotations module_namecd}|r tj|}|j}i}|j D]\}}t |t rJdtjcxkDrdk\sntjdk\rt|dd}n t|d} tjd k\rt||dd }n t||d}|||<|S#t$rYwxYw#t$rY#wxYw) z Partially taken from typing.get_type_hints. Resolve string or ForwardRef annotations into type objects if possible. Nrz)r%r&rC)r%r{riFT) is_argumentis_class)r)r% r")r9) r_modules__dict__KeyErroritemsrUrkr`r r NameError)rr base_globalsmodule annotationsnamevalues r/rrs .2L +[[-F "??LK&,,." e eS !))6Y6#:J:Jj:X"5edK"5e< 7*"5,"M"5,=" D" -   $   s#C0C  CC C,+C,c8|tuxst|tuSr,)rrKrs r/rrs H  = 5 1X ==r1c8tduxrt|tvSr,)rrKrArs r/rrs $  E:e#4 #EEr1ct|Sr,rZrs r/literal_valuesrs E?r1cXt|s|fSt|}td|DS)z This method is used to retrieve all Literal values as Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586) e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]` c3@K|]}t|D]}|ywr,)r)rmrxs r/roz%all_literal_values..s"Ju0B50IJ1JJs)rrra)r'valuess r/rrs. 5 !x E "F JJ JJr1cDddlm}||txr t|dS)zy Check if a given class is a named tuple. It can be either a `typing.NamedTuple` or `collections.namedtuple` rlenient_issubclass_fields)pydantic.v1.utilsrrar^r'rs r/rrs 5 eU + Iy0IIr1cDddlm}||txr t|dS)z Check if a given class is a typed dict (from `typing` or `typing_extensions`) In 3.10, there will be a public method (https://docs.python.org/3.10/library/typing.html#typing.is_typeddict) rr __total__)rrdictr^rs r/rrs 5 eT * Jwuk/JJr1c&|tuxs|tuSr,)TypedDictRequiredTypedDictNotRequiredrs r/_check_typeddict_specialrs % % F2F)FFr1cDt|xstt|S)zN Check if type is a TypedDict special form (Required or NotRequired). )rrKrs r/rrs  $E * Y.FzRWGX.YYr1 test_typecRt|tjxr t|dS)z> Check whether type_ was created using typing.NewType __supertype__)rUrrr^rs r/rrs# eY00 1 Uge_6UUr1cPt|dr|j}t|dr|S)Nr)r^rrs r/rrs( % )## % ) Lr1cf|y|jtjk(xrt|dddk(S)NF_namer)rrrJrs r/_check_classvarrs2y ;;(,, , XGT1Jj1XXr1c|y|jtjk(xr%tjdkxst |dddk(S)z9 Check if a given type is a `typing.Final` type. NFrBrr)rrr_r`rJrs r/_check_finalvarrsF y ;;%// ) qs/?/?&/H/pGTUW^`dLeipLpqr1ann_typect|stt|ry|jtk(r|jj dryy)NTz ClassVar[F)rrKrr __forward_arg__ startswithrs r/rrsCx OJx4H$IZ'H,D,D,O,OP[,\ r1cDt|xstt|Sr,)rrKrs r/rrs 8 $ M 88L(MMr1fieldrcd}|jjtk(r"d}t|j||xsd|_|jjtk(r"d}t|j||xsd|_|r|j |j r|j D]}t||||j|jyy)z] Try to update ForwardRefs on fields based on this ModelField, globalns and localns. FTNr(r)) r'rr r0 outer_type_prepare sub_fieldsrdiscriminator_key&prepare_discriminated_union_sub_fields)rr(r)rsub_fs r/rr sG {{ *)%++xDQ  ""j0/0A0A8W_X\]  %% QE %eh P Q * 446+r1modelfields json_encodersrexc_to_suppressc$|jtjvr6tj|jjj }ni}|j |j ||D]} t|||t|jD]X}t|tr t|}nt|tr|}n3 t|||xsd} |j||| <Zy#|$rYwxYw#|$rYnwxYw)zL Try to update model fields ForwardRefs based on model and localns. rN) __module__r_rrcopy setdefaultrHrr7keysrUrkr r0pop) rrrr)rr(fkeyfrnew_keys r/rr"s  3;;&;;u//099>>@ .   %a(G L =%%'( 8 c3 '_B Z (B  )"h4HG"/!2!23!7 g 8      s$7C<D<DDDDcx|turyt|yt|}|rt|dtsy|dS)z Tries to get the class of a Type[T] annotation. Returns True if Type is used without brackets. Otherwise returns None. TNr)rGrKrYrU)r'rxs r/ get_classrIsA  }%  E?D z$q'40Awr1ct|}|turtt|dSt |r+t|Dcgc]}t|D]}|c}}S|gScc}}w)z~ Return all the types that are allowed by type `tp` `tp` can be a `Union` of allowed types or an `Annotated` type r)rKrrrYr})rLrwrDrs r/rr[sc ^F Xb\!_-- & #B<Baq1ABABBBt CsA$)NNr])srqrsr_typingcollections.abcrosrrrrTypingCallablerr r r r r rrrrrrrrrrrrtyping_extensionsrrrrrrrrr ImportErrorr r!rlrr#rpr`r0r=r>rrAnyArgTCallablerIrA__annotations__r^addrKrNrPrYrercrgboolr}rrkrpydantic.v1.fieldsrrrrrrintrrrrrrMYPY classmethodr__all__rrrrrrrrrrrrrrrrrrrrrr BaseExceptionrrrr"r1r/rs $2-19 1 f2:22s2s2  "T:TTsTsTd:ddsdsd f(KKsKCKSVK T]S#X& !"c'*!b) &'89#) s3x# 69fnn%f.d3i.HT#Y$7.8 ItCy IXd3i%8 If$ *DI *%S/ * 4d3iE#s(O(\T#Y\5c?\"fT#Y49&T#Y&49&RgXd3i(T()M4Xd3i(4T4))5+=+=uOM X -uS#Xd:;Nc3hJ38nG XF3iG 38_F#F+%Mvs{+!+tT"9:hsmS012H D $S)%S#s]3( V >>%)(GDM#B E#sC- Bf#C#D# bqV# C D #C#D#-tCy-S-$ c49n)= HUXM ^bcfhlmphqcq^r F>DI>$>F49FF$s)c3h Kd3i KE#s(O KJcJtJKS KdKGCGDGZZZ K % VtCyVTVd3iDI YxS *YtYrxS *rtr $s)  N$s)NN7\7S737SW768: $8 9$8 \ "$8d3ij89;FG$8 $8 4 .34 $8  $8NT#Y5tT#Y)>#?$ c d3i c-,,-  Ns6P1$Q+Q1 Q?QQ QQQ