o
    DDi                  
   @   s<  d dl 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mZmZmZmZmZ d dlmZmZmZ d dlmZ d dlmZ er\d dlmZ d d	lmZ d d
lmZ d dlmZm Z  edZ!ddde	ee  de
de
de"f f fddZ#ded ded ded fddZ$ddded ddfddZ%G dd dZ&dS )    N)	ExitStack)MappingProxyType)Anycast
CollectionIterableMappingMutableMapping
MutableSetOptionalTypeTYPE_CHECKINGTypeVar)BatchableCSTVisitorvisit_batchedVisitorMethod)MetadataException)BatchableMetadataProvider)CSTNode)Module)CSTVisitorT)BaseMetadataProvider	ProviderT_TwrapperMetadataWrapper	providersreturnr   r   c                 C   s   |  | dd |D S )zW
    Returns map of metadata mappings from resolving ``providers`` on ``wrapper``.
    c                 S   s    i | ]}t |tt|jqS  )typer   dict	_computed.0pr   r   P/var/www/Datamplify/venv/lib/python3.10/site-packages/libcst/metadata/wrapper.py
<dictcomp>5   s     z"_gen_batchable.<locals>.<dictcomp>)r   )r   r   r   r   r%   _gen_batchable)   s   
r'   gatheredc                 C   s,   | D ]}||vr| | t|j| q|S )zM
    Recursively gathers all the given providers and their dependencies.
    )add_gather_providersMETADATA_DEPENDENCIES)r   r(   Pr   r   r%   r*   8   s   
r*   c           	         s"  t  j }tt |t  | }t|dkrt  }|D ]1}t |j|rMt|tr1|	| q|j
r?| j| n|   j|< |	| q fdd|D }t |} j| ||O }t|dkrt|dkrddd |D }td| ||8 }t|dksdS dS )zx
    Updates the _metadata map on wrapper with metadata from the given providers
    as well as their dependencies.
    r   c                    s(   g | ]}|j r| j|n| qS r   )	gen_cache_cachegetr"   r   r   r%   
<listcomp>^   s    z!_resolve_impl.<locals>.<listcomp>z, c                 S   s   g | ]}|j qS r   )__name__)r#   r,   r   r   r%   r1   g   s    z"Detected circular dependencies in N)set	_metadatakeysr*   lenr+   issubset
issubclassr   r)   r-   r.   r/   _genr'   updatejoinr   )	r   r   	completed	remaining	batchabler,   initialized_batchablemetadata_batchnamesr   r0   r%   _resolve_implE   s2   




rB   c                	   @   s  e Zd ZU dZg dZded< ededef f ed< edef ed< d	i fd
dde	dedef ddfddZ
defddZed%ddZded dedef fddZded dededef f fddZd&ddZ		d'd ee d!ee d"ee ddfd#d$ZdS )(r   a  
    A wrapper around a :class:`~libcst.Module` that stores associated metadata
    for that module.

    When a :class:`MetadataWrapper` is constructed over a module, the wrapper will
    store a deep copy of the original module. This means
    ``MetadataWrapper(module).module == module`` is ``False``.

    This copying operation ensures that a node will never appear twice (by identity) in
    the same tree. This allows us to uniquely look up metadata for a node based on a
    node's identity.
    )__moduler4   r.   r   _MetadataWrapper__moduler   r   r4   r.   Fmoduleunsafe_skip_copycacher   Nc                 C   s"   |s|  }|| _i | _|| _dS )a  
        :param module: The module to wrap. This is deeply copied by default.
        :param unsafe_skip_copy: When true, this skips the deep cloning of the module.
            This can provide a small performance benefit, but you should only use this
            if you know that there are no duplicate nodes in your tree (e.g. this
            module came from the parser).
        :param cache: Pass the needed cache to wrapper to be used when resolving metadata.
        N)
deep_clonerD   r4   r.   )selfrE   rF   rG   r   r   r%   __init__   s
   
zMetadataWrapper.__init__c                 C   s   dt t| jd dS )NzMetadataWrapper(
z    z,
))textwrapindentreprrE   rI   r   r   r%   __repr__   s   zMetadataWrapper.__repr__c                 C   s   | j S )a|  
        The module that's wrapped by this MetadataWrapper. By default, this is a deep
        copy of the passed in module.

        ::

            mw = ModuleWrapper(module)
            # Because `mw.module is not module`, you probably want to do visit and do
            # your analysis on `mw.module`, not `module`.
            mw.module.visit(DoSomeAnalysisVisitor)
        )rD   rN   r   r   r%   rE      s   zMetadataWrapper.moduleproviderzBaseMetadataProvider[_T]c                 C   s8   || j v r| j | }n| |g| }ttdtf |S )zR
        Returns a copy of the metadata mapping computed by ``provider``.
        r   )r4   resolve_manyr   r   r   )rI   rP   metadatar   r   r%   resolve   s   
zMetadataWrapper.resolver   c                    s   t  |  fdd|D S )z
        Returns a copy of the map of metadata mapping computed by each provider
        in ``providers``.

        The returned map does not contain any metadata from undeclared metadata
        dependencies that ``providers`` has.
        c                    s   i | ]}| j | qS r   )r4   )r#   krN   r   r%   r&      s    z0MetadataWrapper.resolve_many.<locals>.<dictcomp>)rB   )rI   r   r   rN   r%   rQ      s   

zMetadataWrapper.resolve_manyvisitorr   c                 C   s:   | |  | j|W  d   S 1 sw   Y  dS )z
        Convenience method to resolve metadata before performing a traversal over
        ``self.module`` with ``visitor``. See :func:`~libcst.Module.visit`.
        N)rS   rE   visit)rI   rU   r   r   r%   rV      s   
$zMetadataWrapper.visitvisitorsbefore_visitafter_leavec                 C   sT   t  }|D ]
}|||  qt| j|||W  d   S 1 s#w   Y  dS )z
        Convenience method to resolve metadata before performing a traversal over
        ``self.module`` with ``visitors``. See :func:`~libcst.visit_batched`.
        N)r   enter_contextrS   r   rE   )rI   rW   rX   rY   stackvr   r   r%   r      s
   
$zMetadataWrapper.visit_batched)r   r   )rU   r   r   r   )NN)r2   
__module____qualname____doc__	__slots____annotations__r	   r   objectboolrJ   strrO   propertyrE   r   r   rS   r   rQ   rV   r   r   r   r   r   r   r   r   r%   r   m   sT   
 





)'rK   
contextlibr   typesr   typingr   r   r   r   r   r	   r
   r   r   r   r   libcst._batched_visitorr   r   r   libcst._exceptionsr   libcst.metadata.base_providerr   libcst._nodes.baser   libcst._nodes.moduler   libcst._visitorsr   r   r   r   rb   r'   r*   rB   r   r   r   r   r%   <module>   sF   4



(