
    zi-                    Z   U d Z ddlmZ ddlZddlZddlZddlmZm	Z	m
Z
 ddlmZ ddlmZ ddlmZmZmZmZmZmZ ddlmZmZ dd	lmZmZ d
dlmZmZ ej        rdZde d<   dZ!de d<   ddl"m#Z# e$e%e&e'e(e)e*ej+        eeeej,        eee-j.        e/j.        hZ0de d<   e1e2e3e4e5ee	e
hZ6de d<   dEdZ7dFdZ8dGd Z9dHd"Z:dId%Z; ed&          Z<dJd*Z=dKd.Z> ed/          Z?e'd0dLd6Z@ G d7 d8ejA                  ZBej        rdMd;ZCn G d< d=          ZC ed>          ZDdNd@ZE eF            ZGdOdDZHdS )PzBucket 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TypeVar)	TypeAlias	TypeGuard   )_repr_typing_extraz3typing.Mapping[int, Any] | typing.Mapping[str, Any]r   MappingIntStrAnyz1typing.AbstractSet[int] | typing.AbstractSet[str]AbstractSetIntStr   	BaseModelzset[type[Any]]IMMUTABLE_NON_COLLECTIONS_TYPESBUILTIN_COLLECTIONSvr   returnboolc           	     j    t          | t          t          t          t          t
          t          f          S N)
isinstancelisttupleset	frozensetr   r   r   s    d/var/www/tmov.alphamb/tmov_inventario/venv/lib/python3.11/site-packages/pydantic/_internal/_utils.pysequence_liker)   >   s    a$sI}eLMMM    oclass_or_tuple(type[Any] | tuple[type[Any], ...] | Nonec                F    	 t          | |          S # t          $ r Y dS w xY wNF)r"   	TypeError)r+   r,   s     r(   lenient_isinstancer1   B   s9    !^,,,   uus    
  clsc                    	 t          | t                    ot          | |          S # t          $ r t          | t          j                  rY dS  w xY wr/   )r"   type
issubclassr0   r   WithArgsTypes)r2   r,   s     r(   lenient_issubclassr7   I   s`    #t$$HC)H)HH   c=677 	55s   $' $AATypeGuard[type[BaseModel]]c                6    ddl m} t          | |          o| |uS )zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking,
    unlike raw calls to lenient_issubclass.
    r   r   )mainr   r7   )r2   r   s     r(   is_model_classr;   R   s0     !     c9--F#Y2FFr*   
identifierstrc                T    |                                  ot          j        |            S )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)r<   s    r(   is_valid_identifierrB   [   s)    
 ""$$JW->z-J-J)JJr*   KeyTypemappingdict[KeyType, Any]updating_mappingsc                   |                                  }|D ]o}|                                D ]X\  }}||v rJt          ||         t                    r/t          |t                    rt	          ||         |          ||<   S|||<   Yp|S r!   )copyitemsr"   dictdeep_update)rD   rF   updated_mappingupdating_mappingkr   s         r(   rK   rK   f   s    llnnO- ' '$**,, 	' 	'DAqO##
?13Et(L(L#Q[\]_cQdQd#%01CQ%G%G""%&""		'
 r*   dict[Any, Any]updateNonec                h    |                      d |                                D                        d S )Nc                    i | ]
\  }}|||S r!    ).0rN   r   s      r(   
<dictcomp>z#update_not_none.<locals>.<dictcomp>r   s    EEETQq}Aq}}}r*   )rP   rI   )rD   rP   s     r(   update_not_nonerW   q   s1    NNEEV\\^^EEEFFFFFr*   T)name_factory
input_listlist[T] | tuple[T, ...]rY   typing.Callable[[T], str]list[T]c                   g }g }| D ]T} ||          }||vr+|                     |           |                     |           <|||                    |          <   U|S )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)rZ   rY   resultresult_namesr   v_names         r(   unique_listrd   x   s~     F L 3 3a%%'''MM!12F<%%f--..Mr*   c                      e Zd ZdZdZd#d	Zd$dZd$dZd%dZd&dZ	e
d'd(d            Zed)d            Ze
d*d            Zed+d            Zd,d!Zd"S )-
ValueItemszOClass for more convenient calculation of excluded or included fields on values.)_items_typevaluer   rI   $AbstractSetIntStr | MappingIntStrAnyr   rQ   c                    |                      |          }t          |t          t          f          r#|                     |t          |                    }|| _        d S r!   )_coerce_itemsr"   r#   r$   _normalize_indexeslenrg   )selfri   rI   s      r(   __init__zValueItems.__init__   sQ    ""5))edE]++ 	?++E3u::>>E(-r*   itemr   c                \    |                      | j                            |                    S )zWCheck if item is fully excluded.

        :param item: key or index of a value
        )is_truerg   getro   rq   s     r(   is_excludedzValueItems.is_excluded   s$    
 ||DKOOD11222r*   c                    || j         v S )z`Check if value is contained in self._items.

        :param item: key or index of value
        rg   ru   s     r(   is_includedzValueItems.is_included   s    
 t{""r*   e	int | str+AbstractSetIntStr | MappingIntStrAny | Nonec                h    | j                             |          }|                     |          s|nd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)rg   rt   rs   )ro   rz   rq   s      r(   for_elementzValueItems.for_element   s2     {q!!<<--7tt47r*   r   v_lengthintdict[int | str, Any]c                ,   i }d}|                                 D ]\  }}t          |t          j                  sIt          |t          j                  s/|                     |          st          d| d|j                   |dk    r|                     |          }t          |t                    st          d          |dk     r||z   n|}| 
                    ||                    |                    ||<   |s|S |                     |          r*t          |          D ]}|                    |d           |S t          |          D ]F}|                    |i           }|                     |          s| 
                    ||          ||<   G|S )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   .)rI   r"   typingMappingAbstractSetrs   r0   	__class___coerce_valuer   mergert   range
setdefault)	ro   rI   r   normalized_items	all_itemsir   normalized_inormalized_items	            r(   rm   zValueItems._normalize_indexes   s    24	KKMM 	_ 	_DAqq&.11 cZ6CU5V5V cZ^ZfZfghZiZi c aq a aTUT_ a abbbI~~ ..q11	a%% A   ,-q558a<<aL-1ZZ;K;O;OP\;];]-^-^\** 	$##<<	"" 	$8__ 4 4 ++As3333##x 	M 	MA.99!R@@O<<00 M&*jjO&L&L #r*   Fbaseoverride	intersectc                   |                                |                                S |                               sS |                               r|rnS |rfdD             fdD             z   }nt                    fdD             z   }i }|D ]G}|                                         |                              |          |          }||||<   H|S )aH  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`.
        Nc                    g | ]}|v |	S rT   rT   )rU   rN   r   s     r(   
<listcomp>z$ValueItems.merge.<locals>.<listcomp>   s    ;;;Q(]]!]]]r*   c                    g | ]}|v |	S rT   rT   rU   rN   r   s     r(   r   z$ValueItems.merge.<locals>.<listcomp>   s%    >`>`>`QVW[_V_V_qV_V_V_r*   c                    g | ]}|v|	S rT   rT   r   s     r(   r   z$ValueItems.merge.<locals>.<listcomp>   s    &L&L&LQatmmqmmmr*   )r   )r   rs   r#   r   rt   )r2   r   r   r   
merge_keysmergedrN   merged_items    ``     r(   r   zValueItems.merge   s0    $$X..  &&K;;t 	O;;x   	3$244(2  	M;;;;T;;;>`>`>`>`(>`>`>``JJd&L&L&L&L(&L&L&LLJ') 	( 	(A))DHHQKKaI)VVK&'q	r*   c                    t          | t          j                  rnYt          | t          j                  rt                              | d          } n#t          | dd          }t          d|           | S )N.r   z???z!Unexpected type of exclude value )r"   r   r   r   rJ   fromkeysgetattrr0   )rI   
class_names     r(   rl   zValueItems._coerce_items   sr    eV^,, 	Nv122 	NMM%--EE U;;JL
LLMMMr*   c                ^    ||                      |          r|S |                     |          S r!   )rs   rl   )r2   ri   s     r(   r   zValueItems._coerce_value  s0    =CKK..=L  '''r*   r   c                    | du p| du S )NT.rT   r'   s    r(   rs   zValueItems.is_true  s    Dy$AH$r*   _repr.ReprArgsc                    d | j         fgS r!   rx   )ro   s    r(   __repr_args__zValueItems.__repr_args__  s    t{#$$r*   N)ri   r   rI   rj   r   rQ   )rq   r   r   r   )rz   r{   r   r|   )rI   r   r   r   r   r   )F)r   r   r   r   r   r   r   r   )rI   rj   r   r   )ri   r   r   r   r   r   r   r   )r   r   )__name__
__module____qualname____doc__	__slots__rp   rv   ry   r~   rm   classmethodr   staticmethodrl   r   rs   r   rT   r*   r(   rf   rf      s       YY#I. . . .3 3 3 3# # # #8 8 8 8#  #  #  # J # # # # [#J    \ ( ( ( [(
 % % % \%% % % % % %r*   rf   nameri   c                    d S r!   rT   r   ri   s     r(   ClassAttributer     s    r*   c                  &    e Zd ZdZdZdd	ZddZdS )r   z(Hide class attribute from its instances.r   r   r=   ri   r   r   rQ   c                "    || _         || _        d S r!   r   )ro   r   ri   s      r(   rp   zClassAttribute.__init__   s    DIDJJJr*   instanceowner	type[Any]c                R    || j         S t          | j        d|j        d          )Nz attribute of z is class-only)ri   AttributeErrorr   r   )ro   r   r   s      r(   __get__zClassAttribute.__get__$  s3    z! DI!_!_u~!_!_!_```r*   N)r   r=   ri   r   r   rQ   )r   r   r   r   r   rQ   )r   r   r   r   r   rp   r   rT   r*   r(   r   r     sM        66#		 	 	 		a 	a 	a 	a 	a 	ar*   r   Objobjc                    | j         }|t          v r| S 	 | s(|t          v r|t          u r| n|                                 S n# t
          t          t          f$ r Y nw xY wt          |           S )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$   rH   r0   
ValueErrorRuntimeErrorr   )r   obj_types     r(   smart_deepcopyr   -  s    
 }H222
 	<x#666"e++33;z<0    C==s   )? AAlefttyping.Iterable[Any]rightc                N    t          | |t                    D ]\  }}||ur dS dS )a  Check 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   _EMPTY)r   r   	left_item
right_items       r(   all_identicalr   C  sC     "-T5F!K!K!K  	:J&&55 '4r*   r   )r+   r   r,   r-   r   r   )r2   r   r,   r   r   r   )r2   r   r   r8   )r<   r=   r   r   )rD   rE   rF   rE   r   rE   )rD   rO   rP   r   r   rQ   )rZ   r[   rY   r\   r   r]   )r   r=   ri   rX   r   rX   )r   r   r   r   )r   r   r   r   r   r   )Ir   
__future__r   _annotationsr@   r   weakrefcollectionsr   r   r   rH   r   	itertoolsr   typesr	   r
   r   r   r   r   r   r   typing_extensionsr   r    r   r   TYPE_CHECKINGr   __annotations__r   r:   r   r   floatcomplexr=   r   bytesr4   NoneTyperefNotImplementedr   Ellipsisr   r#   r%   r$   r&   rJ   r   r)   r1   r7   r;   rB   rC   rK   rW   rX   rd   Representationrf   r   r   r   objectr   r   rT   r*   r(   <module>r      s     3 2 2 2 2 2    7 7 7 7 7 7 7 7 7 7       ! ! ! ! ! ! d d d d d d d d d d d d d d d d         2 2 2 2 2 2 2 2 " " " " " " " "	 !"WWWWW#VVVVV      
 		K '3     0 				'  	 	 	 	N N N N      G G G GK K K K ')

   G G G G GCLL /2     ,C% C% C% C% C%% C% C% C%L 
 a    
a a a a a a a a genn   & 
     r*   