
    )i(>                       % 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rSSK	J
r
JrJ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  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%J&r&J'r'  SSK(J)r)  SSK*J+r+J,r,J-r-  SSK.J/r/  SSK0J1r1J2r2  SSK3J4r4  \#(       a*  \\5\$4   \\6\$4   -  r7S\8S'   \\5   \\6   -  r9S\8S'   SSK:J;r;  \5\<\=\6\>\?\@\2R                  \\\ \R                  \\!\CR                  \ER                  1rFS\8S'   \G\H\I\J\K\
\\1rLS\8S'   S:S jrMS;S jrNS<S jrOS=S jrPS>S jrQS?S  jrR\&" S!5      rSS@S" jrTSAS# jrU\&" S$5      rV\6S%.     SBS& jjrW " S' S(\1R                  5      rY\#(       a  SCS) jrZO
 " S* S+5      rZ\&" S,5      r[SDS- jr\\]" 5       r^SES. jr_SFS/ jr`\R                  " S0S19 " S2 S35      5       rb\&" S4S5S69rc\&" S75      rd " S8 S9\%\c\d4   5      reg)GzBucket 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)CallableIterableMapping)Set)deepcopy)cached_property)	Parameter)zip_longest)BuiltinFunctionTypeCodeTypeFunctionTypeGeneratorType
LambdaType
ModuleType)TYPE_CHECKINGAnyGenericTypeVaroverload)MISSING)	TypeAlias	TypeGuard
deprecated)PydanticDeprecatedSince211   )_repr_typing_extra)import_cached_base_modelr   MappingIntStrAnyAbstractSetIntStr   )	BaseModelzset[type[Any]]IMMUTABLE_NON_COLLECTIONS_TYPESBUILTIN_COLLECTIONSc                \    U R                   [        R                  [        R                  4;   $ )a*  Return whether the parameter accepts a positional argument.

```python {test="skip" lint="skip"}
def func(a, /, b, *, c):
    pass

params = inspect.signature(func).parameters
can_be_positional(params['a'])
#> True
can_be_positional(params['b'])
#> True
can_be_positional(params['c'])
#> False
```
)kindr   POSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)params    Y/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/pydantic/_internal/_utils.pycan_be_positionalr/   J   s$      ::)33Y5T5TUUU    c           	     V    [        U [        [        [        [        [
        [        45      $ N)
isinstancelisttupleset	frozensetr   r   vs    r.   sequence_liker:   ]   s    a$sI}eLMMr0   c                :     [        X5      $ ! [         a     gf = fNF)r3   	TypeError)oclass_or_tuples     r.   lenient_isinstancer@   a   s$    !,, s   
 
c                     [        U [        5      =(       a    [        X5      $ ! [         a#    [        U [        R
                  5      (       a   ge f = fr<   )r3   type
issubclassr=   r!   WithArgsTypes)clsr?   s     r.   lenient_issubclassrF   h   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"   rF   )rE   r&   s     r.   is_model_classrH   q   s     )*Ic-F#2FFr0   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_identifierrN   z   s&    
 ""$JW->->z-J)JJr0   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$ r2   )copyitemsr3   dictdeep_update)mappingupdating_mappingsupdated_mappingupdating_mappingkr9   s         r.   rT   rT      ss    llnO-$**,DA#
?3Et(L(LQ[\]_cQdQd%01CQ%G"%&"	 - . r0   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 r2   )updaterR   )rU   r[   rY   r9   s       r.   update_not_noner\      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_listr^   resultresult_namesr9   v_names         r.   unique_listrf      s[     F La%'MM!12<%%f-.  Mr0   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 r2   )_coerce_itemsr3   r4   r5   _normalize_indexeslenrj   )selfvaluerR   s      r.   __init__ValueItems.__init__   s>    ""5)edE]++++E3u:>E(-r0   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_truerj   getrp   items     r.   is_excludedValueItems.is_excluded   s     
 ||DKKOOD122r0   c                    XR                   ;   $ )zPCheck if value is contained in self._items.

:param item: key or index of value
rj   rw   s     r.   is_includedValueItems.is_included   s    
 {{""r0   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)rj   rv   ru   )rp   erx   s      r.   for_elementValueItems.for_element   s/     {{q!<<--t747r0   c                   0 nSnUR                  5        H  u  pV[        U[        5      (       dF  [        U[        5      (       d1  U R	                  U5      (       d  [        SU SUR                   35      eUS:X  a  U R                  U5      nMy  [        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   .)rR   r3   r	   AbstractSetru   r=   	__class___coerce_valueintmergerv   range
setdefault)	rp   rR   v_lengthnormalized_items	all_itemsir9   normalized_inormalized_items	            r.   rn   ValueItems._normalize_indexes   sY    24	KKMDAq'**jK.H.HDLLYZOO"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 # !  r0   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)r   ru   r4   r   rv   )rE   baseoverrider   rY   
merge_keysmergedmerged_items           r.   r   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 [        5      (       a   U $ [        U [        5      (       a  [        R	                  U S5      n U $ [        U SS5      n[        SU 35      e)N.r   z???z!Unexpected type of exclude value )r3   r	   r   rS   fromkeysgetattrr=   )rR   
class_names     r.   rm   ValueItems._coerce_items  sb    eW%%  {++MM%-E  !U;J?
|LMMr0   c                Z    Ub  U R                  U5      (       a  U$ U R                  U5      $ r2   )ru   rm   )rE   rq   s     r.   r   ValueItems._coerce_value%  s+    =CKK..L  ''r0   c                     U SL =(       d    U SL $ )NT. r8   s    r.   ru   ValueItems.is_true+  s    Dy$AH$r0   c                     S U R                   4/$ r2   r|   rp   s    r.   __repr_args__ValueItems.__repr_args__/  s    t{{#$$r0   r|   N)rq   r   rR   $AbstractSetIntStr | MappingIntStrAnyreturnNone)rx   r   r   bool)r   z	int | strr   z+AbstractSetIntStr | MappingIntStrAny | None)rR   r#   r   r   r   zdict[int | str, Any])F)r   r   r   r   r   r   r   r   )rR   r   r   r#   )rq   r   r   r   r9   r   r   r   )r   z_repr.ReprArgs)__name__
__module____qualname____firstlineno____doc__	__slots__rr   ry   r}   r   rn   classmethodr   staticmethodrm   r   ru   r   __static_attributes__r   r0   r.   rh   rh      sz    Y#I.3#8# J # #J   ( (
 % %%r0   rh   c                    g r2   r   name	get_values     r.   LazyClassAttributer   5  s    r0   c                  @    \ rS rSrSrSS jr\S	S j5       rS
S jrSr	g)r   i9  zA descriptor exposing an attribute only accessible on a class (hidden from instances).

The attribute is lazily computed and cached during the first access.
c                    Xl         X l        g r2   r   )rp   r   r   s      r.   rr   LazyClassAttribute.__init__?  s    I&Nr0   c                "    U R                  5       $ r2   )r   r   s    r.   rq   LazyClassAttribute.valueC  s    >>##r0   c                n    Uc  U R                   $ [        U R                  < SUR                  < S35      e)Nz attribute of z is class-only)rq   AttributeErrorr   r   )rp   instanceowners      r.   __get__LazyClassAttribute.__get__G  s4    zz! DII=u~~>PP^!_``r0   )r   r   N)r   strr   zCallable[[], Any]r   r   )r   r   )r   r   r   z	type[Any]r   r   )
r   r   r   r   r   rr   r   rq   r   r   r   r0   r.   r   r   9  s&    	
	' 
	$ 
	$	ar0   r   Objc                    U [         L a  U $ 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.
)
r   r   r'   r(   r5   rQ   r=   
ValueErrorRuntimeErrorr   )objobj_types     r.   smart_deepcopyr   P  sv    
 g~
}}H22
x#66"e+3;;
 C=	 z<0 s   A A A43A4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   h  s'     "-TI!N	& "O r0   c                    U b  U $ U$ )zTReturn the first argument if it is not `None`, otherwise return the second argument.r   )abs     r.   get_first_not_noner   w  s    1$1$r0   T)frozenc                  P    \ rS rSr% SrSrS\S'   S
S jr\(       a  SS jr	Sr
g	Sr
g	)SafeGetItemProxyi|  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      $ r2   )r   rv   r   rp   keys     r.   __getitem__SafeGetItemProxy.__getitem__  s    ||Y//r0   c               8    U R                   R                  U5      $ r2   )r   __contains__r   s     r.   r   SafeGetItemProxy.__contains__  s    <<,,S11r0   r   N)r   r   r   r   )r   r   r   r   )r   r   r   r   r   r   __annotations__r   r   r   r   r   r0   r.   r   r   |  s(     I0 	2 r0   r   _ModelTr&   )bound_RTc                  h    \ rS rSrSrSS jr\SS j5       r\\" SSS9SS j5       5       rSS	 jrS
r	g)deprecated_instance_propertyi  a  A decorator exposing the decorated class method as a property, with a warning on instance access.

This decorator takes a class method defined on the `BaseModel` class and transforms it into
an attribute. The attribute can be accessed on both the class and instances of the class. If accessed
via an instance, a deprecation warning is emitted stating that instance access will be removed in V3.
c                   Xl         g r2   fget)rp   r   s     r.   rr   %deprecated_instance_property.__init__  s    	r0   c                    g r2   r   rp   r   objtypes      r.   r   $deprecated_instance_property.__get__  s    FIr0   zAccessing this attribute on the instance is deprecated, and will be removed in Pydantic V3. Instead, you should access this attribute from the model class.N)categoryc                    g r2   r   r   s      r.   r   r     s	     JMr0   c                   Ubi  [         R                  S:  a  U R                  R                  OU R                  R                  R                  n[
        R                  " SU< S3[        SS9  U R                  R                  X5      " 5       $ )N)   
   zAccessing the zi attribute on the instance is deprecated. Instead, you should access this attribute from the model class.r%   )r   
stacklevel)	sysversion_infor   r   __func__warningswarnr   r   )rp   r   r   	attr_names       r.   r   r     s     ##w. 		""YY''00  MM  .R R3	 yy  355r0   r   )r   zCallable[[type[_ModelT]], _RT]r   r   )r   r   r   type[_ModelT]r   r   )r   r   r   r  r   r   )r   z_ModelT | Noner   r  r   r   )
r   r   r   r   r   rr   r   r   r   r   r   r0   r.   r   r     sK     I I	J
 M  M6r0   r   )r-   r   r   r   r   )r>   r   r?   z(type[Any] | tuple[type[Any], ...] | Noner   r   )rE   r   r?   r   r   r   )rE   r   r   zTypeGuard[type[BaseModel]])rM   r   r   r   )rU   dict[KeyType, Any]rV   r  r   r  )rU   zdict[Any, Any]r[   r   r   r   )rb   zlist[T] | tuple[T, ...]r^   zCallable[[T], str]r   zlist[T])r   r   r   zCallable[[], T]r   r]   )r   r   r   r   )r   Iterable[Any]r   r  r   r   )r   r   r   r   r   r   )fr   
__future__r   _annotationsdataclassesrK   r   r   weakrefcollectionsr   r   r   collections.abcr   r   r	   r
   r   rQ   r   	functoolsr   inspectr   	itertoolsr   typesr   r   r   r   r   r   typingr   r   r   r   r   pydantic_corer   typing_extensionsr   r   r   pydanticr    r    r!   _import_utilsr"   r   r   r#   r   r$   mainr&   floatcomplexr   bytesrB   NoneTyperefNotImplementedr   Ellipsisr'   r4   r6   r5   r7   rS   r(   r/   r:   r@   rF   rH   rN   rO   rT   r\   r]   rf   Representationrh   r   r   r   objectr   r   r   	dataclassr   r   r   r   r   r0   r.   <module>r     s!  
 3   
   7 7 7 7 .  %  ! d d A A ! > > / " 3")#s("3gc3h6G"GiG#.s#3k#6F#FyF 
 		KK '3  0 				' ^ 	V&NGK )
G CL (+' % 	,C%%% C%L Ka a( en* H	%
 d#2 2 $22 );
/en$677C<#8 $6r0   