o
    Nie                     @  s6  U d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlmZ ddlmZmZmZmZ ddlmZ ddlmZmZ ddlmZ dd	l
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# ddl$m%Z% erddlm&Z&m'Z' ddlm(Z( ddl
m)Z)m*Z* ddlm+Z+m,Z,m-Z- ddl.m/Z/ G dd de,Z0G dd de,Z1G dd de,Z2e
j3e
j4B e
j)B e
j5B e
j6B e
jB e
jB e
jB Z7de8d< e&def e9B e:B Z;de8d< e#<e=Z>e?dej@ZAejBZBejCZCejDZDejEZEejFZFdd!d"ZGdd#dd&d'ZHdd)d*ZIdd,d-ZJdd.d/ZKdd1d2ZLdd4d5ZMdd7d8ZNdd;d<ZOdd>d?ZPdd@dAZQddCdDZR		dddIdJZS		dddLdMZTddOdPZUddRdSZVddVdWZWddXdYZXeeefZYdZe8d[< dd\d]ZZdd^d_Z[ddadbZ\ddddeZ]ddgdhZ^ddjdkZ_ddmdnZ`ddodpZaddrdsZbddudvZcddydzZdee d{dd~dZfdddZgG dd dZhG dd dZiG dd dZjG dd dekelef ZmdddZn		ddddZo		ddddZpdddZqdddZr			ddddZsdddZtddddZudddZveddddfdddZwedfdddZxdS )z&Helpers for inspecting Python modules.    )annotationsN)Mapping)cached_propertypartialpartialmethodsingledispatchmethod)import_module)	Parameter	Signature)StringIO)ClassMethodDescriptorTypeMethodDescriptorTypeWrapperDescriptorType)TYPE_CHECKINGAny
ForwardRef)unparse)logging)stringify_annotation)CallableSequence)_ParameterKind)
MethodType
ModuleType)FinalProtocol	TypeAlias)TypeIsc                   @  s   e Zd Zd
dddZd	S )_SupportsGet._SupportsGet__instancer   _SupportsGet__ownertype | Nonereturnc                 C     d S N )selfr   r    r%   r%   G/home/ubuntu/.local/lib/python3.10/site-packages/sphinx/util/inspect.py__get__#       z_SupportsGet.__get__N).)r   r   r    r!   r"   r   )__name__
__module____qualname__r(   r%   r%   r%   r'   r   "   s    r   c                   @  s   e Zd Zd	ddZdS )
_SupportsSet_SupportsSet__instancer   _SupportsSet__valuer"   Nonec                 C  r#   r$   r%   )r&   r.   r/   r%   r%   r'   __set__'   r)   z_SupportsSet.__set__N)r.   r   r/   r   r"   r0   )r*   r+   r,   r1   r%   r%   r%   r'   r-   %       r-   c                   @  s   e Zd ZdddZdS )	_SupportsDelete_SupportsDelete__instancer   r"   r0   c                 C  r#   r$   r%   )r&   r4   r%   r%   r'   
__delete__+   r)   z_SupportsDelete.__delete__N)r4   r   r"   r0   )r*   r+   r,   r5   r%   r%   r%   r'   r3   )   r2   r3   r   _RoutineType._SignatureTypez at 0x[0-9a-f]{8,16}(?=>)objr   r"   c                 C  s2   t | dr| S zt| W S  ty   |  Y S w )zlGet an original object from wrapped object (wrapped functions).

    Mocked objects are returned as is.
    __sphinx_mock__)hasattrinspectunwrap
ValueErrorr8   r%   r%   r'   r<   E   s   
r<   stopr@   Callable[[Any], bool] | Nonec                C  s   t |r2|| s0t| r| j} nt| rt| dr| j} nt| s&t| r*| j	} n| S || r| S 	 t| r;| j} nt| rIt| drI| j} nt| sQt| rU| j	} n| S q3)a  Get an original object from wrapped object.

    Unlike :func:`unwrap`, this unwraps partial functions, wrapped functions,
    class methods and static methods.

    When specified, *stop* is a predicate indicating whether an object should
    be unwrapped or not.
    __wrapped__)
callable	ispartialfuncr;   	isroutiner:   rB   isclassmethodisstaticmethod__func__)r8   r@   r%   r%   r'   
unwrap_allU   s(   		rJ   Sequence[str] | Nonec                 C  sD   t | dd}|du rdS t|ttB rtdd |D r|S t|)zGet the ``__all__`` attribute of an object as a sequence.

    This returns ``None`` if the given ``obj.__all__`` does not exist and
    raises :exc:`ValueError` if ``obj.__all__`` is not a list or tuple of
    strings.
    __all__Nc                 s  s    | ]}t |tV  qd S r$   
isinstancestr).0er%   r%   r'   	<genexpr>   s    zgetall.<locals>.<genexpr>)safe_getattrrN   listtupleallr=   )r8   rL   r%   r%   r'   getallu   s    rW   Mapping[str, Any]c                 C     t | dd}t|tr|S i S )z:Safely get the ``__annotations__`` attribute of an object.__annotations__NrS   rN   r   )r8   rZ   r%   r%   r'   getannotations      
r\   c                 C  rY   )z:Safely get :attr:`obj.__globals__ <function.__globals__>`.__globals__Nr[   )r8   r^   r%   r%   r'   
getglobals   r]   r_   tuple[type, ...]c                 C  s   t | dd}t|tr|S dS )z/Safely get :attr:`obj.__mro__ <class.__mro__>`.__mro__Nr%   )rS   rN   rU   )r8   ra   r%   r%   r'   getmro   r]   rb   tuple[Any, ...] | Nonec                 C  s@   t | sdS t| di }|d}t|trt|dkr|S dS )zSafely get ``obj.__orig_bases__``.

    This returns ``None`` if the object is not a class or if ``__orig_bases__``
    is not well-defined (e.g., a non-tuple object or an empty sequence).
    N__dict____orig_bases__r   )isclassrS   getrN   rU   len)r8   rd   re   r%   r%   r'   getorigbases   s   
ri   'dict[str, Any] | dict[str, None] | Nonec                 C  s`   t | stt| dd}|du rdS t|tr|S t|tr"|diS t|ttB r.t|S t	)a  Safely get :term:`obj.__slots__ <__slots__>` as a dictionary if any.

    - This returns ``None`` if ``obj.__slots__`` does not exist.
    - This raises a :exc:`TypeError` if *obj* is not a class.
    - This raises a :exc:`ValueError` if ``obj.__slots__`` is invalid.
    	__slots__N)
rf   	TypeErrorrS   rN   dictrO   rT   rU   fromkeysr=   )r8   rk   r%   r%   r'   getslots   s   


ro   xTypeIs[type[enum.Enum]]c                 C  s   t | o	t| tjS )zACheck if the object is an :class:`enumeration class <enum.Enum>`.)rf   
issubclassenumEnumrp   r%   r%   r'   isenumclass   s   rv   TypeIs[enum.Enum]c                 C  s   t | tjS )z0Check if the object is an enumeration attribute.)rN   rs   rt   ru   r%   r%   r'   isenumattribute   s   rx   c                 C  s   t | r| j} t | s| S )zGet an original object from a partial-like object.

    If *obj* is not a partial object, it is returned as is.

    .. seealso:: :func:`ispartial`
    )rD   rE   r>   r%   r%   r'   	unpartial   s   ry   TypeIs[partial | partialmethod]c                 C     t | ttB S )z4Check if the object is a partial function or method.)rN   r   r   r>   r%   r%   r'   rD         rD   clsname
str | NoneTypeIs[classmethod]c                 C  sp   t | trdS t| r| jdurt| jrdS |r6|r6t }t|D ]}|j||}||ur5t	|  S q"dS )z.Check if the object is a :class:`classmethod`.TNF)
rN   classmethodismethod__self__rf   objectrb   rd   rg   rG   r8   r}   r~   sentinelbaseclsmethr%   r%   r'   rG      s   
rG   TypeIs[staticmethod]c                 C  sX   t | trdS |r*|r*t }t|d|gD ]}|j||}||ur)t |t  S qdS )z/Check if the object is a :class:`staticmethod`.Tra   F)rN   staticmethodr   getattrrd   rg   r   r%   r%   r'   rH      s   
rH   5TypeIs[_SupportsGet | _SupportsSet | _SupportsDelete]c                   s   t  fdddD S )z<Check if the object is a :external+python:term:`descriptor`.c                 3  s     | ]}t t |d V  qd S r$   )rC   rS   )rP   itemru   r%   r'   rR     s
    
zisdescriptor.<locals>.<genexpr>)r(   r1   r5   )anyru   r%   ru   r'   isdescriptor  s   r   boolc                 C  s   t | dddu S )z1Check if the object is an :func:`abstractmethod`.__isabstractmethod__FTrS   r>   r%   r%   r'   isabstractmethod     r   methodr   c                 C  s   t | ddduS )z&Check if the method is a bound method.r   Nr   )r   r%   r%   r'   isboundmethod  r   r   c                 C  s$   z| j jdkW S  ty   Y dS w )z6Check if the object is a function or method in cython.cython_function_or_methodF)	__class__r*   AttributeErrorr>   r%   r%   r'   is_cython_function_or_method  s
   r   zFinal[tuple[type, ...]]_DESCRIPTOR_LIKEc                 C  sr   t | rdS t| r7t| }t|st|st|rdS t|r#dS t|r)dS t	|t
r0dS t|jdkS dS )z4Check if the object is an attribute-like descriptor.TFinstancemethod)r;   isdatadescriptorr   r<   
isfunction	isbuiltinr   r   rf   rN   r   typer*   )r8   	unwrappedr%   r%   r'   isattributedescriptor'  s   

r   c                 C  s*   t | ot| dot| do| jjdkS )zDCheck if the object is a :func:`~functools.singledispatch` function.dispatchregister	functools)r;   r   r:   r   r+   r>   r%   r%   r'   is_singledispatch_function@  s   

r   TypeIs[singledispatchmethod]c                 C  s
   t | tS )zBCheck if the object is a :class:`~functools.singledispatchmethod`.)rN   r   r>   r%   r%   r'   is_singledispatch_methodJ  s   
r   TypeIs[types.FunctionType]c                 C     t t| S )zCheck if the object is a user-defined function.

    Partial objects are unwrapped before checking them.

    .. seealso:: :external+python:func:`inspect.isfunction`
    )r;   r   ry   r>   r%   r%   r'   r   O     r   !TypeIs[types.BuiltinFunctionType]c                 C  r   )zCheck if the object is a built-in function or method.

    Partial objects are unwrapped before checking them.

    .. seealso:: :external+python:func:`inspect.isbuiltin`
    )r;   r   ry   r>   r%   r%   r'   r   Y  r   r   TypeIs[_RoutineType]c                 C  r   )zCheck if the object is a kind of function or method.

    Partial objects are unwrapped before checking them.

    .. seealso:: :external+python:func:`inspect.isroutine`
    )r;   rF   ry   r>   r%   r%   r'   rF   c  r   rF   *TypeIs[Callable[..., types.CoroutineType]]c                 C  s   t | td} t| S )zDCheck if the object is a :external+python:term:`coroutine` function.r?   )rJ   _is_wrapped_coroutiner;   iscoroutinefunctionr>   r%   r%   r'   r   m  s   
r   c                 C  s&   t | st| st| rdS t| dS )z2Check if the object is wrapped coroutine-function.FrB   )rH   rG   rD   r:   r>   r%   r%   r'   r   s  s   
r   "TypeIs[property | cached_property]c                 C  r{   )z2Check if the object is property (possibly cached).)rN   propertyr   r>   r%   r%   r'   
isproperty|  r|   r   TypeIs[types.GenericAlias]c                 C  s   t | tjtjB S )z'Check if the object is a generic alias.)rN   typesGenericAliastyping_BaseGenericAliasr>   r%   r%   r'   isgenericalias  s   r   rO   defargsc                 G  s   t |dkrdt | }t|z
t| |g|R  W S  tyN } z'z| j| W W  Y d}~S  ty8   Y nw |rE|d W  Y d}~S t||d}~ww )z;A getattr() that turns all exceptions into AttributeErrors.   z/safe_getattr expected at most 3 arguments, got Nr   )rh   rl   r   	Exceptionrd   r   )r8   r~   r   msgexcr%   r%   r'   rS     s    
rS   _seenr   frozenset[int]c             
     s  |t  trFt v rdS t hO zt }W n ty/   t fddd}Y nw  fdd|D }ddd	d |D  S t  trt v rSd
S t hO zt }W n tys   t fddd}Y nw ddfdd|D  S t  trt v rdS t hO zt }W n ty   t fddd}Y nw ddfdd|D  S t  tj	rڈ j
jtj	j
urt S  jj d j S t  trt v rdS tt gO ddfdd D dt dk S t  tr+t v rdS t hO ddfdd D  S zt }W n tyA } zt|d}~ww td|}|ddS )zA repr() implementation that returns text safe to use in reST context.

    Maintains a set of 'seen' object IDs to detect and avoid infinite recursion.
    z	dict(...)c                      t |  dS Nr   object_description)kseenr%   r'   <lambda>      z$object_description.<locals>.<lambda>)keyc                 3  s,    | ]}t |d t  | d fV  qdS r   Nr   )rP   r   r8   r   r%   r'   rR     s    

z%object_description.<locals>.<genexpr>z{%s}, c                 s  s"    | ]\}}| d | V  qdS ): Nr%   )rP   r   valuer%   r%   r'   rR     s     zset(...)c                   r   r   r   ru   r   r%   r'   r     r   c                 3      | ]	}t | d V  qdS r   r   rP   rp   r   r%   r'   rR         
zfrozenset(...)c                   r   r   r   ru   r   r%   r'   r     r   zfrozenset({%s})c                 3  r   r   r   r   r   r%   r'   rR     r   .z
tuple(...)z({}{})c                 3  r   r   r   r   r   r%   r'   rR         ,r   z	list(...)z[%s]c                 3  r   r   r   r   r   r%   r'   rR     r   N 
 )rN   rm   idsortedrl   joinset	frozensetrs   rt   __repr__rI   reprr   r*   r~   rU   formatrh   rT   r   r=   memory_address_resubreplace)r8   r   sorted_keysitemssorted_valuessr   r%   r   r'   r     s~   




r   	attr_namec                   sl   t | }zt fdd|D }W n
 ty   Y dS w zt|d}W n
 ty-   Y dS w tt|d|u S )a  Check whether *attr_name* is implemented on a builtin class.

        >>> is_builtin_class_method(int, '__init__')
        True


    This function is needed since CPython implements ``int.__init__`` via
    descriptors, but PyPy implementation is written in pure Python code.
    c                 3  s$    | ]} t |d i v r|V  qdS )rd   Nr   )rP   cr   r%   r'   rR     s   " z*is_builtin_class_method.<locals>.<genexpr>Fr*   N)rb   nextStopIterationrS   r   r   builtins)r8   r   mror}   r~   r%   r   r'   is_builtin_class_method  s   
r   c                   @  s.   e Zd ZdZdddZdddZdddZdS )DefaultValuezKA simple wrapper for default value of the parameters of overload functions.r   rO   r"   r0   c                 C  
   || _ d S r$   r   )r&   r   r%   r%   r'   __init__     
zDefaultValue.__init__otherr   r   c                 C  
   | j |kS r$   r   r&   r   r%   r%   r'   __eq__  r   zDefaultValue.__eq__c                 C     | j S r$   r   r&   r%   r%   r'   r        zDefaultValue.__repr__N)r   rO   r"   r0   )r   r   r"   r   r"   rO   )r*   r+   r,   __doc__r   r   r   r%   r%   r%   r'   r     s
    

r   c                   @  sB   e Zd ZdZdddZddd	ZdddZdddZdddZdS )TypeAliasForwardRefzPseudo typing class for :confval:`autodoc_type_aliases`.

    This avoids the error on evaluating the type inside :func:`typing.get_type_hints()`.
    r~   rO   r"   r0   c                 C  r   r$   r~   )r&   r~   r%   r%   r'   r     r   zTypeAliasForwardRef.__init__c                 C  r#   r$   r%   r   r%   r%   r'   __call__  s   zTypeAliasForwardRef.__call__r   r   r   c                 C  r   r$   r   r   r%   r%   r'   r     r   zTypeAliasForwardRef.__eq__intc                 C  s
   t | jS r$   )hashr~   r   r%   r%   r'   __hash__"  r   zTypeAliasForwardRef.__hash__c                 C  r   r$   r   r   r%   r%   r'   r   %  r   zTypeAliasForwardRef.__repr__N)r~   rO   r"   r0   )r"   r0   )r   r   r"   r   )r"   r  r   )	r*   r+   r,   r   r   r  r   r  r   r%   r%   r%   r'   r     s    



r   c                   @  s$   e Zd ZdZddd	ZdddZdS )TypeAliasModulez8Pseudo module class for :confval:`autodoc_type_aliases`.modnamerO   mappingMapping[str, str]r"   r0   c                 C  s   || _ || _d | _d S r$   )_TypeAliasModule__modname_TypeAliasModule__mapping_TypeAliasModule__module)r&   r  r  r%   r%   r'   r   ,  s   
zTypeAliasModule.__init__r~   r   c                   s   d td | j|g}|| jv rt| j| S |d   fdd| j D }|r.t||S zt|W S  tyM   | j	d u rEt| j| _	t
| j	| Y S w )Nr   c                       i | ]\}}|  r||qS r%   
startswithrP   r   vprefixr%   r'   
<dictcomp>9       z/TypeAliasModule.__getattr__.<locals>.<dictcomp>)r   filterr	  r
  r   r   r  r   ImportErrorr  r   )r&   r~   fullnamenestedr%   r  r'   __getattr__2  s   



zTypeAliasModule.__getattr__N)r  rO   r  r  r"   r0   )r~   rO   r"   r   )r*   r+   r,   r   r   r  r%   r%   r%   r'   r  )  s    
r  c                      s,   e Zd ZdZd fddZdddZ  ZS )TypeAliasNamespacezPseudo namespace class for :confval:`autodoc_type_aliases`.

    Useful for looking up nested objects via ``namespace.foo.bar.Class``.
    r  r  r"   r0   c                   s   t    || _d S r$   )superr   _TypeAliasNamespace__mapping)r&   r  r   r%   r'   r   P  s   

zTypeAliasNamespace.__init__r   rO   r   c                   sJ   || j v rt| j | S |d   fdd| j  D }|r#t||S t)Nr   c                   r  r%   r  r  r  r%   r'   r  Z  r  z2TypeAliasNamespace.__getitem__.<locals>.<dictcomp>)r  r   r   r  KeyError)r&   r   r  r%   r  r'   __getitem__T  s   

zTypeAliasNamespace.__getitem__)r  r  r"   r0   )r   rO   r"   r   )r*   r+   r,   r   r   r  __classcell__r%   r%   r  r'   r  J  s    r  subjectc                 C  s&   t | }|ddko|dtjkS )z<Check the function should be unwrapped on getting signature.r*   
contextlib__file__)r_   rg   r"  r#  )r!  r^   r%   r%   r'   _should_unwrapb  s   r$  Fbound_methodtype_aliasesMapping[str, str] | Noner
   c                 C  s:  |du ri }zt | rt| }ntj| dd}W n ty'   t| }Y nw t|j }|j}zGt|}t	j
| d|dd}t|D ]\}}	|	j|v rb||	j }
t|
trZ|
j}
|	j|
d||< qDd|v rxt|d trt|d j}n|d }W n	 ty   Y nw |rt| rnt|dkr|d t||dd	S )
z|Return a Signature object for the given *subject*.

    :param bound_method: Specify *subject* is a bound method or not
    NT)follow_wrapped)include_extras
annotationr"   r   F)return_annotation__validate_parameters__)r$  r;   	signaturer=   rT   
parametersvaluesr,  r  r   get_type_hints	enumerater~   rN   r   r   r   r   rh   popr
   )r!  r%  r&  r.  r/  r,  localnsr   iparamr+  r%   r%   r'   r.  l  sL   	




r.  sigglobalnsdict[str, Any] | Noner4  c                 C  s   |du ri }|du r|}t | j }t|D ]\}}|jr-t|j||}|j|d||< q| j}|r9t|||}| j||dS )z;Evaluate unresolved type annotations in a signature object.Nr*  )r/  r,  )rT   r/  r0  r2  r+  	_evaluater   r,  )r7  r8  r4  r/  r5  r6  r+  r,  r%   r%   r'   evaluate_signature  s   r;  refr   c                 C  s.   t jdkr| j||i t dS | ||t S )zEvaluate a forward reference.)         )recursive_guard)sysversion_infor:  r   )r<  r8  r4  r%   r%   r'   _evaluate_forwardref  s   
rC  r+  dict[str, Any]c              	   C  s   z7t | tr2t| d}t|||} t | trt|||} W | S t | tr5t| d}t|||} W | S W | S W | S  ttfyC   Y | S w )z$Evaluate unresolved type annotation.T)rN   rO   r   rC  	NameErrorrl   )r+  r8  r4  r<  r%   r%   r'   r:    s&   


	

r:  Tshow_annotationshow_return_annotationunqualified_typehintsc                 C  s  |rd}nd}t j}g }d}| j D ]}|jt jkr%|t jkr%|d |jt jkr9|t jt jdfv r9|d t	 }	|jt j
u rK|	d|j  n|jt ju rZ|	d|j  n|	|j |ru|j|uru|	d |	t|j| |j|ur|r|j|ur|	d n|	d	 |	t|j ||	  |j}q|t ju r|d d
|}
| j|u s|r|sd|
 dS t| j|}d|
 d| S )a`  Stringify a :class:`~inspect.Signature` object.

    :param show_annotation: If enabled, show annotations on the signature
    :param show_return_annotation: If enabled, show annotation of the return value
    :param unqualified_typehints: If enabled, show annotations as unqualified
                                  (ex. io.StringIO -> StringIO)
    smartzfully-qualifiedN/*z**r   z = =r   ()z) -> )r	   emptyr/  r0  kindPOSITIONAL_ONLYappendKEYWORD_ONLYPOSITIONAL_OR_KEYWORDr   VAR_POSITIONALwriter~   VAR_KEYWORDr+  r   defaultr   getvaluer   r,  )r7  rF  rG  rH  modeEMPTYargs	last_kindr6  argconcatenated_argsretannr%   r%   r'   stringify_signature  sV   









ra  c                 C  s4   d|  d }t |}tt j|jd }t||S )z:Create a :class:`~inspect.Signature` object from a string.zdef funcz: passr   )astparser   castFunctionDefbodysignature_from_ast)r.  codemodulefunctionr%   r%   r'   signature_from_str4  s   

rk  r   nodeast.FunctionDefrh  c              	   C  sB  t j}| j}t|j}t|j}|t|j t| }d| | }g }t|j|ddD ]\}}	|t	t j
|||	d q+t|j||d ddD ]\}}	|t	t j|||	d qH|jri|t	t j|j|dd t|j|jddD ]\}}	|t	t j|||	d qr|jr|t	t j|j|dd t| j|p|}
t||
dS )z=Create a :class:`~inspect.Signature` object from an AST node.r$   F)strict)defexprN)r,  )r	   rO  r\  rU   defaultsrh   posonlyargsziprR  _definerQ  rT  varargrU  
kwonlyargskw_defaultsrS  kwargrW  ast_unparsereturnsr
   )rl  rh  r[  r\  rp  pos_only_offsetdefaults_offsetparamsr^  ro  r,  r%   r%   r'   rg  =  s.   

 rg  rP  r   r^  ast.argro  ast.expr | Noner	   c                C  sB   t j}|d u r	|ntt||}t|j|p|}t |j| ||dS )N)rX  r+  )r	   rO  r   rx  r+  r^  )rP  r^  rh  ro  r[  rX  r+  r%   r%   r'   rs  p  s   rs  
attrgetterr   allow_inheritedc                 C  s   |r-|r-t | ||r-t|D ]}|j|}|r,t|dr,t|j}|dus(|s,|  S qt| }t| r@|| j	j
kr@t| jS |du r|r|r|rt|D ]}t||d}|durdt|}|durd nqN|du rt|D ]}t||d}|durt|}|dur nqm|du rt| }|S )zGet the docstring for the object.

    This tries to obtain the docstring for some kind of objects additionally:

    * partial functions
    * inherited docstring
    * inherited decorated methods
    rI   N)rG   rb   rd   rg   r:   getdocrI   _getdoc_internalrD   r   r   rE   rS   r;   )r8   r  r  r}   r~   r   r   docr%   r%   r'   r  ~  s>   



r  Callable[[Any, str, Any], Any]c                 C  s   || dd }t |tr|S d S )Nr   rM   )r8   r  r  r%   r%   r'   r    s   
r  )r8   r   r"   r   )r8   r   r@   rA   r"   r   )r8   r   r"   rK   )r8   r   r"   rX   )r8   r   r"   r`   )r8   r   r"   rc   )r8   r   r"   rj   )rp   r   r"   rq   )rp   r   r"   rw   )r8   r   r"   rz   )NN)r8   r   r}   r   r~   r   r"   r   )r8   r   r}   r   r~   r   r"   r   )rp   r   r"   r   )r8   r   r"   r   )r   r   r"   r   )r8   r   r"   r   )r8   r   r"   r   )r8   r   r"   r   )r8   r   r"   r   )r8   r   r"   r   )r8   r   r"   r   )r8   r   r"   r   )r8   r   r~   rO   r   r   r"   r   )r8   r   r   r   r"   rO   )r8   r   r   rO   r"   r   )r!  r7   r"   r   )FN)r!  r7   r%  r   r&  r'  r"   r
   )r7  r
   r8  r9  r4  r9  r"   r
   )r<  r   r8  r9  r4  r9  r"   r   )r+  r   r8  rD  r4  rD  r"   r   )TTF)
r7  r
   rF  r   rG  r   rH  r   r"   rO   )r.  rO   r"   r
   )r   )rl  rm  rh  rO   r"   r
   )
rP  r   r^  r}  rh  rO   ro  r~  r"   r	   )r8   r   r  r   r  r   r}   r   r~   r   r"   r   )r8   r   r  r  r"   r   )yr   
__future__r   rb  r   r"  rs   r;   rerA  r   r   collections.abcr   r   r   r   r   r   	importlibr   r	   r
   ior   r   r   r   r   r   r   sphinx.pycode.astr   rx  sphinx.utilr   sphinx.util.typingr   r   r   r   r   r   r   r   r   typing_extensionsr   r   r-   r3   FunctionType
LambdaTypeBuiltinFunctionTypeBuiltinMethodTyper6   rZ   r   r   r7   	getLoggerr*   loggercompile
IGNORECASEr   isasyncgenfunctionr   ismethoddescriptorrf   ismoduler<   rJ   rW   r\   r_   rb   ri   ro   rv   rx   ry   rD   rG   rH   r   r   r   r   r   r   r   r   r   r   rF   r   r   r   r   rS   r   r   r   r   r   r  rm   rO   r  r$  r.  r;  rC  r:  ra  rk  rg  rs  r  r  r%   r%   r%   r'   <module>   s    




 












	












	


L!
@


J	
34