
    5j1                       % S r SSKJr  SSKrSSKrSSKrSSKrSSKJ	r	J
r
Jr  SSKJr  SSKJr  SSKJrJrJrJrJrJr  SSKJrJrJr  SS	KJrJr  S
SKJrJr  S
SK J!r!  \RD                  (       a  Sr#S\$S'   Sr%S\$S'   SSK&J'r'  \(\)\*\+\,\-\.\R^                  \\\\R`                  \\\1Rd                  \3Rd                  1r4S\$S'   \5\6\7\8\9\	\
\1r:S\$S'   S.S jr;S/S jr<S0S jr=S1S jr>S2S jr?\" S5      r@S3S jrAS4S jrB\" S5      rC\+S .     S5S! jjrD " S" S#\R                  5      rF\RD                  (       a  S6S$ jrGO
 " S% S&5      rG\" S'5      rHS7S( jrI\J" 5       rKS8S) jrL\R                  " S*S+9 " S, S-5      5       rNg)9zBucket of reusable internal utilities.

This should be reduced as much as possible with functions only used in one place, moved to that place.
    )annotationsN)OrderedDictdefaultdictdeque)deepcopy)zip_longest)BuiltinFunctionTypeCodeTypeFunctionTypeGeneratorType
LambdaType
ModuleType)AnyMappingTypeVar)	TypeAlias	TypeGuard   )_repr_typing_extra)import_cached_base_modelz3typing.Mapping[int, Any] | typing.Mapping[str, Any]r   MappingIntStrAnyz1typing.AbstractSet[int] | typing.AbstractSet[str]AbstractSetIntStr   )	BaseModelzset[type[Any]]IMMUTABLE_NON_COLLECTIONS_TYPESBUILTIN_COLLECTIONSc           	     V    [        U [        [        [        [        [
        [        45      $ N)
isinstancelisttupleset	frozensetr   r   vs    X/root/lseg-credit/backend/venv/lib/python3.13/site-packages/pydantic/_internal/_utils.pysequence_liker(   A   s    a$sI}eLMM    c                :     [        X5      $ ! [         a     gf = fNF)r    	TypeError)oclass_or_tuples     r'   lenient_isinstancer/   E   s$    !,, s   
 
c                     [        U [        5      =(       a    [        X5      $ ! [         a#    [        U [        R
                  5      (       a   ge f = fr+   )r    type
issubclassr,   r   WithArgsTypes)clsr.   s     r'   lenient_issubclassr5   L   sF    #t$HC)HH c=6677s   !$ )AAc                @    [        5       n[        X5      =(       a    XL$ )zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking,
unlike raw calls to lenient_issubclass.
)r   r5   )r4   r   s     r'   is_model_classr7   U   s     )*Ic-F#2FFr)   c                f    U R                  5       =(       a    [        R                  " U 5      (       + $ )zChecks that a string is a valid identifier and not a Python keyword.
:param identifier: The identifier to test.
:return: True if the identifier is valid.
)isidentifierkeyword	iskeyword)
identifiers    r'   is_valid_identifierr=   ^   s&    
 ""$JW->->z-J)JJr)   KeyTypec                    U R                  5       nU Hc  nUR                  5        HL  u  pEXB;   a>  [        X$   [        5      (       a'  [        U[        5      (       a  [	        X$   U5      X$'   MH  XRU'   MN     Me     U$ r   )copyitemsr    dictdeep_update)mappingupdating_mappingsupdated_mappingupdating_mappingkr&   s         r'   rC   rC   i   ss    llnO-$**,DA#
?3Et(L(LQ[\]_cQdQd%01CQ%G"%&"	 - . r)   c                    U R                  UR                  5        VVs0 s H  u  p#Uc  M
  X#_M     snn5        g s  snnf r   )updaterA   )rD   rJ   rH   r&   s       r'   update_not_nonerK   t   s.    NNV\\^E^TQqDAD^EFEs   	;
;
T)name_factoryc                   / n/ nU  HG  nU" U5      nXS;  a$  UR                  U5        UR                  U5        M4  XBUR                  U5      '   MI     U$ )zMake a list unique while maintaining order.
We update the list if another one with the same name is set
(e.g. model validator overridden in subclass).
)appendindex)
input_listrM   resultresult_namesr&   v_names         r'   unique_listrU   {   s[     F La%'MM!12<%%f-.  Mr)   c                      \ rS rSrSrSrSS jrSS jrSS jrSS jr	SS jr
\SSS	 jj5       r\SS
 j5       r\SS j5       r\SS j5       rSS jrSrg)
ValueItems   zOClass for more convenient calculation of excluded or included fields on values.)_items_typec                    U R                  U5      n[        U[        [        45      (       a  U R	                  U[        U5      5      nX l        g r   )_coerce_itemsr    r!   r"   _normalize_indexeslenrY   )selfvaluerA   s      r'   __init__ValueItems.__init__   s>    ""5)edE]++++E3u:>E(-r)   c                V    U R                  U R                  R                  U5      5      $ )zGCheck if item is fully excluded.

:param item: key or index of a value
)is_truerY   getr_   items     r'   is_excludedValueItems.is_excluded   s     
 ||DKKOOD122r)   c                    XR                   ;   $ )zPCheck if value is contained in self._items.

:param item: key or index of value
rY   rf   s     r'   is_includedValueItems.is_included   s    
 {{""r)   c                l    U R                   R                  U5      nU R                  U5      (       d  U$ S$ )z}:param e: key or index of element on value
:return: raw values for element if self._items is dict and contain needed element
N)rY   re   rd   )r_   erg   s      r'   for_elementValueItems.for_element   s/     {{q!<<--t747r)   c                   0 nSnUR                  5        H  u  pV[        U[        R                  5      (       dP  [        U[        R                  5      (       d1  U R                  U5      (       d  [        SU SUR                   35      eUS:X  a  U R                  U5      nM  [        U[        5      (       d  [        S5      eUS:  a  X%-   OUnU R                  XcR                  U5      5      X7'   M     U(       d  U$ U R                  U5      (       a&  [        U5       H  nUR                  US5        M     U$ [        U5       H@  nUR                  U0 5      nU R                  U5      (       a  M-  U R                  XH5      X5'   MB     U$ )a-  :param items: dict or set of indexes which will be normalized
:param v_length: length of sequence indexes of which will be

>>> self._normalize_indexes({0: True, -2: True, -1: True}, 4)
{0: True, 2: True, 3: True}
>>> self._normalize_indexes({'__all__': True}, 4)
{0: True, 1: True, 2: True, 3: True}
Nz,Unexpected type of exclude value for index "z" __all__zExcluding fields from a sequence of sub-models or dicts must be performed index-wise: expected integer keys or keyword "__all__"r   .)rA   r    typingr   AbstractSetrd   r,   	__class___coerce_valueintmergere   range
setdefault)	r_   rA   v_lengthnormalized_items	all_itemsir&   normalized_inormalized_items	            r'   r]   ValueItems._normalize_indexes   sh    24	KKMDAq&..11Z6CUCU5V5VZ^ZfZfghZiZi"NqcQSTUT_T_S` abbI~ ..q1	a%%A  ,-q58<aL-1ZZ;O;OP\;]-^* " ##<<	""8_ ++As3 %##xA.99!R@O<<00&*jj&L # !  r)   c                6   U R                  U5      nU R                  U5      nUc  U$ U R                  U5      (       d  Uc  U$ U R                  U5      (       a  U(       a  U$ U$ U(       a6  U Vs/ s H  oDU;   d  M
  UPM     snU Vs/ s H  oDU;   d  M
  UPM     sn-   nO&[        U5      U Vs/ s H  oDU;  d  M
  UPM     sn-   n0 nU H;  nU R                  UR	                  U5      UR	                  U5      US9nUc  M7  XvU'   M=     U$ s  snf s  snf s  snf )a   Merge a `base` item with an `override` item.

Both `base` and `override` are converted to dictionaries if possible.
Sets are converted to dictionaries with the sets entries as keys and
Ellipsis as values.

Each key-value pair existing in `base` is merged with `override`,
while the rest of the key-value pairs are updated recursively with this function.

Merging takes place based on the "union" of keys if `intersect` is
set to `False` (default) and on the intersection of keys if
`intersect` is set to `True`.
)	intersect)rw   rd   r!   ry   re   )r4   baseoverrider   rH   
merge_keysmergedmerged_items           r'   ry   ValueItems.merge   s    $$X.  &K;;tO;;x  $42(2 %);T(]!T;(>`(Q[_V_q(>``Jd(&L(Qtmq(&LLJ')A))DHHQKaI)VK&'q	 
  <>`&Ls$   /	D<D	DD/	D<Dc                    [        U [        R                  5      (       a   U $ [        U [        R                  5      (       a  [        R                  U S5      n U $ [        U SS5      n[        SU 35      e)N.rv   z???z!Unexpected type of exclude value )r    rt   r   ru   rB   fromkeysgetattrr,   )rA   
class_names     r'   r\   ValueItems._coerce_items   sl    eV^^,,  v1122MM%-E  !U;J?
|LMMr)   c                Z    Ub  U R                  U5      (       a  U$ U R                  U5      $ r   )rd   r\   )r4   r`   s     r'   rw   ValueItems._coerce_value	  s+    =CKK..L  ''r)   c                     U SL =(       d    U SL $ )NT. r%   s    r'   rd   ValueItems.is_true  s    Dy$AH$r)   c                     S U R                   4/$ r   rk   )r_   s    r'   __repr_args__ValueItems.__repr_args__  s    t{{#$$r)   rk   N)r`   r   rA   $AbstractSetIntStr | MappingIntStrAnyreturnNone)rg   r   r   bool)ro   z	int | strr   z+AbstractSetIntStr | MappingIntStrAny | None)rA   r   r|   rx   r   zdict[int | str, Any])F)r   r   r   r   r   r   r   r   )rA   r   r   r   )r`   r   r   r   r&   r   r   r   )r   z_repr.ReprArgs)__name__
__module____qualname____firstlineno____doc__	__slots__ra   rh   rl   rp   r]   classmethodry   staticmethodr\   rw   rd   r   __static_attributes__r   r)   r'   rW   rW      sz    Y#I.3#8# J # #J   ( (
 % %%r)   rW   c                    g r   r   namer`   s     r'   ClassAttributer     s    #r)   c                  0    \ rS rSrSrSrSS jrSS jrSrg)	r   i  z(Hide class attribute from its instances.r   c                    Xl         X l        g r   r   )r_   r   r`   s      r'   ra   ClassAttribute.__init__"  s    IJr)   c                n    Uc  U R                   $ [        U R                  < SUR                  < S35      e)Nz attribute of z is class-only)r`   AttributeErrorr   r   )r_   instanceowners      r'   __get__ClassAttribute.__get__&  s4    zz! DII=u~~>PP^!_``r)   N)r   strr`   r   r   r   )r   r   r   z	type[Any]r   r   )	r   r   r   r   r   r   ra   r   r   r   r)   r'   r   r     s    6#			ar)   r   Objc                    U R                   nU[        ;   a  U $  U (       d%  U[        ;   a  U[        L a  U $ U R	                  5       $ [        U 5      $ ! [
        [        [        4 a     N"f = f)zReturn type as is for immutable built-in types
Use obj.copy() for built-in empty collections
Use copy.deepcopy() for non-empty collections and unknown objects.
)	rv   r   r   r"   r@   r,   
ValueErrorRuntimeErrorr   )objobj_types     r'   smart_deepcopyr   /  sj    
 }}H22
x#66"e+3;;
 C=	 z<0 s   A A A)(A)c                >    [        X[        S9 H  u  p#X#Ld  M    g   g)zCheck that the items of `left` are the same objects as those in `right`.

>>> a, b = object(), object()
>>> all_identical([a, b, a], [a, b, a])
True
>>> all_identical([a, b, [a]], [a, b, [a]])  # new list object, while "equal" is not "identical"
False
)	fillvalueFT)r   	_SENTINEL)leftright	left_item
right_items       r'   all_identicalr   E  s'     "-TI!N	& "O r)   T)frozenc                  d    \ rS rSr% SrSrS\S'   S
S jr\R                  (       a  SS jr
Srg	Srg	)SafeGetItemProxyiT  zWrapper redirecting `__getitem__` to `get` with a sentinel value as default

This makes is safe to use in `operator.itemgetter` when some keys may be missing
)wrappedzMapping[str, Any]r   c               B    U R                   R                  U[        5      $ r   )r   re   r   r_   keys     r'   __getitem__SafeGetItemProxy.__getitem__a  s    ||Y//r)   c               8    U R                   R                  U5      $ r   )r   __contains__r   s     r'   r   SafeGetItemProxy.__contains__j  s    <<,,S11r)   r   N)r   r   r   r   )r   r   r   r   )r   r   r   r   r   r   __annotations__r   rt   TYPE_CHECKINGr   r   r   r)   r'   r   r   T  s.     I0 	2 r)   r   r   )r-   r   r.   z(type[Any] | tuple[type[Any], ...] | Noner   r   )r4   r   r.   r   r   r   )r4   r   r   zTypeGuard[type[BaseModel]])r<   r   r   r   )rD   dict[KeyType, Any]rE   r   r   r   )rD   zdict[Any, Any]rJ   r   r   r   )rQ   zlist[T] | tuple[T, ...]rM   ztyping.Callable[[T], str]r   zlist[T])r   r   r`   rL   r   rL   )r   r   r   r   )r   typing.Iterable[Any]r   r   r   r   )Or   
__future__r   _annotationsdataclassesr:   rt   weakrefcollectionsr   r   r   r@   r   	itertoolsr   typesr	   r
   r   r   r   r   r   r   r   typing_extensionsr   r    r   r   _import_utilsr   r   r   r   r   mainr   rx   floatcomplexr   r   bytesr1   NoneTyperefNotImplementedrv   Ellipsisr   r!   r#   r"   r$   rB   r   r(   r/   r5   r7   r=   r>   rC   rK   rL   rU   RepresentationrW   r   r   r   objectr   r   	dataclassr   r   r)   r'   <module>r      s  
 3     7 7  ! d d ( ( 2 " 3	"WiW#VyV 
 		KK '3  0 				' ^ 	NGK )
G CL /2' , 	,C%%% C%L 
5a a en& H	 d#2 2 $2r)   