
    zi^1                    p   d Z ddlmZ ddlZddlZddlZddlmZ ddlm	Z	 ddl
mZmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZmZmZmZ erddlmZ ddlmZ ddlmZ ddlm Z  ddl!m"Z" 	 	 d<d=dZ# G d de          Z$d>d!Z% e	d"          d?d$            Z&dd%d@d0Z'dAd4Z(dd%dBd7Z)dCd:Z*dCd;Z+dS )DzmPrivate logic related to fields (the `Field()` function and `FieldInfo` class), and arguments to `Annotated`.    )annotationsN)copy)	lru_cache)TYPE_CHECKINGAny)PydanticUndefined   )_typing_extra)ConfigWrapper)Representation)get_cls_type_hints_lenientget_type_hintsis_classvaris_finalvarBaseMetadata   	FieldInfo	BaseModel)StandardDataclass)DecoratorInfosFobjr   localnsdict[str, Any] | Noneinclude_extrasboolreturndict[str, Any]c                    t          | dd          }d}|r)	 t          j        |         j        }n# t          $ r Y nw xY wt          | |||          S )a  Gets type hints for an object by inferring the global namespace.

    It uses the `typing.get_type_hints`, The only thing that we do here is fetching
    global namespace from `obj.__module__` if it is not `None`.

    Args:
        obj: The object to get its type hints.
        localns: The local namespaces.
        include_extras: Whether to recursively include annotation metadata.

    Returns:
        The object type hints.
    
__module__N)globalnsr   r   )getattrsysmodules__dict__KeyErrorr   )r   r   r   module_namer#   s        e/var/www/tmov.alphamb/tmov_inventario/venv/lib/python3.11/site-packages/pydantic/_internal/_fields.pyget_type_hints_infer_globalnsr+      sr    $ #|T22K&*H 	{;/8HH 	 	 	D	 #'R`aaaas   / 
<<c                      e Zd ZdZdZdS )PydanticMetadataz0Base class for annotation markers like `Strict`. N)__name__r"   __qualname____doc__	__slots__r.       r*   r-   r-   8   s        ::IIIr3   r-   metadatar   c                 0     t                      |           S )zCreate a new `_PydanticGeneralMetadata` class with the given metadata.

    Args:
        **metadata: The metadata to add.

    Returns:
        The new `_PydanticGeneralMetadata` class.
    )_general_metadata_cls)r4   s    r*   pydantic_general_metadatar7   >   s     # ""8,,,r3   )maxsizetype[BaseMetadata]c                 :    ddl m}   G d dt          |           }|S )zCDo it this way to avoid importing `annotated_types` at import time.r   r   c                      e Zd ZdZddZdS )7_general_metadata_cls.<locals>._PydanticGeneralMetadataz,Pydantic general metadata like `max_digits`.r4   r   c                    || _         d S N)r'   )selfr4   s     r*   __init__z@_general_metadata_cls.<locals>._PydanticGeneralMetadata.__init__R   s    $DMMMr3   N)r4   r   )r/   r"   r0   r1   r@   r.   r3   r*   _PydanticGeneralMetadatar<   O   s.        ::	% 	% 	% 	% 	% 	%r3   rA   )annotated_typesr   r-   )r   rA   s     r*   r6   r6   J   sK     -,,,,,% % % % %#3\ % % % $#r3   )typevars_mapclstype[BaseModel]basestuple[type[Any], ...]config_wrapperr   types_namespacerC   dict[Any, Any] | None%tuple[dict[str, FieldInfo], set[str]]c               $   ddl m} t          | |          }| j                            di           }i }t                      }	|                                D ]\  }
dk    r|j        D ]}                    |          r|D ]X}t          |          rFddl
m} t          ||          r	|j        v s't          d dt          |           d| d	          Yt!          fd
|j        D                       }t#          j        d d| d| dt&                     t)          |
          r|	                               t-          |
t          | t.                              r|	                               +t1                    s<| j        rdk    rt          dd          t          | di                               d          }|D ]v}d t5          j        |          rt5          j         |          ndD             }t          |          r0||u rK|v rPt#          j        d d|j         dt&                     w	 t          | t.                    }|t.          u rt:          	  |j        |
|          }	 t?          |            n# t:          $ r Y nw xY w# t:          $ r{ |v r |j         |
          }nci }| j!        ddd         D ]&}|"                    t          |di                      '|v rtG          |                   }n |j         |
          }Y nw xY w| j        d         }|j$        v rtK          d          ||<   |r-|&                                D ]}|'                    ||           ||	fS )a[  Collect the fields of a nascent pydantic model.

    Also collect the names of any ClassVars present in the type hints.

    The returned value is a tuple of two items: the fields dict, and the set of ClassVar names.

    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_map: A dictionary mapping type variables to their concrete types.

    Returns:
        A tuple contains fields and class variables.

    Raises:
        NameError:
            - If there is a conflict between a field name and protected namespaces.
            - If there is a field other than `root` in `RootModel`.
            - If a field shadows an attribute in the parent model.
    r   r   __annotations__model_configr   zField "z" conflicts with member z of protected namespace "z".c              3  F   K   | ]}                     |          |V  d S r>   
startswith).0xann_names     r*   	<genexpr>z'collect_model_fields.<locals>.<genexpr>   sK       - -hNaNabcNdNd-- - - - - -r3   z)" has conflict with protected namespace "z_".

You may be able to resolve this warning by setting `model_config['protected_namespaces'] = z`.rootzUnexpected field with name z4; only 'root' is allowed as a field of a `RootModel`__pydantic_generic_metadata__originc                    h | ]	}|j         
S r.   name)rR   fields     r*   	<setcomp>z'collect_model_fields.<locals>.<setcomp>   s'          $
     r3   r.   zField name "z"" shadows an attribute in parent "z"; Nmodel_fields__pydantic_decorators__z0you can't override a field with a computed field)(fieldsr   r   r'   getsetitemsprotected_namespacesrQ   hasattrmainr   
issubclassr_   	NameErrorr$   tuplewarningswarnUserWarningr   add_is_finalvar_with_default_valr   is_valid_field_name__pydantic_root_model__dataclassesis_dataclassr0   AttributeErrorfrom_annotated_attributedelattrfrom_annotation	__bases__updater   computed_fields
ValueErrorvaluesapply_typevars_map)rD   rF   rH   rI   rC   r   
type_hintsr   ra   
class_varsann_typeprotected_namespacebr   valid_namespacesgeneric_originbasedataclass_fieldsdefault
field_infomodel_fields_lookuprS   
decoratorsr\   rT   s                           @r*   collect_model_fieldsr   X   s   < #"""""+CAAJ ,""#4b99K#%F55J(..00 b& b&(~%% #1#F 	 	""#677   Aq(++ 444444 *1i 8 8 X=W=W"+!T( !T !TGTUW_L`L` !T !T<O!T !T !T# # 
 (- - - - -#1#F- - - ( ($ MY( Y YUh Y YDTY Y Y $	   x   	NN8$$$(73J[3\3\]] 	NN8$$$"8,, 	& 	8v+=+=nhnnn   !&ErJJNNxXX 	 	D   EPE]^bEcEc)k);D)A)A)Aik      tX&& >))/// e8eetO`eee  
	c8->??G+++$$ ,* <;HgNNJX&&&&!   3  	E 	E 	E;&&6Y6x@@

 =?#ttt, O OA'..wq."/M/MNNNN222 "&&9(&C!D!DJJ
 ";!:8!D!DJ#	E< &)\2K%L
z111OPPP%x D]]__ 	D 	DE$$\?CCCC:s%   &J+
J
J('J(+BL0/L0type_	type[Any]valc                    ddl m} t          |           sdS |t          u rdS t	          ||          r|j        t          u r	|j        dS dS )Nr   r   FT)ra   r   r   r   
isinstancer   default_factory)r   r   r   s      r*   ro   ro      sk    """"""u u	!	!	!u	C	#	# 8I)I)IcNaNiutr3   type[StandardDataclass]dict[str, FieldInfo]c                  ddl m} i }| j        }t          t	          |                     }|                                D ]\  }}t          j        |j        ||          }	t          |	          r0|j
        s+|j        t          j        k    r|j        t          j        k    rbt          |j        |          r$|j        j        r |j        |	|j                  }
n |j        |	|          }
|
||<   |
j        t$          ur5t          t'          | ||
          |          rt)          | ||
j                   |r-|                                D ]}|                    ||           |S )a  Collect the fields of a dataclass.

    Args:
        cls: dataclass.
        types_namespace: Optional extra namespace to look for types in.
        typevars_map: A dictionary mapping type variables to their concrete types.

    Returns:
        The dataclass fields.
    r   r   )ra   r   __dataclass_fields__dictvarsrd   r
   eval_type_lenienttyper   initr   rr   MISSINGr   r   init_varru   r   r$   setattrr|   r}   )rD   rI   rC   r   ra   r   cls_localnsrT   dataclass_fieldr   r   r\   s               r*   collect_dataclass_fieldsr      s    #"""""#%F585MtCyy//K%5%;%;%=%= 7 7!/ 2?3GZeffx   	  $	';+>>>/;3FFF o-y99 	W&/ ;;HoF]^^JJ;;HoVVJ%x%666:gcS[]gFhFhjs;t;t6C:#5666 D]]__ 	D 	DE$$\?CCCCMr3   r[   strc                .    |                      d           S )N_rP   rZ   s    r*   rp   rp   -  s    s####r3   c                X    |                      d          o|                      d           S )Nr   __rP   rZ   s    r*   is_valid_privateattr_namer   1  s(    ??3=(=(=$==r3   )NF)r   r   r   r   r   r   r   r    )r4   r   r   r   )r   r9   )rD   rE   rF   rG   rH   r   rI   r   rC   rJ   r   rK   )r   r   r   r   r   r   )rD   r   rI   r   rC   rJ   r   r   )r[   r   r   r   ),r1   
__future__r   _annotationsrr   r%   rk   r   	functoolsr   typingr   r   pydantic_corer    r
   _configr   _reprr   r   r   r   r   rB   r   ra   r   rg   r   _dataclassesr   _decoratorsr   r+   r-   r7   r6   r   ro   r   rp   r   r.   r3   r*   <module>r      sm   s s 2 2 2 2 2 2     



              % % % % % % % % + + + + + +       " " " " " " ! ! ! ! ! ! _ _ _ _ _ _ _ _ _ _ _ _ ,,,,,,,""""""      //////++++++
 &* b b b b b:    ~   	- 	- 	- 	- 4
$ 
$ 
$ 
$& +/P P P P P Pf
 
 
 
 tx2 2 2 2 2 2j$ $ $ $> > > > > >r3   