
    Fe.                       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 ddl	m
Z
mZmZmZ ddlmZ ddl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m Z  ddl!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+m,Z,m-Z-m.Z. ddl/m0Z0m1Z1m2Z2m3Z3 e
r ddl4m5Z5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>Z>  e%j~                  e@      ZA eBeBj                        ZD ej                  dej                        ZG ej                  d      ZHdYdZI G d d      ZJ G d d      ZK eJ       ZL eK       ZM eN       ZO eN       ZP eN       ZQdZdZRd[dZSd\dZTd]d ZUd]d!ZV eN       ZWd^d"ZXd_d#ZYd`d$ZZdadbd%Z[	 	 	 dc	 	 	 	 	 	 	 	 	 ddd&Z\ G d' d(e]      Z^ G d) d*      Z_ G d+ d,      Z` G d- d.e`      Za G d/ d0e`      Zb G d1 d2e`      Zc G d3 d4      Zd G d5 d6ed      Ze G d7 d8edeb      Zf G d9 d:ef      Zgd;gZhd<gZi G d= d>edeb      Zj G d? d@ej      Zk G dA dB      Zl G dC dDel      Zm G dE dFel      Zn G dG dHemeneb      Zo G dI dJedec      Zp G dK dLel      Zq G dM dNel      Zr G dO dPel      Zs G dQ dRel      Zt G dS dTemereseteqeeec	      Zu G dU dVeeec      ZvdedWZwdfdXZxy)ga  Extension to create automatic documentation from code docstrings.

Automatically insert docstrings for functions, classes or whole modules into
the doctree, thus avoiding duplication between docstrings and documentation
for those who like elaborate docstrings.
    )annotationsN)	Parameter	Signature)TYPE_CHECKINGAnyCallableTypeVar)
StringList)ENUMConfig)RemovedInSphinx80Warning)get_class_membersimport_moduleimport_object)ismockmock
undecorate)___)ModuleAnalyzerPycodeError)inspectlogging)prepare_docstringseparate_metadata)evaluate_signaturegetdocobject_descriptionsafe_getattrstringify_signature)
OptionSpecget_type_hintsrestifystringify_annotation)IteratorSequence)
ModuleType)Sphinx)BuildEnvironment)DocumenterBridgea  ^ ([\w.]+::)?            # explicit module name
          ([\w.]+\.)?            # module and/or class name(s)
          (\w+)  \s*             # thing name
          (?: \[\s*(.*)\s*])?    # optional: type parameters list
          (?: \((.*)\)           # optional: arguments
           (?:\s* -> \s* (.*))?  #           return annotation
          )? $                   # and nothing more
          z	^__\S+__$c                    | S N )xs    =/usr/lib/python3/dist-packages/sphinx/ext/autodoc/__init__.pyidentityr0   A   s    H    c                       e Zd ZdZddZddZy)_Allz;A special value for :*-members: that matches to any member.c                     yNTr-   selfitems     r/   __contains__z_All.__contains__H   s    r1   c                     y r,   r-   r6   s     r/   appendz_All.appendK       r1   Nr8   r   returnbool)r8   r   r>   None)__name__
__module____qualname____doc__r9   r;   r-   r1   r/   r3   r3   E   s    Er1   r3   c                      e Zd ZdZddZy)_EmptyzGA special value for :exclude-members: that never matches to any member.c                     yNFr-   r6   s     r/   r9   z_Empty.__contains__R   s    r1   Nr=   )rA   rB   rC   rD   r9   r-   r1   r/   rF   rF   O   s
    Qr1   rF   c                    | dv rt         S | du ry| j                  d      D cg c]#  }|j                         s|j                         % c}S c c}w )z8Used to convert the :members: option to auto directives.r5   FN,)ALLsplitstripargr.   s     r/   members_optionrP   ]   sC    
l
	#&99S>?aQWWY	???s
   AAc                    | dv rt         S | j                  d      D ch c]#  }|j                         s|j                         % c}S c c}w )z-Used to convert the :exclude-members: option.r5   rJ   )EMPTYrL   rM   rN   s     r/   exclude_members_optionrS   g   s9    
l"yy~;!AGGI;;;s
   A	A	c                    | dv rdhS | r-| j                  d      D ch c]  }|j                          c}S t               S c c}w )zBUsed to convert the :inherited-members: option to auto directives.r5   objectrJ   )rL   rM   setrN   s     r/   inherited_members_optionrW   n   s@    
lz	#&99S>2a	22u 3s   Ac                F    | dv ry| dv r| S t        t        d      | z        )z=Used to convert the :member-order: option to auto directives.r5   N)alphabeticalbysource	groupwisez)invalid value for member-order option: %s
ValueErrorr   rO   s    r/   member_order_optionr_   x   s1    
l	9	9
GH3NOOr1   c                <    | dv r| S t        t        d      | z        )zDUsed to convert the :class-doc-from: option to autoclass directives.)bothclassinitz+invalid value for class-doc-from option: %sr\   r^   s    r/   class_doc_from_optionrd      s&    
''
IJSPQQr1   c                    | dv rt         S | S )Nr5   )SUPPRESSr^   s    r/   annotation_optionrg      s    
l
r1   c                     y)znUsed to convert flag options to auto directives.  (Instead of
    directives.flag(), which returns None).
    Tr-   r^   s    r/   bool_optionri      s     r1   c                    | j                  d      t        u ry| j                  dg       }dD ]5  }|| v s| |   t        dfvs| |   D ]  }||vs|j                  |        7 y)zWMerge :private-members: and :special-members: options to the
    :members: option.
    membersN>   private-membersspecial-members)getrK   
setdefaultr;   )optionsrk   keymembers       r/   merge_members_optionrs      sv     {{9$  B/G5 +'>gcl3+=!#, +(NN6*++r1   c                      	 	 d fd}|S )a  Return a listener that removes the first *pre* and last *post*
    lines of every docstring.  If *what* is a sequence of strings,
    only docstrings of a type in *what* will be processed.

    Use like this (e.g. in the ``setup()`` function of :file:`conf.py`)::

       from sphinx.ext.autodoc import cut_lines
       app.connect('autodoc-process-docstring', cut_lines(4, what=['module']))

    This can (and should) be used in place of :confval:`automodule_skip_lines`.
    c                    r|vry |d = r|r|d   s|j                  d       | d = |r|d   r|j                  d       y y y )N )popr;   )	appwhat_nameobjrp   linespostprewhats	         r/   processzcut_lines.<locals>.process   sY    E%$3$KU2Y		"tefU2YLL 5r1   ry   r(   rz   strr{   r   r|   r   rp   r   r}   	list[str]r>   r@   r-   )r   r~   r   r   s   ``` r/   	cut_linesr      s     Nr1   c                N    t        j                  |       	 	 dfd}|S )an  Return a listener that either keeps, or if *exclude* is True excludes,
    lines between lines that match the *marker* regular expression.  If no line
    matches, the resulting docstring would be empty, so no change will be made
    unless *keepempty* is true.

    If *what* is a sequence of strings, only docstrings of a type in *what* will
    be processed.
    c                ,   r|vry d} }|d d  }t        |      D ]Q  \  }	}
|r|j                  |	|z
         |dz  }j                  |
      s3| }|s9|j                  |	|z
         |dz  }S |ss||d d  |r|d   r|j                  d       y y y )Nr      rv   rw   )	enumeraterx   matchr;   )ry   rz   r{   r|   rp   r}   deleteddelete
orig_linesilineexclude	keepempty	marker_rer   s              r/   r   zbetween.<locals>.process   s    E%1X
 , 	!GAt		!g+&1t$#IIa'k*qLG	! Y!E!HU2YLL 5r1   r   )recompile)markerr   r   r   r   r   s    ``` @r/   betweenr      s,     

6"I * Nr1   c                  ,     e Zd ZdZd fdZddZ xZS )Optionsz>A dict/attribute hybrid that returns None on nonexisting keys.c                2    t        t        | 	               S r,   )r   supercopyr7   	__class__s    r/   r   zOptions.copy   s    uw|~&&r1   c                L    	 | |j                  dd         S # t        $ r Y y w xY w)Nr   -)replaceKeyError)r7   r{   s     r/   __getattr__zOptions.__getattr__   s/    	S#.// 		s    	##)r>   r   )r{   r   r>   r   )rA   rB   rC   rD   r   r   __classcell__r   s   @r/   r   r      s    H'r1   r   c                  2    e Zd ZdZdddd	 	 	 	 	 ddZd Zy)ObjectMembera}  A member of object.

    This is used for the result of `Documenter.get_module_members()` to
    represent each member of the object.

    .. Note::

       An instance of this class behaves as a tuple of (name, object)
       for compatibility to old Sphinx.  The behavior will be dropped
       in the future.  Therefore extensions should not use the tuple
       interface.
    NF)	docstringclass_skippedc               J    || _         || _        || _        || _        || _        y r,   )rA   rU   r   r   r   )r7   r{   r|   r   r   r   s         r/   __init__zObjectMember.__init__  s%    "r1   c                p    t        j                  dt        d       | j                  | j                  f|   S )NzZThe tuple interface of ObjectMember is deprecated. Use (obj.__name__, obj.object) instead.   
stacklevel)warningswarnr   rA   rU   )r7   indexs     r/   __getitem__zObjectMember.__getitem__  s3     @.1	> t{{+E22r1   )r{   r   r|   r   r   
str | Noner   r   r   r?   r>   r@   )rA   rB   rC   rD   r   r   r-   r1   r/   r   r      s5     HL#U.2?C3r1   r   c                  D   e Zd ZU dZdZdZdZdZdZe	e	dZ
ded<   d"d	Ze	 	 d#d
       Zd$d%dZed&d       Zd'dZ	 	 d(dZd)dZd*d+dZd,dZd)dZd-dZd,dZd-dZd-dZd.dZd/dZd0dZd,dZd1dZ d2dZ!	 	 d3dZ"d*d4dZ#	 	 	 	 d5dZ$	 	 	 	 d6	 	 	 	 	 	 	 	 	 d7d!Z%y )8
Documenterae  
    A Documenter knows how to autodocument a single object type.  When
    registered with the AutoDirective, it will be used to document objects
    of that type when needed by autodoc.

    Its *objtype* attribute selects what auto directive it is assigned to
    (the directive name is 'auto' + objtype), and what directive it generates
    by default, though that can be overridden by an attribute called
    *directivetype*.

    A Documenter has an *option_spec* that works like a docutils directive's;
    in fact, it will be used to parse an auto directive's options that matches
    the Documenter.
    rU      r   T)no-indexnoindexr!   option_specc                F    t        | j                  j                  ||g| S )z5getattr() override for types such as Zope interfaces.)autodoc_attrgetterenvry   )r7   r|   r{   defargss       r/   get_attrzDocumenter.get_attr=  s    !$((,,TDGDDr1   c                    d}t        |      )z?Called to see if a member can be documented by this Documenter.!must be implemented in subclassesNotImplementedError)clsrr   
membernameisattrparentmsgs         r/   can_document_memberzDocumenter.can_document_memberA  s     2!#&&r1   c                4   || _         |j                  j                  | _        |j                  | _        |j                  | _        || _        || _        d| _        d | _        g | _	        d| _
        d | _        d| _        d | _        d| _        d | _        d | _        y Nrw   )	directiver   configgenoptrp   r{   indentmodnamemoduleobjpathfullnameargsretannrU   object_namer   analyzer)r7   r   r{   r   s       r/   r   zDocumenter.__init__H  s    "'mm22%.]] ''	 )-"$ !%	/3r1   c                V    | j                   j                  j                  j                  S )z%Returns registered Documenter classes)r   ry   registrydocumentersr7   s    r/   r   zDocumenter.documentersa  s     xx||$$000r1   c                    |j                         r6 | j                  j                  j                  | j                  |z   |g|  y | j                  j                  j                  d|g|  y)z0Append one line of generated reST to the output.rw   N)rM   r   resultr;   r   )r7   r   sourcelinenos       r/   add_linezDocumenter.add_linef  sV    ::<(DNN!!((t);VMfM(DNN!!((V=f=r1   c                    d}t        |      )a@  Resolve the module and name of the object to document given by the
        arguments and the current module/class.

        Must return a pair of the module name and a chain of attributes; for
        example, it would return ``('zipfile', ['ZipFile', 'open'])`` for the
        ``zipfile.ZipFile.open`` method.
        r   r   )r7   r   parentspathbaser   s         r/   resolve_namezDocumenter.resolve_namem  s     2!#&&r1   c                   t         j                  | j                        }|:t        j	                  t        d      | j                  | j                  fz  d       y|j                         \  }}}}}}|*|dd }|r |j                  d      j                  d      ng }	nd}g }	t        | j                  j                        5  | j                  ||	||      \  }| _        ddd       |sy|| _        || _        || _        | j                  xs d| j                  r&ddj%                  | j                        z   z   | _        y	dz   | _        y	# 1 sw Y   lxY w)
zDetermine what module to import and what attribute to document.

        Returns True and sets *self.modname*, *self.objpath*, *self.fullname*,
        *self.args* and *self.retann* if parsing and resolving was successful.
        Nz!invalid signature for auto%s (%r)autodoctypeF.rw   T)py_ext_sig_rer   r{   loggerwarningr   objtypegroupsrstriprL   r   r   autodoc_mock_importsr   r   r   r   r   joinr   )
r7   matchedexplicit_modnamer   r   tp_listr   r   r   r   s
             r/   
parse_namezDocumenter.parse_namey  sS     %%dii0?NN2ABdllTXT]T]E^^ )  +>Enn>N;$gtV '&s+G59dkk#&,,S1rGGG$++223 	T$($5$5gwd$S!GT\	T 	,,,":>,,# 66P MOP	T 	Ts   E

Ec                \   t        | j                  j                        5  	 t        | j                  | j
                  | j                  | j                  | j                  j                        }|\  | _	        | _
        | _        | _        t        | j                        rt        | j                        | _        	 ddd       y# t        $ rT}|r t         j#                  |j$                  d   dd       | j&                  j)                          Y d}~ddd       yd}~ww xY w# 1 sw Y   yxY w)	zImport the object given by *self.modname* and *self.objpath* and set
        it as *self.object*.

        Returns True if successful, False if an error occurred.
        
attrgetterwarningiserrorNTr   r   r   r   subtypeF)r   r   r   r   r   r   r   r   autodoc_warningiserrorr   r   r   rU   r   r   ImportErrorr   r   r   r   note_reread)r7   
raiseerrorretexcs       r/   r   zDocumenter.import_object  s     $++223 	#DLL$,,/3}}37;;3U3UW KNGT[$*:DK$++&",T[["9DK	 	  sxx{OT$$&	 		 	s0   D"BC	DADD"DD""D+c                X    | j                  | j                  dd      xs | j                  S )zGet the real module name of an object to document.

        It can differ from the name of the module through which the object was
        imported.
        rB   N)r   rU   r   r   s    r/   get_real_modnamezDocumenter.get_real_modname  s$     }}T[[,=MMr1   c                    | j                   j                  ryt        j                  | j                        }| j                  |dd      }|r|| j                  k7  ryy)z`Check if *self.object* is really defined in the module given by
        *self.modname*.
        TrB   NF)rp   imported_membersr   	unpartialrU   r   r   )r7   subjectr   s      r/   check_modulezDocumenter.check_module  sN     <<((##DKK0--t<w$,,.r1   c                     y)z}Format the argument signature of *self.object*.

        Should return None if the object does not have a signature.
        rw   r-   r7   kwargss     r/   format_argszDocumenter.format_args  s    
 r1   c                T    dj                  | j                        xs | j                  S )zFormat the name of *self.object*.

        This normally should be something that can be parsed by the generated
        directive, but doesn't need to be (Sphinx will display it unparsed
        then).
        r   )r   r   r   r   s    r/   format_namezDocumenter.format_name  s      xx%55r1   c                    |r	  | j                   di |S | j                         S # t        $ r Y | j                         S w xY wNr-   )r  	TypeErrorr  s     r/   _call_format_argszDocumenter._call_format_args  sV    't''1&11 !!   !!s   & 	A Ac           	     R   | j                   d| j                   z  }| j                  }nQ	 d} | j                  di |}|r:t        j                  d|      }|r"|j                  d      }|j                  d      }| j                  j                  j                  d	| j                  | j                  | j                  | j                   |      }|r|\  }}|||rd
|z  z   S dz   S y# t        $ r8}t        j                  t        d      | j                  |d       d}Y d}~d}~ww xY w)zFormat the signature (arguments and return annotation) of the object.

        Let the user process it via the ``autodoc-process-signature`` event.
        Nz(%s)z^(\(.*\))\s+->\s+(.*)$r   r   z+error while formatting arguments for %s: %sr   r   autodoc-process-signaturez -> %srw   r-   )r   r   r  r   r   group	Exceptionr   r   r   r   r   eventsemit_firstresultr   rU   rp   )r7   r  r   r   r   r  r   s          r/   format_signaturezDocumenter.format_signature  s!   
 99 DII%D[[F-t--77 hh'@$GG&}}Q/!(q!1 112M26,,26++t||TSY[ !LD&&Hv-AAbAA  r"OP#}}c	  Cs   AC% %	D&..D!!D&c                   t        | dd      }t        | d| j                        }| j                         }| j                         }d| d| d}t	        |j                  d            D ]1  \  }}| j                  | | | |       |dk(  s$d	t        |      z  }3 | j                  j                  s| j                  j                  r| j                  d
|       | j                  r | j                  d| j                  z  |       yy)z>Add the directive header and options to the generated content.domainpydirectivetypez.. :z:: 
r    z   :no-index:z   :module: %sN)getattrr   r  get_sourcenamer   rL   r   lenrp   no_indexr   r   r   )	r7   sigr  r   r{   
sourcenameprefixr   sig_lines	            r/   add_directive_headerzDocumenter.add_directive_header	  s    x.D/4<<@	!((*
 vha	{#.$SYYt_5 	+KAxMMVHTF8*5$&Avs6{*		+ <<  DLL$8$8MM/:6<< MM*T\\9:F r1   c                "   t        | j                  | j                  | j                  j                  | j
                  | j                        }|rA| j                  j                  j                  j                  j                  }t        ||      gS g S )zDecode and return lines of the docstring(s) for the object.

        When it returns None, autodoc-process-docstring will not be called for this
        object.
        )r   rU   r   r   autodoc_inherit_docstringsr   r   r   statedocumentsettings	tab_widthr   )r7   r   r1  s      r/   get_doczDocumenter.get_doc  sn     4;;t{{7]7];;(8(8:	,,55>>HHI%i;<<	r1   c           	   #  8  K   |D ]  }| j                   j                  rm| j                   j                  j                  d| j                  | j                  | j
                  | j                  |       |r|d   dk7  r|j                  d       |E d{     y7 w)z7Let the user process the docstrings before adding them.autodoc-process-docstringrv   rw   N)r   ry   emitr   r   rU   rp   r;   )r7   
docstringsdocstringliness      r/   process_doczDocumenter.process_doc,  s     ( 	&Nxx||!!"="&,,t{{"&,,@ "nR&8B&>"))"-%%%	& &s   BBBBc                V   t        j                  | j                  dd       rQt        j                  | j                  dd       r0| j                  j                   d| j                  j                   }n| j
                  }| j                  r| j                  j                   d| S d|z  S )NrB   rC   r   z:docstring of zdocstring of %s)r   r   rU   rB   rC   r   r   srcname)r7   r   s     r/   r$  zDocumenter.get_sourcename;  s      lDA$$T[[.$G ++0014;;3K3K2LMH}}H==mm++,N8*EE$x//r1   c                   d}| j                         }| j                  r| j                  j                         }| j                  rwdj	                  | j                  dd       | j                  d   f}||v rFd}t        ||         g}t        | j                  |            D ]  \  }}| j                  |||        |r[| j                         }	|	nH|	s|	j                  g        t        | j                  |	            D ]  \  }}| j                  |||        |rBt        |j                  |j                        D ]  \  }}
| j                  ||
d   |
d            yy)z>Add content from docstrings, attribute documentation and user.Tr   Nrv   Fr   r   )r$  r   find_attr_docsr   r   listr   r8  r   r2  r;   zipdataitems)r7   more_contentr   r(  	attr_docsrq   attribute_docstringsr   r   r6  srcs              r/   add_contentzDocumenter.add_contentI  sZ   	 ((*
==446I||xxSb 12DLL4DE)# %I -13,@+A(#,T-=-=>R-S#T ;4dJ:; J!! %%b)()9)9*)EF 7GAtMM$
A67  !2!2L4F4FG 4	cdCFCF34 r1   c                    d}t        |      )a+  Return `(members_check_module, members)` where `members` is a
        list of `(membername, member)` pairs of the members of *self.object*.

        If *want_all* is True, return all members.  Else, only return those
        members given by *self.options.members* (which may also be None).
        r   r   )r7   want_allr   s      r/   get_object_memberszDocumenter.get_object_membersp  s     2!#&&r1   c           
          d fd}g }dj                   j                        } j                  r j                  j                         }ni }|D ]2  }	 |j                  }|j
                  }	|	t        u xs ||f|v }
	 t        |	 j                   j                  j                    j
                  |      }t        |t"              sd} j                  |	dd      }|r j                  |dd      }||k(  rd}t        |t              r|j$                  r|j$                  }t'        |      \  }}t)        |      }d	|v rd
}nd|v rd}n|j+                  d      }d}t-        |	      r||f|vrn j.                  j0                  r| j.                  j0                  v rd}nV|rvt2        j5                  |      ra j.                  j6                  rH| j.                  j6                  v r0|dk(  rd}n |||      rd}n|xs  j.                  j8                  }nd}n||f|v r9|r4|r2 j.                  j:                  d}n| j.                  j:                  v }nd
}n|r[|rY|s j.                  j8                  r> j.                  j:                  d}nj |||      rd}n^| j.                  j:                  v }nEd}nB j.                  j<                  t>        u r |||      rd}n|xs  j.                  j8                  }t        |t              r|j@                  rd} jB                  jD                  rD jB                  jD                  jG                  d jH                  ||	|  j.                        }|| }|s|jU                  ||	|
f       5 |S # t        $ r6 t        |t              r |\  }}	t        j                  dt        d       Y Yw xY w# tJ        $ r:}tL        jO                  tQ        d       jR                  ||	|d       d}Y d}~d}~ww xY w)a  Filter the given member list.

        Members are skipped if

        - they are private (except if given explicitly or the private-members
          option is set)
        - they are special methods (except if given explicitly or the
          special-members option is set)
        - they are undocumented (except if the undoc-members option is set)

        The user can override the skipping decision by connecting to the
        ``autodoc-skip-member`` event.
        c                   j                   j                  xs
 t               }t        j                  j
                        rj
                  j                  D ]i  }|j                  |v r|j
                  k7  r y| |j                  v r y| j                  |di       v r yt        |t              sZ|j                  |u si y y)NTF__annotations__)rp   inherited_membersrV   r   isclassrU   __mro__rA   __dict__r   
isinstancer   r   )r{   r|   rL  r   r7   s       r/   is_filtered_inherited_memberz?Documenter.filter_members.<locals>.is_filtered_inherited_member  s     $ > > G#%t{{+;;.. 	%C||'88SDKK=O#s||+$t}}S2CRHH$!#|4s9J$	% r1   r   zReturning tuples of (name, object) as the second return value from get_object_members() is deprecated. Return ObjectMember(name, object) instances instead.r   r   Nr   rD   privateTpublicFr   autodoc-skip-memberz`autodoc: failed to determine %s.%s (%r) to be documented, the following exception was raised:
%sr   r   )r{   r   r|   r   r>   r?   )+r   r   r   r<  rA   rU   AttributeErrorrP  r   r   r   r   INSTANCEATTRr   r   r   r-  r   r   r   r?   
startswithr   rp   exclude_membersspecial_member_rer   special_membersundoc_membersprivate_membersrk   rK   r   r   ry   r  r   r  r   r   r   r{   r;   )r7   rk   rG  rQ  r  	namespacerB  r|   r   rr   r   docr   cls_docmetadatahas_doc	isprivatekeep	skip_userr  s   `                   r/   filter_memberszDocumenter.filter_membersz  s   	"  HHT\\*	==446II  v	9C \\
 |+S	:/F)/SF_VT]]DKK4Z4Z![[*6!#s+C mmFK>"mmCDAG#~"c<0S]]--C 1# 6Xs)( $I) %I * 5 5c :I&>y*&=Y&Nll22 DLL$@$@@ D"3"9"9*"E44&$,,*F*FF%2#(D9*cJ#(D#*#Hdll.H.HD$,	9I<<77?#(D#-1M1M#MD  $)$,,"<"<<<77?#(D9*cJ#(D#-1M1M#MD$,,38SI$  'D$,,*D*Dc<0S[[ D 88<< $ = =-t||Z $,,!0I !,#,} 

J78mv	9p 
i " c<0 &)"
FK -	 V  r #L  M#yy*fc	  S 	s+   N>K-O
;OO
	P0PPc           
     2   | j                   | j                  j                  d<   | j                  r&| j                  d   | j                  j                  d<   |xs4 | j                  j
                  xs | j                  j                  t        u }| j                  |      \  }}g }| j                  ||      D ]  \  }}}| j                  j                         D 	cg c]  }	|	j                  ||||       r|	 }
}	|
sE|
j                  d        | j                    ddj                  g | j                  |      z   } |
d   | j                  || j                         }|j#                  ||f        | j                  j$                  xs | j&                  j(                  }| j+                  ||      }|D ](  \  }}|j-                  d	| j.                  |xr | 
       * d| j                  j                  d<   d| j                  j                  d<   yc c}	w )zGenerate reST for member documentation.

        If *all_members* is True, document all members, else those given by
        *self.options.members*.
        autodoc:moduler   autodoc:classc                    | j                   S r,   )priority)r   s    r/   <lambda>z-Documenter.document_members.<locals>.<lambda>9  s
     r1   rq   ::r   rv   T)all_membersreal_modnamer
  N)r   r   	temp_datar   rp   rL  rk   rK   rH  re  r   valuesr   sortr   r   r   r;   member_orderr   autodoc_member_ordersort_membersgeneratero  )r7   rn  rG  members_check_modulerk   memberdocumentersmnamerr   r   r   classes
full_mname
documenterrs  s                 r/   document_memberszDocumenter.document_members  s    04||+,<<26,,q/DHH/ 0LL220LL((C/ 	 )-(?(?(I%g <>'+':':7H'M 	;#UFF&*&6&6&=&=&? Ps11&%N  PG PLL5L6 !LL>,sxx8N$,,8N8N/OOJ$T^^ZMJ$$j&%9:	; ||00TDKK4T4T --.?N"3 	BJ t/@/@1@&j   B	B 04+,.2?+/Ps   Hc                    |dk(  r|j                  d        |S |dk(  r<| j                  r.| j                  j                  dfd}|j                  |       |S |j                  d        |S )zSort the given member list.r[   c                >    | d   j                   | d   j                  fS Nr   )rs  r{   es    r/   rk  z)Documenter.sort_members.<locals>.<lambda>Q  s    AaD,=,=qtyy+I r1   rl  rZ   c                |    | d   j                   j                  d      d   }j                  |t                    S Nr   rm  r   )r{   rL   rn   r%  )entryr   tagorders     r/   keyfuncz(Documenter.sort_members.<locals>.keyfuncY  s5    $Qx}}2248;H#<<#h-@@r1   c                     | d   j                   S r  r{   r  s    r/   rk  z)Documenter.sort_members.<locals>.<lambda>^      1Q499 r1   r  ztuple[Documenter, bool]r>   int)rr  r   r  )r7   r   orderr  r  s       @r/   ru  zDocumenter.sort_membersL  s     K!IJ  j  }}==11A   W -  !45r1   Nc                   | j                         s.t        j                  t        d      | j                  z  d       y| j                         sy| j                         }|xs || _        	 t        j                  | j                        | _
        | j                  j                          | j                  j                  j                  | j                  j                         | j                  |k7  rE	 t        j                  |      }| j                  j                  j                  |j                         t)        | j+                         xs g g       }	t-        | j.                        r-|	s+t        j                  t        d      | j                  d       |r| j1                         sy| j3                         }
| j5                  d|
       	 | j7                         }| j=                  |       | j5                  d|
       | xj>                  | j@                  z  c_        | jC                  |       | jE                  |       y# t         $ rf}t        j#                  d|       d| _
        t%        | j&                  dd      x}r%| j                  j                  j                  |       Y d}~d}~ww xY w# t         $ r Y w xY w# t8        $ r6}t        j                  t        d	      | j:                  |d       Y d}~yd}~ww xY w)
a  Generate reST for the object given by *self.name*, and possibly for
        its members.

        If *more_content* is given, include that content. If *real_modname* is
        given, use that module name to find attribute docs. If *check_module* is
        True, only generate if the object is defined in the module name it is
        imported from. If *all_members* is True, document all members.
        zdon't know which module to import for autodocumenting %r (try placing a "module" or "currentmodule" directive in the document, or giving an explicit module name)r   r   Nz$[autodoc] module analyzer failed: %s__file__rw   zA mocked object is detected: %rz+error while formatting signature for %s: %s)#r   r   r   r   r{   r   r  ro  r   
for_moduler   r<  r   record_dependenciesaddr:  r   debugr#  r   sumr2  r   rU   r
  r$  r   r  r  r   r+  r   content_indentrE  r}  )r7   rA  ro  r
  rn  guess_modnamer  module___file__r   r6  r(  r'  s               r/   rv  zDocumenter.generateb  s     NN I J 		 !*	  +
  !!# --/!-!>	J*55d6G6GHDM MM((* NN..224==3H3HI-)44]C2266x7G7GH !$DLLN$8b" =
$++zNN2?@999  6 $$&((*

 	b*%	'')C 	!!#&b*% 	t*** 	& 	k*m  	HLL?E DM")$++z2"FFF2266G	H  .  	NN2KL==#I  ?	sD   ,>I 3AJ4 K 	J1AJ,,J14	K K	L,K>>L)r|   r   r{   r   r   r   r>   r   
rr   r   r   r   r   r?   r   r   r>   r?   )rw   )r   r*   r{   r   r   r   r>   r@   )r>   zdict[str, type[Documenter]])r   r   r   r   r   r  r>   r@   
r   r   r   r   r   r   r   r   r>   ztuple[str | None, list[str]]r>   r?   Fr  r?   r>   r?   r>   r   r  r   r>   r   r'  r   r>   r@   r>   list[list[str]] | None)r6  zlist[list[str]]r>   zIterator[str]rA  StringList | Noner>   r@   rG  r?   r>   ztuple[bool, list[ObjectMember]])rk   zlist[ObjectMember]rG  r?   r>   zlist[tuple[str, Any, bool]]rn  r?   r>   r@   r   list[tuple[Documenter, bool]]r  r   r>   r  NNFF
rA  r  ro  r   r
  r?   rn  r?   r>   r@   )&rA   rB   rC   rD   r   r  rj  rs  titles_allowedri   r   rK  r   classmethodr   r   propertyr   r   r   r   r   r  r
  r  r  r  r  r+  r2  r8  r$  rE  rH  re  r}  ru  rv  r-   r1   r/   r   r     sD     GNHLN  K 
E '!%' '42 1 1>
'6
'#J,N	6	"!FG,&0%4N'c7cJ+3Z$A0 +/#'"!`+'`+ !`+ 	`+
 `+ 
`+r1   r   c                      e Zd ZU dZdZdZdZi dededede	d	ed
e
de
dededededededededeZded<   d! fdZd" fdZe	 	 d#d       Z	 	 d$dZd% fdZd&d' fdZd(dZd)dZd*dZ	 	 	 	 d+ fd Z xZS ),ModuleDocumenterz6
    Specialized Documenter subclass for modules.
    r   rw   r   rk   undoc-membersr   inherited-membersshow-inheritancesynopsisplatform
deprecatedmember-orderexclude-membersrl   rm   zimported-memberszignore-module-allno-valuer   r!   r   c                V    t        |   |  t        | j                         d | _        y r,   )r   r   rs   rp   __all__r7   r   r   s     r/   r   zModuleDocumenter.__init__  s#    $T\\*-1r1   c                   | j                   }| xj                   | j                  z  c_         t        |   d        || _         |rBt	        |j
                  |j                        D ]  \  }}| j                  ||d   |d            y y )Nr   r   )r   _extra_indentr   rE  r>  r?  r@  r   )r7   rA  
old_indentr   rD  r   s        r/   rE  zModuleDocumenter.add_content  sz    [[
t)))D!  !2!2L4F4FG 4	cdCFCF34 r1   c                     yrH   r-   r   rr   r   r   r   s        r/   r   z$ModuleDocumenter.can_document_member  s     r1   c                \    | t         j                  t        d      d       |xs d|z   g fS )Nz*"::" in automodule name doesn't make senser   r   rw   )r   r   r   r7   r   r   r   r   s        r/   r   zModuleDocumenter.resolve_name  s8    NN2KL )  +
d"B&&r1   c                    t         |          }| j                  s| j                  r-t        j                  t        d      | j                  z  d       |S )Nz@signature arguments or return annotation given for automodule %sr   r   )r   r   r   r   r   r   r   r   )r7   r  r   s     r/   r   zModuleDocumenter.parse_name  sQ    g "99NN2 8 9;?==I )  + 
r1   c                B   t         |   |      }	 | j                  j                  s$t	        j
                  | j                        | _        |S # t        $ rG}t        j                  t        d      |j                  d   | j                  fz  d       Y d }~|S d }~ww xY w)NzN__all__ should be a list of strings, not %r (in module %s) -- ignoring __all__r   r   r   )r   r   rp   ignore_module_allr   getallrU   r  r]   r   r   r   r   r   )r7   r  r  r  r   s       r/   r   zModuleDocumenter.import_object  s    g#J/	I<<11&~~dkk: 
  	INN2 C DHHQK78>G  I I 
	Is   :A 	B<BBc                   t         j                  | |       | j                         }| j                  j                  r)| j                  d| j                  j                  z   |       | j                  j                  r)| j                  d| j                  j                  z   |       | j                  j                  r| j                  d|       y y )Nz   :synopsis: z   :platform: z   :deprecated:)r   r+  r$  rp   r  r   r  r  )r7   r'  r(  s      r/   r+  z%ModuleDocumenter.add_directive_header
  s    ''c2((*
 <<  MM*T\\-B-BBJO<<  MM*T\\-B-BBJO<<""MM+Z8 #r1   c                ,   | j                   r| j                   j                  }ni }i }t        | j                        D ]d  }	 t	        | j                  |d      }t        |      rt        |      }|j                  d|fg       }t        ||dj                  |            ||<   f t        j                  | j                        D ]?  }||vs|j                  d|fg       }t        |t        dj                  |            ||<   A |S # t        $ r Y w xY w)zGet members of target module.Nrw   r!  )r   )r   rB  dirrU   r   r   r   rn   r   r   rU  r   getannotationsrV  )r7   rB  rk   r{   valuer   s         r/   get_module_membersz#ModuleDocumenter.get_module_members  s	   ==//II+-$ 	D$T[[$=%=&u-E%MM2t*b9	 ,T5DIIiDX Y	 **4;;7 	MD7"%MM2t*b9	 ,T<7;yy7K!M	M  " s   A!D	DDc           	        | j                         }|rw| j                  dt        |j                               fS |j                         D ]"  }|j                  | j                  vsd|_        $ dt        |j                               fS | j                  j                  xs g }g }|D ]U  }||v r|j                  ||          t        j                  t        d      t        | j                  dd      |fz  d       W d|fS )NTFzHmissing attribute mentioned in :members: option: module %s, attribute %srA   z???r   r   )r  r  r=  rq  rA   r   rp   rk   r;   r   r   r   r   rU   )r7   rG  rk   rr   
memberlistr  r{   s          r/   rH  z#ModuleDocumenter.get_object_members2  s   ))+||# T'.."2333%nn. .Fdll:)-. d7>>#3444--3JC" 37?JJwt}-NN2 '@ $A$0j%$PRV#W$X )2 # 3	3 #:r1   c                
   |dk(  rk| j                   r_| j                   J | j                   t              t              |j                  d        dfd}|j                  |       |S t        |   ||      S )NrZ   c                     | d   j                   S r  r  r  s    r/   rk  z/ModuleDocumenter.sort_members.<locals>.<lambda>U  r  r1   rl  c                t    | d   j                   j                  d      d   }|v rj                  |      S S r  )r{   rL   r   )r  r{   
module_allmodule_all_lenmodule_all_sets     r/   r  z.ModuleDocumenter.sort_members.<locals>.keyfuncX  s?    Qx}}**403>)%++D11))r1   r  )r  rV   r%  rr  r   ru  )r7   r   r  r  r  r  r  r   s       @@@r/   ru  zModuleDocumenter.sort_membersL  s    J4<<<<+++J _N _N !45* )7'U;;r1   r   r   r>   r@   r  r  r  r  r  r  r  )r>   zdict[str, ObjectMember]r  r  )rA   rB   rC   rD   r   r  r  rP   ri   rW   r0   r_   rS   r   rK  r   rE  r  r   r   r   r   r+  r  rH  ru  r   r   s   @r/   r  r    sH    GNM
>
#2K
K
!46N
 	K
 *4X
 	H	
 +K	

 	+

 .?@V
 	>
 ,=n
 	K
 *=k
 	K
 	;
K 
2
4 !% 
'6'964<<$A< <r1   r  c                      e Zd ZdZ	 	 ddZy)ModuleLevelDocumenterzo
    Specialized Documenter subclass for objects on module level (functions,
    classes, data/constants).
    c                    ||||gz   fS |r|j                  d      }|||gz   fS | j                  j                  j                  d      }|s%| j                  j                  j                  d      }|||gz   fS )Nr   rg  	py:module)r   r   rp  rn   ref_contextr  s        r/   r   z"ModuleLevelDocumenter.resolve_namej  s    Gtf,,,kk#&GGtf,,, (($$(()9:hh**..{;G4&(((r1   Nr  rA   rB   rC   rD   r   r-   r1   r/   r  r  e  s    )6)r1   r  c                      e Zd ZdZ	 	 ddZy)ClassLevelDocumenterz_
    Specialized Documenter subclass for objects on class level (methods,
    attributes).
    c                   ||||gz   fS |r|j                  d      }nT| j                  j                  j                  d      }|+| j                  j                  j                  d      }|d g fS |}|j                  d      \  }}}|g}|s%| j                  j                  j                  d      }|s%| j                  j                  j                  d      }|||gz   fS )Nr   rh  zpy:classrg  r  )r   r   rp  rn   r  
rpartition)	r7   r   r   r   r   mod_clsmod_cls_sepr   s	            r/   r   z!ClassLevelDocumenter.resolve_name  s    Gtf,,,kk#&G
 xx))--o>H88//33J?#8OG#..s3c%hh((,,-=>Ghh**..{;G4&(((r1   Nr  r  r-   r1   r/   r  r  |  s    )6)r1   r  c                  V     e Zd ZU dZdZded<   g Zded<   d
dZd fdZd fd	Z	 xZ
S )DocstringSignatureMixinz
    Mixin for FunctionDocumenter and MethodDocumenter to provide the
    feature of reading the signature from the docstring.
    Nr  _new_docstringsr   _signaturesc           	     ~   | j                   d   g}t        | t              rS|j                  d       t	        | j
                  d      r,|j                  d | j
                  j                  D               | j                         }|y|d d  | _	        g | _
        d }t        |      D ]  \  }}t        |      D ]  \  }}|s n|j                  d      r|j                  d      j                         }t        j                  |      }|s n|j!                         \  }	}
}}}}||vr n| j"                  }|j$                  j&                  j(                  j*                  }t-        dj/                  ||dz   d        |      | j                  |<   |||f}| j                  j                  d	| d
|         | |S  |S )Nrv   r   rN  c              3  4   K   | ]  }|j                     y wr,   )rA   ).0r   s     r/   	<genexpr>z:DocstringSignatureMixin._find_signature.<locals>.<genexpr>  s     "OC3<<"Os   )NN\r!  r   (z) -> )r   rP  ClassDocumenterr;   hasattrrU   extendrN  r2  r  r  r   endswithr   r   r   r   r   r.  r/  r0  r1  r   r   )r7   valid_namesr6  r   r   doclinesjr   r   exmodr   r   r   r   r   r   r1  s                    r/   _find_signaturez'DocstringSignatureMixin._find_signature  s   ||B'(dO,z*t{{I."""O4;;;N;N"OO\\^
)!}$Z0 "	KAx$X. E4==&;;t,335D &++D1;@<<>8tT7D& {* !NN	%OO44==GG	*;DIIhqSTuvFV<W<E+G$$Q' >!6\F $$++avU6(,CD;E> !I"	H r1   c                P    | j                   | j                   S t        | 	         S r,   )r  r   r2  r   s    r/   r2  zDocstringSignatureMixin.get_doc  s(    +'''w  r1   c                   |  | j                   7| j                  j                  r!| j                         }||\  | _         | _        t        |   di |}| j                  rdj                  |g| j                  z         S |S )Nr!  r-   )	r   r   autodoc_docstring_signaturer  r   r   r  r  r   )r7   r  r   r'  r   s       r/   r  z(DocstringSignatureMixin.format_signature  s}    IIKK;; ))+F!)/&	4;g&0099cUT%5%5566Jr1   r>   z$tuple[str | None, str | None] | Noner  r  )rA   rB   rC   rD   r  rK  r  r  r2  r  r   r   s   @r/   r  r    s4     /3O+2K2h!
 r1   r  c                  $     e Zd ZdZd fdZ xZS )DocstringStripSignatureMixinzz
    Mixin for AttributeDocumenter to provide the
    feature of stripping any function signature from the docstring.
    c                    | j                   2| j                  j                  r| j                         }|
|\  }| _        t        |   di |S r  )r   r   r  r  r   r   r  )r7   r  r   _argsr   s       r/   r  z-DocstringStripSignatureMixin.format_signature  sQ    II77 ))+F! &,"t{w'1&11r1   r  )rA   rB   rC   rD   r  r   r   s   @r/   r  r    s    2 2r1   r  c                  p     e Zd ZdZdZdZe	 	 dd       ZddZdddZ	d fdZ
d fdZdd	Zdd
Z xZS )FunctionDocumenterz8
    Specialized Documenter subclass for functions.
    function   c                    t        j                  |      xs> t        j                  |      xs' t        j                  |      xr t	        |t
              S r,   )r   
isfunction	isbuiltin	isroutinerP  r  r  s        r/   r   z&FunctionDocumenter.can_document_member  sL     ""6* Ug.?.?.G U""6*Sz&BR/S	Vr1   c                ~   | j                   j                  dv r|j                  dd       | j                   j                  dk(  r|j                  dd       	 | j                  j
                  j                  d| j                  d       t        j                  | j                  | j                   j                        }t        |fi |}| j                   j$                  r|j'                  dd      }|S # t        $ r4}t        j                  t        d	      | j                   |       Y d }~y
d }~wt"        $ r d
}Y rw xY w)Nnonedescriptionshow_annotationFshortunqualified_typehintsT autodoc-before-process-signaturetype_aliases-Failed to get a function signature for %s: %srw   r  \\)r   autodoc_typehintsro   autodoc_typehints_formatr   ry   r5  rU   r   	signatureautodoc_type_aliasesr    r  r   r   r   r   r]   strip_signature_backslashr   )r7   r  r'  r   r  s        r/   r  zFunctionDocumenter.format_args  s    ;;((,CC/7;;//7:5t<		HHLL@$++uU##DKKdkk>^>^_C&s5f5D ;;00<<f-D  	NN2MN==#/ 	D	s   A2C3 3	D<<*D++D<;D<c                     y r,   r-   r7   rn  s     r/   r}  z#FunctionDocumenter.document_members)  r<   r1   c                    | j                         }t        | 	  |       t        j                  | j
                        st        j                  | j
                        r| j                  d|       y y )N
   :async:)r$  r   r+  r   iscoroutinefunctionrU   isasyncgenfunctionr   )r7   r'  r(  r   s      r/   r+  z'FunctionDocumenter.add_directive_header,  sX    ((*
$S)&&t{{3w7Q7QRVR]R]7^MM,
3 8_r1   c                   | j                   j                  dk(  r|j                  dd       g }| j                  rMdj	                  | j
                        | j                  j                  v r| j                   j                  dk7  rd}n"d}t        | $  di |}|j                  |       t        j                  | j                        r| j                  j                  j                         D ]g  \  }}|t        u r| j!                  ||      }|s$t#        | j$                  d      }||_        dg|_        |j                  |j                                i |r| j                  t        j&                  | j                  | j                   j(                        }	t+        | j                  d	i       }
| j                  j                  dj	                  | j
                           D ]R  }| j-                  |	|      }t/        ||
| j                   j(                        }t1        |fi |}|j                  |       T d
j	                  |      S )Nr
  r  Tr   r  Frw   r  __globals__r!  r-   )r   r  ro   r   r   r   	overloadsr  r   r  r;   r   is_singledispatch_functionrU   r   r@  annotate_to_first_argumentr  r   r  r  r   merge_default_valuer   r    )r7   r  sigs
overloadedr'  typfuncdispatchfuncr|  actualr  overloadr   s               r/   r  z#FunctionDocumenter.format_signature3  s   ;;//7:5t<MM&$--*A*AA--7JJ'*4V4CKK--dkk:![[11779 	C	T&=#'#B#B4#ML#%7%K
,8
).0T
*J$?$?$AB	C $--3&&t{{48KK4T4TVF&t{{M2FK MM33CHHT\\4JK !33FHE-h.2kk.N.NP *(=f=C ! yyr1   c                @   t        |j                  j                               }t        |      D ]\  \  }}|j                  j	                  |j
                        }|s.|j                  dk(  s>|j                  |j                        ||<   ^ |j                  |      S zGMerge default values of actual implementation to the overload variants.z...)default
parametersr=  r-  rq  r   rn   r{   r+  r   r7   r'  r(  r-  r   paramactual_params          r/   r!  z&FunctionDocumenter.merge_default_value\      (--4467
!*- 	LHAu!,,00<L 6 %l6J6J K
1	L
 :66r1   c                <   	 t        j                  || j                  j                        }t        |j                        dk(  ryd }t        |j                  j                               }|d   j                  t        j                   u r2|d   j#                  |      |d<   	 |j#                  |      |_        |S |S # t        $ r4}t
        j                  t        d      | j                  |       Y d}~yd}~wt        $ r Y yw xY w# t&        t        f$ r Y yw xY w)?Annotate type hint to the first argument of function if needed.r  r  Nr   c                      y r,   r-   r-   r1   r/   dummyz<FunctionDocumenter.annotate_to_first_argument.<locals>.dummyt      r1   
annotationr,  r   r  r   r  r  r   r   r   r   r]   r%  r-  r=  rq  r9  r   emptyr   __signature__rU  r7   r%  r$  r'  r  r6  paramss          r/   r   z-FunctionDocumenter.annotate_to_first_argumentf  s   	##Dt{{7W7WXC s~~!#	 cnn++-.!99??2q	))S)9F1I&)kk% '2 ''#
 1  	NN2MN==#/ 		  #I. /   +B? $D	 ?	D*C77DD	DDr  r  r  r  r  r'  r   r(  r   r>   r   r%  r   r$  r   r>   zCallable | None)rA   rB   rC   rD   r   rs  r  r   r  r}  r+  r  r!  r   r   r   s   @r/   r  r    sP     GLV!%V V,4'R7r1   r  c                  ,     e Zd ZdZdZdZd fdZ xZS )DecoratorDocumenterzB
    Specialized Documenter subclass for decorator functions.
    	decoratorrv   c                0    t        |   di |}d|v r|S y)NrJ   rw   r-   )r   r  )r7   r  r   r   s      r/   r  zDecoratorDocumenter.format_args  s$    w",V,$;Kr1   r  )rA   rB   rC   rD   r   rj  r  r   r   s   @r/   rC  rC    s      G H r1   rC  zenum.EnumMeta.__call__ztyping.Generic.__new__c                  6    e Zd ZU dZdZdZeeeeee	e
eeeedZded<   dZdZd	ed
<   dZded<   d fdZe	 	 dd       Zd d! fdZd"dZd#dZd$ fdZd# fdZd%dZd&dZd' fdZd(dZd)dZd*dZd+ fdZd d, fdZ 	 	 	 	 d-	 	 	 	 	 	 	 	 	 d. fdZ! xZ"S )/r  z6
    Specialized Documenter subclass for classes.
    rb      )rk   r  r   r  r  r  r  rl   rm   class-doc-fromr   r!   r      Nr   _signature_classrw   r   _signature_method_namec                   t        |   |  | j                  j                  dk(  r| j                  j                         | _        | j                  j                  ddg| j                  d<   nJ| j                  j                  j                  d       | j                  j                  j                  d       t        | j                         y )N	separated__new__r   rm   )	r   r   r   autodoc_class_signaturerp   r   rZ  r;   rs   r  s     r/   r   zClassDocumenter.__init__  s    $;;..+=<<,,.DL ||++33<j2I./,,33I>,,33J?T\\*r1   c                |    t        |t              xs+ |xr' t        j                  |      xs t        |t              S r,   )rP  r   r   	isNewTyper	   r  s        r/   r   z#ClassDocumenter.can_document_member  s9     &$' SQ))&1PZ5P	Sr1   c                h   t         |   |      }|rt        | j                  d      r,| j                  d   | j                  j
                  k7  | _        nd| _        t        j                  | j                        st        | j                  t              rt        | j                  d| j                        }|| j                  k7  rl| j                  j                  |      rQ| j                  t        |      d  j                  d      j!                  d      }|| j                  z   | _        || _        |S )NrA   rv   TrB   r   )r   r   r  rU   r   rA   doc_as_attrr   rQ  rP  r	   r#  r   rW  r%  rM   rL   )r7   r  r  r   basesr   s        r/   r   zClassDocumenter.import_object  s    g#J/ t{{J/$(LL$48L8L$L #'   -DKK1Q!$++|T\\Jdll*t||/F/Fw/O LLW7==cBHHME#(4<<#7DL#*DL
r1   c                    t        j                   j                        st         j                  t              ryd fd}t         j                  d      r=t         j                  j                  t              rd d  j                  j                  fS  |t         j                        d      }|#|j                   d|j                   t        v rd }|l j                  j                  j                  d|d       	 t        j                  |d j                   j"                        }t         j                        d|fS  | j                  d	      }|#|j                   d|j                   t&        v rd }|c j                  j                  j                  d|d       	 t        j                  |d j                   j"                        } j                  d	|fS  | j                  d
      }|c j                  j                  j                  d|d       	 t        j                  |d j                   j"                        } j                  d
|fS  j                  j                  j                  d j                  d       	 t        j                   j                  d j                   j"                        }d d |fS # t$        $ r Y w xY w# t$        $ r Y w xY w# t$        $ r Y w xY w# t$        $ r Y yw xY w)N)NNNc                    t        j                  | |      ryj                  | |d      }t        j                  |      st        j                  |      sy|S )zF Get the `attr` function or method from `obj`, if it is user-defined. N)r   is_builtin_class_methodr   ismethodr  )r|   attrr7   s     r/   #get_user_defined_function_or_methodzKClassDocumenter._get_signature.<locals>.get_user_defined_function_or_method  sK    ..sD9==dD1D$$T*g.@.@.FKr1   r<  __call__r   r  Tbound_methodr  rN  r   F)r|   r   rY  r   r>   r   )r   rQ  rU   rP  r	   r  r<  r   r   rB   rC   _METACLASS_CALL_BLACKLISTr   ry   r5  r  r   r  r]   _CLASS_NEW_BLACKLIST)r7   rZ  callr'  newrc   s   `     r/   _get_signaturezClassDocumenter._get_signature  s   T[[)ZW-M#	 DKK14;;44i@t{{8888 343DjQ//"!D$5$5#67;TTHHLL@$M''459[[5U5UWDKK(*c99
 2$++yI?..!3#3#3"459MM?HHLL@#tL''$59[[5U5UW{{Is22
 34;;
KHHLL@$M''459[[5U5UW{{J33 	<dkk5Q	##DKKe151Q1QSCs?"M         	  	sI    AK &:K :K& :K5 	KK	K#"K#&	K21K25	L Lc                   | j                   j                  dv r|j                  dd       | j                   j                  dk(  r|j                  dd       	 | j	                         \  | _        }}|xs d| _        |yt        |fd	di|S # t        $ r4}t        j                  t        d      | j                  |       Y d }~yd }~ww xY w)
Nr  r	  Fr
  r  Tz0Failed to get a constructor signature for %s: %srw   show_return_annotation)r   r  ro   r  rb  rJ  r  r   r   r   r   rK  r    )r7   r  rK  r'  r  s        r/   r  zClassDocumenter.format_args4  s    ;;((,CC/7;;//7:5t<	AEATATAV>D!#93 '=&B#;"3OuOOO  	NN2PQ==#/		s   B 	C	*CC	c                    t         |          }||d   d f}t        | j                        D ])  \  }}|j	                  d      s|d d | j                  |<   + |S )Nr   z -> Nonei)r   r  r   r  r  )r7   r   r   r'  r   s       r/   r  zClassDocumenter._find_signatureH  sm    (*Qi&F 0 01 	/FAs||J' '*#2h  #		/ r1   c                   | j                   ry| j                  j                  dk(  ry| j                  j                  dk(  r|j	                  dd       t
        	|          }g }| j                         }|r| j                  j                  dk7  rt        | j                  | j                  d       }t        |di       }|D ]  }t        ||| j                  j                        }t        |j                  j!                               }|j#                  |dd  t$        j&                  	      }t)        |fi |}|j+                  |        n|j+                  |       d
j-                  |      S )Nrw   rM  r
  r  Tr  r  r   )r-  return_annotationr!  )rS  r   rO  r  ro   r   r  get_overloaded_signaturesr  r   rJ  rK  r   r  r=  r-  rq  r   r   r;  r    r;   r   )
r7   r  r'  r"  r  methodr  r(  r-  r   s
            r/   r  z ClassDocumenter.format_signatureV  sF   ;;..+=;;//7:5t<g&(224	66&@!$"7"79T9TVZ[F&v}bAK% !-h.2kk.N.NP "("5"5"<"<">?
#++z!"~>Goo , O)(=f=C ! KKyyr1   c                   | j                   r| j                  r| j                   j                  D ]  }	 t        j                  |j
                        }|j                          dj                  |j                  | j                  g      }||j                  v r|j                  j                  |g       c S ||j                  v rg c S  g S # t        $ r Y w xY w)Nr   )rJ  rK  rN  r   r  rB   analyzer   rC   r  rn   r  r   )r7   r   r   qualnames       r/   rh  z)ClassDocumenter.get_overloaded_signaturesv  s      T%@%@,,44 
-88HH$$&"xx)9)94;V;V(WXH8#5#55'1155hCC!X%6%66!	 7 	 # s   A?C5C	CCc                    t        | j                  d| j                        }t        | j                  dd       }|t        | j                  dd       }|rd|v rd }|r|rdj                  ||g      S y )NrB   rC   rA   z<locals>r   )r   rU   r   r   )r7   __modname__rC   s      r/   get_canonical_fullnamez&ClassDocumenter.get_canonical_fullname  sm    "4;;dllK#DKKF'ZFLJ,6L<88[,788r1   c                   | j                         }| j                  rd| _        t        |   |       t        j                  | j                        st        | j                  t              ry | j                  rCdj                  | j                        | j                  j                  v r| j                  d|       | j                         }| j                  sEt        j                  | j                        s&|r$| j                   |k7  r| j                  d|z  |       | j                  s| j"                  j$                  r{t        j&                  | j                        r t)        | j                  j*                        }nWt-        | j                  d      r?t/        | j                  j0                        r t)        | j                  j0                        }ng }| j2                  j4                  j7                  d| j                   | j                  | j"                  |       | j8                  j:                  dk(  r|D cg c]  }t=        |d       }}n|D cg c]  }t=        |       }}| j                         }| j                  d	|       | j                  d
t?        d      dj                  |      z  z   |       y y y c c}w c c}w )N	attributer   
   :final:z   :canonical: %s	__bases__autodoc-process-basesr
  smartrw   r   z	Bases: %s, ) r$  rS  r  r   r+  r   rQ  rU   rP  r	   r   r   r   finalsr   ro  r   rp   show_inheritancegetorigbasesr=  __orig_bases__r  r%  rs  r   r  r5  r   r  r#   r   )r7   r'  r(  canonical_fullnamerT  r   base_classesr   s          r/   r+  z$ClassDocumenter.add_directive_header  s   ((*
!,D$S)T[[)ZW-M==SXXdll3t}}7K7KKMM,
3!88:  ):):4;;)G&4==<N+NMM-0BBJO DLL$A$A##DKK0 T[[778k2s4;;;P;P7QT[[223HHOO  !8!%T\\5R {{33w>AFG#W 5GG8=>>>,,.JMM"j)MM%!K.499\3J"JJJW+ %B  H>s   <J?Kc                l   t        | j                  | j                  | j                  | j                  j
                        }|s| j                  j                  sdg fS g }| j                  j                  D ]J  }||v r|j                  ||          t        j                  t        d      || j                  fz  d       L d|fS | j                  j                  rdt        |j                               fS d|j                         D cg c]  }|j                   | j                  k(  s|  c}fS c c}w )NFz!missing attribute %s in object %sr   r   )r   rU   r   r   r   r-  rp   rk   r;   r   r   r   r   rL  r=  rq  r   )r7   rG  rk   selectedr{   ms         r/   rH  z"ClassDocumenter.get_object_members  s
   #DKKt}}$(KK$J$JL<<''by H,, J7?OOGDM2NN2&I#J$($--#8$9?H # J	J (?"\\++$w~~/000gnn&6R!((dkk:Q1RRRRs   
D1)D1c                   t        | j                  t              r)| j                  j                  t        j                  k(  rg S t        j
                  d d dk  r#t        j                  | j                        st        | j                  t              r| j                  j                  d      j                  d      }| j                  }t        t        |            D ]  }dj                  |d t        |      |z
         }|t        |      |z
  d  |z   }	 t        j                   |      }|j#                          d|d   f}t%        |j&                  j)                  |g             }|r|| _        || _        |gc S  | j,                  r| j/                         rg S y t1        | dd       }	|	|	S | j2                  j)                  d| j4                  j6                        }
g }t9        | j                  | j:                        }|r|j=                  |       |
dv r^| j;                  | j                  d	d       }t9        || j:                  | j4                  j>                  | j                  d	      }|J|t        j@                  j                  k(  s+|j                         t        j@                  j                  k(  rd }|s| j;                  | j                  d
d       }t9        || j:                  | j4                  j>                  | j                  d
      }|J|t        jB                  j                  k(  s+|j                         t        jB                  j                  k(  rd }|r|
dk(  r|g}n|j=                  |       | jD                  jF                  jH                  jJ                  jL                  }|D cg c]  }tO        ||       c}S # t*        $ r Y w xY wc c}w )Nr   )   
   r   rw   rv   r  rH  )ra   rc   r   rN  rc   )(rP  rU   r	   rD   sysversion_infor   rQ  r   rM   rL   r   ranger%  r   r   r  rk  r=  rB  rn   r   rS  get_variable_commentr#  rp   r   autoclass_contentr   r   r;   r-  r   rN  r   r.  r/  r0  r1  r   )r7   partsorig_objpathr   new_modnamenew_objpathr   rq   commentr}   classdoc_fromr6  attrdocstringr   initdocstringrN  r1  r   s                     r/   r2  zClassDocumenter.get_doc  s6   dkk7+{{""goo5	BQ')  -DKK1Q**3/55c:#||s5z* A"%((5#e*q.+A"BK"'E
Q"8<"GK
#1#<#<[#I ((*!;r?3"&x'9'9'='=c2'F"G"+6DL+6DL$+9, # ((*	/6L(()94;;;X;XY
t{{DMM:m, ,,}}T[[*dCH"8T]]#';;#I#I#';;
<M )&//"9"99$$&&//*A*AA $ --YE &w'+{{'M'M'+{{I!? "-"fnn&<&<<"((*fnn.D.DD$(M F*"/J%%m4NN((11::DD	ISTI!)Y7TTe ' d Us   A#O.O	OOc                d   	 ddj                  | j                        f}| j                  r t        j                  | j
                        }n#t        j                  | j                               }|j                          t        |j                  j                  |g             S # t        $ r Y y w xY w)Nrw   r   )r   r   rS  r   r  r   r  rk  r=  rB  rn   r   )r7   rq   r   s      r/   r  z$ClassDocumenter.get_variable_comment  s    		sxx-.C)44T\\B)44T5J5J5LM**..sB788 		s   B B# #	B/.B/c                   t        j                  | j                        rt| j                  j                  dk(  r!t        | j                  j                  d      }nt        | j                  j                        }t        t        d      |z  dgd      }t        | j                  t              rt        | j                  j                        g}| j                  j                  D ]Q  }| j                  j                  dk(  r|j                  t        |d             8|j                  t        |             S | j                  j                   rm| j                  j                  dk(  r!t        | j                  j                   d      }nt        | j                  j                         }|j                  d|z          | j                  j"                  r|j                  d       | j                  j$                  r|j                  d       t        t        d	      d
j'                  |      z  dgd      }| j(                  r\| j*                  | j-                         k7  r?	 t/        j0                  | j*                        | _        | j2                  j5                          | j(                  rp| j9                         s`	 | j                  j                  dk(  rt        | j                  d      }nt        | j                        }t        t        d      |z  gd      }t<        | }  |       y # t6        $ r Y w xY w# t:        $ r Y *w xY w)Nr
  ru  alias of %srw   )r   zbound=\ zcovariant=Truezcontravariant=Truezalias of TypeVar(%s)rv  ) r   rQ  rU   r   r  r#   __supertype__r
   r   rP  r	   reprrA   __constraints__r;   r$   	__bound____covariant____contravariant__r   rS  r   r  r   r  r   rk  r   r  rU  r   rE  )r7   rA  	supertypeattrs
constraintboundaliasr   s          r/   rE  zClassDocumenter.add_content'  s   T[[){{33w>#DKK$=$=wG	#DKK$=$=>	%q'7)'CR&HQSTLdkk7+$++../0E"kk99 C
;;777BLL!5j'!JKLL!5j!AB	C
 {{$$;;777B#DKK$9$97CE#DKK$9$9:E[501{{((-.{{,,12%)*TYYu-==rBL 0E0E0G G . 9 9$,, G%%' D$=$=$?;;777B#DKK9E#DKK0E)1]+;e+C*DRP 	L)   " s%   >L) :AL8 )	L54L58	MMc                >    | j                   ry t        | 	  |       y r,   )rS  r   r}  )r7   rn  r   s     r/   r}  z ClassDocumenter.document_membersY  s     -r1   c                (    t         |   |||      S )N)rA  r
  rn  )r   rv  )r7   rA  ro  r
  rn  r   s        r/   rv  zClassDocumenter.generate^  s$     w\-9,7   9 	9r1   r  r  r  r  )r>   z/tuple[Any | None, str | None, Signature | None]r  r  )r>   zlist[Signature])r>   r   r  r  r  )r>   list[str] | Noner  r  r  r  )#rA   rB   rC   rD   r   rs  rP   ri   rW   r_   rS   rd   r   rK  rj  rJ  rK  r   r  r   r   rb  r  r  r  rh  ro  r+  rH  r2  r  rE  r}  rv  r   r   s   @r/   r  r    s    GL!K6N'9L1)n/K  H c "$C$+ S!%S S
"P dP(@"(XTS(FUP
0*d. +/#'"!9'9 !9 	9
 9 
9 9r1   r  c                  L    e Zd ZdZdZdZej                  dz   Ze	 	 dd       Z	y)ExceptionDocumenterz>
    Specialized ClassDocumenter subclass for exceptions.
    	exceptionr     c                    	 t        |t              xr t        |t              S # t        $ r&}| j
                   d| d| d}t        |      |d }~ww xY w)Nz failed to discern if member z with membername z is a BaseException subclass.)rP  r   
issubclassBaseExceptionr  rA   r]   )r   rr   r   r   r   r  r   s          r/   r   z'ExceptionDocumenter.can_document_membery  si    
	+fd+Q
6=0QQ 	+
 <<. =fX F)l*GI  S/s*	+s   !$ 	A!AANr  )
rA   rB   rC   rD   r   rs  r  rj  r  r   r-   r1   r/   r  r  o  s?     GL ''!+H+!%+ +r1   r  c                  b    e Zd ZU ded<   ded<   ded<   ded<   ded	<   d
ed<   ddZddZddZy)DataDocumenterMixinBaser   r   r)   r   r   r   r   r   rU   r   r   c                     y)z,Check directive header should be suppressed.Fr-   r   s    r/    should_suppress_directive_headerz8DataDocumenterMixinBase.should_suppress_directive_header      r1   c                     y)z*Check :value: header should be suppressed.Fr-   r   s    r/   should_suppress_value_headerz4DataDocumenterMixinBase.should_suppress_value_header  r  r1   c                     y)z4Update docstring, for example with TypeVar variance.Nr-   )r7   rA  s     r/   update_contentz&DataDocumenterMixinBase.update_content  s    r1   Nr  rA  r
   r>   r@   )rA   rB   rC   rK  r  r  r  r-   r1   r/   r  r    s1    N	LKKr1   r  c                  0     e Zd ZdZd fdZd fdZ xZS )GenericAliasMixinzt
    Mixin for DataDocumenter and AttributeDocumenter to provide the feature for
    supporting GenericAliases.
    c                b    t        j                  | j                        xs t        |          S r,   )r   isgenericaliasrU   r   r  r   s    r/   r  z2GenericAliasMixin.should_suppress_directive_header  s*    &&t{{3 ;8:	<r1   c                L   t        j                  | j                        ru| j                  j                  dk(  rt        | j                  d      }nt        | j                        }|j                  t        d      |z  d       |j                  dd       t        | %  |       y )Nr
  ru  r  rw   )
r   r  rU   r   r  r#   r;   r   r   r  )r7   rA  r  r   s      r/   r  z GenericAliasMixin.update_content  s|    !!$++.{{33w>W5,- 05 8"=B'|,r1   r  r  )rA   rB   rC   rD   r  r  r   r   s   @r/   r  r    s    
<
- 
-r1   r  c                  >     e Zd ZdZdd fdZd fdZd fdZ xZS )	 UninitializedGlobalVariableMixinz
    Mixin for DataDocumenter to provide the feature for supporting uninitialized
    (type annotation only) global variables.
    c                ^   	 t         |   d      S # t        $ r}	 t        | j                  j
                        5  t        | j                  | j                  j                        }t        |d | j                  j                        }| j                  d   |v r t        | _        || _        	 d d d        Y d }~y	 d d d        n# 1 sw Y   nxY wn# t        $ r Y nw xY w|r t        j!                  |j"                  d   dd       | j$                  j'                          Y d }~yd }~ww xY w)	NTr  rv   r   r   r   r   F)r   r   r   r   r   r   r   r   r   r"   r  r   UNINITIALIZED_ATTRrU   r   r   r   r   r   r   )r7   r  r  r   r   r   s        r/   r   z.UninitializedGlobalVariableMixin.import_object  s   	7(D(99 	
$++::; $*4<<9[9[\F"0151Q1Q#SK||B';6&8&,#$ $ 7	$ $ $   NN388A;YNPHH  "%	sQ    
D,CA0C-C;	CC		CD'	CD'CAD''D,c                H    | j                   t        u xs t        |          S r,   rU   r  r   r  r   s    r/   r  z=UninitializedGlobalVariableMixin.should_suppress_value_header  %    11 746	8r1   c                H    | j                   t        u rg S t        |          S r,   rU   r  r   r2  r   s    r/   r2  z(UninitializedGlobalVariableMixin.get_doc  s"    ;;,,I7?$$r1   r  r  r  r  rA   rB   rC   rD   r   r  r2  r   r   s   @r/   r  r    s    
.8% %r1   r  c                       e Zd ZU dZdZdZdZ eej                        Z	de
d<   ee	d<   ee	d<   e	 	 dd	       Zdd
Zdd fdZd fdZd fdZdddZddZddZd fdZd fdZ xZS )DataDocumenterz9
    Specialized Documenter subclass for data items.
    r?  (   ir!   r   r9  r  c                *    t        |t              xr |S r,   )rP  r  r  s        r/   r   z"DataDocumenter.can_document_member  s     &"23>>r1   c                6   t        t        j                  |            }||_        	 t	        j
                  | j                        }|j                          |j                  j                         D ]  \  \  }}}|dk(  s||vs|||<    y# t        $ r Y yw xY w)9Update __annotations__ to support type_comment and so on.rw   N)dictr   r  rK  r   r  r   rk  r   r@  r   )r7   r   r   r   	classnameattrnamer9  s          r/   update_annotationsz!DataDocumenter.update_annotations  s    711&9:!,	%00>H5=5I5I5O5O5Q 71%Hz?x{'B,6K)7  		s   AB ?B B 	BBc                t    t         |   |      }| j                  r| j                  | j                         |S r,   )r   r   r   r  r7   r  r  r   s      r/   r   zDataDocumenter.import_object  s0    g#J/;;##DKK0
r1   c                    t         |          ry| j                         xs g }t        dj	                  t        |g                   \  }}d|v ryyNTr!  z
hide-valueFr   r  r2  r   r   r  r7   r^  r   r`  r   s       r/   r  z+DataDocumenter.should_suppress_value_header  sM    7/1,,.&BC"3DIIc#rl4K"LIxx'r1   c                   t         |   |       | j                         }| j                  j                  t
        u s| j                         ry | j                  j                  r*| j                  d| j                  j                  z  |       y | j                  j                  dk7  rt        | j                  d | j                  j                        }| j                  d   |v r| j                  j                  dk(  r*t         |j                   | j                  d         d      }n)t         |j                   | j                  d         d      }| j                  d|z   |       	 | j                  j"                  s%| j%                         st'        | j(                        ry t+        | j(                        }| j                  d|z   |       y # t,        $ r Y y w xY w	Nz   :annotation: %sr  rv   r
  ru  fully-qualified-except-typing
   :type: z   :value: r   r+  r$  rp   r9  rf   r  r   r   r  r"   r   r  r   r  r$   rn   no_valuer  r   rU   r   r]   r7   r'  r(  r   objreprr   s        r/   r+  z#DataDocumenter.add_directive_header  s   $S)((*
<<""h.$2W2W2Y\\$$MM.1H1HH$& {{,,6,T[[$-1[[-M-MO<<#{2{{;;wF"6{t||TVGW7X7>#@ #7{t||TVGW7X7V#XMM,"8*ELL))T-N-N-Pt{{+0=GMM-'"9:F    %;G !*G 	GGc                     y r,   r-   r  s     r/   r}  zDataDocumenter.document_members/  r<   r1   c                x    | j                  | j                  xs | j                  dd       }|xs | j                  S NrB   r   r   rU   r   r7   ro  s     r/   r  zDataDocumenter.get_real_modname2  0    }}T[[%?DKKtT+t||+r1   c                    	 t        j                  | j                        }|j                          d|f}||j                  v rt        |j                  |         S 	 y # t        $ r Y y w xY wr   )r   r  r   rk  rB  r=  r   )r7   r  r   rq   s       r/   get_module_commentz!DataDocumenter.get_module_comment6  su    	%00>Hx.Ch(((H..s344 )
   		s   AA 	A)(A)c                f    | j                  | j                  d         }|r|gS t        |          S )Nrv   )r  r   r   r2  )r7   r  r   s     r/   r2  zDataDocumenter.get_docB  s4    ))$,,r*:;97?$$r1   c                l    d | _         |s
t               }| j                  |       t        |   |       y r,   r   r
   r  r   rE  r7   rA  r   s     r/   rE  zDataDocumenter.add_contentJ  s1     %<LL)L)r1   r  r   r   r>   r@   r  r  r  r  r  r  )r  r   r>   r  r  r  )rA   rB   rC   rD   r   rs  rj  r  r  r   rK  rg   ri   r  r   r  r   r  r+  r}  r  r  r2  rE  r   r   s   @r/   r  r    s     GLH"#8#D#DEKE 1K)K
?!%? ?	@,
%	* 	*r1   r  c                       e Zd ZdZdZdZdZdZe	 	 dd       Z	dd fdZ
ddZd fdZddd	Zd fd
ZddZddZd fdZ xZS )MethodDocumenterzQ
    Specialized Documenter subclass for methods (normal, static and class).
    ri  2   r   c                R    t        j                  |      xr t        |t               S r,   )r   r  rP  r  r  s        r/   r   z$MethodDocumenter.can_document_member_  s%       (UFDT1U-UUr1   c                R   t         |   |      }|s|S | j                  j                  j	                  | j
                        }|| j                  }t        j                  |      s,t        j                  || j                  | j
                        r| j                  dz
  | _
        |S )Nr   r{   r   )r   r   r   rO  rn   r   rU   r   isclassmethodisstaticmethodrs  )r7   r  r  r|   r   s       r/   r   zMethodDocumenter.import_objectd  s    g#J/J kk""&&t'7'78;++C!!#&&&s$BRBRS $ 1 1A 5D
r1   c                $   | j                   j                  dv r|j                  dd       | j                   j                  dk(  r|j                  dd       	 | j                  t        j
                  k(  r| j                  t        k7  rd}nt        j                  | j                  | j                  | j                        rh| j                  j                  j                  d	| j                  d       t        j                  | j                  d| j                   j                  
      }ng| j                  j                  j                  d	| j                  d       t        j                  | j                  d| j                   j                  
      }t        |fi |}| j                   j,                  r|j/                  dd      }|S # t         $ r4}t"        j%                  t'        d      | j(                  |       Y d }~yd }~wt*        $ r d}Y rw xY w)Nr  r	  Fr
  r  Tz()r  r  r\  +Failed to get a method signature for %s: %srw   r  r  )r   r  ro   r  rU   r   r   r   r  r   r   ry   r5  r  r  r    r  r   r   r   r   r]   r  r   )r7   r  r   r'  r  s        r/   r  zMethodDocumenter.format_argsu  s   ;;((,CC/7;;//7:5t<	{{foo-$++2G
 ))$++4;;TM]M]^HHLL%%&H$++W\]!++DKKe9=9Y9Y[C HHLL%%&H$++W[\!++DKKd9=9Y9Y[C*39&9 ;;00<<f-D  	NN2KL==#/ 	D	s   EG 	H*G>>HHc                   t         |   |       | j                         }| j                  j                  j                  | j                  | j                        }t        j                  |      r| j                  d|       t        j                  |      st        j                  |      r| j                  d|       t        j                  |      r| j                  d|       t        j                  || j                  | j                        r| j                  d|       | j                  rEdj!                  | j"                        | j                  j$                  v r| j                  d|       y y y )N   :abstractmethod:r     :classmethod:r  z   :staticmethod:r   rr  )r   r+  r$  r   rO  rn   r   rU   r   isabstractmethodr   r  r  r  r  r   r   r   rw  )r7   r'  r(  r|   r   s       r/   r+  z%MethodDocumenter.add_directive_header  s   $S)((*
kk""&&t'7'7E##C(MM/<&&s+w/I/I#/NMM,
3  %MM,j9!!#4;;T=M=MNMM-z:==SXXdll3t}}7K7KKMM,
3 L=r1   c                     y r,   r-   r  s     r/   r}  z!MethodDocumenter.document_members  r<   r1   c                   | j                   j                  dk(  r|j                  dd       g }| j                  rMdj	                  | j
                        | j                  j                  v r| j                   j                  dk7  rd}n"d}t        | $  di |}|j                  |       | j                  j                  j                  | j
                  d         }t        j                  |      r|j                   j"                  j%                         D ]x  \  }}|t&        u r| j)                  ||      }|s$t+        | j,                  d      }	| j                  |	_        ||	_        dg|	_        |j                  |	j                                z |r| j                  t        j.                  | j&                  | j                  | j0                  	      r7t        j2                  | j&                  d| j                   j4                  
      }
n6t        j2                  | j&                  d| j                   j4                  
      }
t7        | j&                  di       }| j                  j                  dj	                  | j
                           D ]  }| j9                  |
|      }t;        ||| j                   j4                        }t        j.                  | j&                  | j                  | j0                  	      s8t=        |j>                  jA                               }|jC                  |dd        }tE        |fi |}|j                  |        dj	                  |      S )Nr
  r  Tr   r  Frv   rw   r  r\  r  r   r,  r!  r-   )#r   r  ro   r   r   r   r  r  r   r  r;   r   rO  rn   r   is_singledispatch_method
dispatcherr   r@  rU   r   r  r   r  r   r  r  r   r!  r   r=  r-  rq  r   r    )r7   r  r"  r#  r'  methr$  r%  dispatchmethr|  r'  r  r(  r-  r   s                 r/   r  z!MethodDocumenter.format_signature  s   ;;//7:5t<MM&$--*A*AA--7JJ'*4V4CKK{{##''R(89++D1!__55;;= 
C	T&=#'#B#B4#ML#%5dnnb%I
,0KK
),8
).0T
*J$?$?$AB
C $--3%%dkkt{{IYIYZ **4;;U8<8X8XZ !**4;;T8<8X8XZ 't{{M2FK MM33CHHT\\4JK 
!33FHE-h.2kk.N.NP --dkkt{{373C3CE!%h&9&9&@&@&B!CJ'//:ab>/JH)(=f=C 
! yyr1   c                @   t        |j                  j                               }t        |      D ]\  \  }}|j                  j	                  |j
                        }|s.|j                  dk(  s>|j                  |j                        ||<   ^ |j                  |      S r*  r.  r/  s          r/   r!  z$MethodDocumenter.merge_default_value  r2  r1   c                <   	 t        j                  || j                  j                        }t        |j                        dk(  ryd }t        |j                  j                               }|d   j                  t        j                   u r2|d   j#                  |      |d<   	 |j#                  |      |_        |S |S # t        $ r4}t
        j                  t        d      | j                  |       Y d}~yd}~wt        $ r Y yw xY w# t&        t        f$ r Y yw xY w)r4  r  r  Nr   c                      y r,   r-   r-   r1   r/   r6  z:MethodDocumenter.annotate_to_first_argument.<locals>.dummy  r7  r1   r8  r,  r:  r=  s          r/   r   z+MethodDocumenter.annotate_to_first_argument  s   	##Dt{{7W7WXC s~~!#	 cnn++-.!99??2q	))S)9F1I&)kk% '2 ''#
 1  	NN2KL==#/ 		  #I. r?  c                   | j                   | j                   S | j                  d   dk(  rt        | j                  | j                  | j
                  j                  | j                  | j                        }|J|t        j                  j                  k(  s+|j                         t        j                  j                  k(  rd }|rB| j                  j                  j                  j                  j                   }t#        ||      gS g S | j                  d   dk(  rt        | j                  | j                  | j
                  j                  | j                  | j                        }|J|t        j$                  j                  k(  s+|j                         t        j$                  j                  k(  rd }|rB| j                  j                  j                  j                  j                   }t#        ||      gS g S t&        | Q         S )Nrv   r   )tabsizerN  )r  r   r   rU   r   r   r-  r   r   r   rD   rM   r   r.  r/  r0  r1  r   rN  r   r2  )r7   r   r1  r   s      r/   r2  zMethodDocumenter.get_doc	  s   +
 '''<<z)t{{DMM#{{EE#{{D,<,<>I %foo555"foo&=&== 	 NN0099BBLL	))YGHH	\\"*t{{DMM#{{EE#{{D,<,<>I %fnn444"fnn&<&<< 	 NN0099BBLL	))YGHH	7?$$r1   r  r  r  r  r  r  r@  rA  r  )rA   rB   rC   rD   r   r  rs  rj  r  r   r   r  r+  r}  r  r!  r   r2  r   r   s   @r/   r  r  V  sj     GMLHV!%V V"!F4 2h7<"% "%r1   r  c                  >     e Zd ZdZdd fdZd fdZd fdZ xZS )	NonDataDescriptorMixina  
    Mixin for AttributeDocumenter to provide the feature for supporting non
    data-descriptors.

    .. note:: This mix-in must be inherited after other mix-ins.  Otherwise, docstring
              and :value: header will be suppressed unexpectedly.
    c                    t         |   |      }|r(t        j                  | j                        s	d| _        |S d| _        |S )NTF)r   r   r   isattributedescriptorrU   non_data_descriptorr  s      r/   r   z$NonDataDescriptorMixin.import_object5	  sD    g#J/w44T[[A'+D$ 
 (-D$
r1   c                @    t        | dd       xs t        | 	         S Nr  F)r#  r   r  r   s    r/   r  z3NonDataDescriptorMixin.should_suppress_value_header>	  s(    D"7?? ;8:	<r1   c                <    t        | dd      ry t        | 	         S r  )r#  r   r2  r   s    r/   r2  zNonDataDescriptorMixin.get_docB	  s"    4.6 7?$$r1   r  r  r  r  r  r   s   @r/   r  r  ,	  s    <% %r1   r  c                  F     e Zd ZdZddZdd fdZd fdZd	 fdZ xZS )

SlotsMixinzX
    Mixin for AttributeDocumenter to provide the feature for supporting __slots__.
    c                    	 t        j                  | j                        x}r| j                  d   |v S y# t        t
        f$ r Y yw xY w)z/Check the subject is an attribute in __slots__.rv   F)r   getslotsr   r   r]   r  )r7   parent___slots__s     r/   isslotsattributezSlotsMixin.isslotsattributeP	  sQ    	#*#3#3DKK#@@@||B'+;;;I& 		s   15 AAc                \    t         |   |      }| j                         rt        | _        |S r,   )r   r   r  	SLOTSATTRrU   r  s      r/   r   zSlotsMixin.import_objectZ	  s*    g#J/  "#DK
r1   c                F    | j                   t        u ryt        |          S r5   )rU   r  r   r  r   s    r/   r  z'SlotsMixin.should_suppress_value_headera	  s     ;;)#7799r1   c                   | j                   t        u r`	 t        j                  | j                        }|r<|j                  | j                  d         rt        || j                  d            }|gS g S t        | 9         S # t        $ rC}t        j                  t        d      | j                  j                  |fd       g cY d }~S d }~ww xY w)Nrv   z'Invalid __slots__ found on %s. Ignored.r   r   )rU   r  r   r  r   rn   r   r   r]   r   r   r   rC   r   r2  )r7   r  r   r  r   s       r/   r2  zSlotsMixin.get_docg	  s    ;;)#
#*#3#3DKK#@ #(8(<(<T\\"=M(N 12B4<<PRCS2T UI%;&I 7?$$  r"KL $ 8 8#>Y  P	s$   AB 2B 	C8C	C	Cr  r  r  r  )	rA   rB   rC   rD   r  r   r  r2  r   r   s   @r/   r
  r
  K	  s!    :% %r1   r
  c                  \     e Zd ZdZ e       ZddZddZdd	 fdZd
 fdZ	d fdZ
 xZS )RuntimeInstanceAttributeMixina1  
    Mixin for AttributeDocumenter to provide the feature for supporting runtime
    instance attributes (that are defined in __init__() methods with doc-comments).

    Example:

        class Foo:
            def __init__(self):
                self.attr = None  #: This is a target of this mix-in.
    c                h    | j                  || j                  d         ry| j                  |      ryy)z8Check the subject is an attribute defined in __init__().rv   TF)get_attribute_commentr   +is_runtime_instance_attribute_not_commented)r7   r   s     r/   is_runtime_instance_attributez;RuntimeInstanceAttributeMixin.is_runtime_instance_attribute	  s4     %%fdll2.>?;;FCr1   c                Z   t        j                  |      D ]~  }	 t        |d      }t        |d      }t        j                  |      }|j                          |r<| j                  r0dj                  || j                  d   g      }||j                  v r y y# t        t        f$ r Y w xY w)zHCheck the subject is an attribute defined in __init__() without comment.rB   rC   r   rv   TF)r   getmror   r   r  rk  r   r   r  rU  r   )r7   r   r   r   rl  r   rq   s          r/   r  zIRuntimeInstanceAttributeMixin.is_runtime_instance_attribute_not_commented	  s    >>&) 	C%c<8'^<)44V<  "((Hdll2.>#?@Ch///#	  #K0 s   A9BB*)B*c           	     h   	 t         |   d      S # t        $ r}	 t        | j                  j
                        5  t        | j                  | j                  dd d| j                  | j                  j                        }|d   }| j                  |      r&| j                  | _        || _        	 ddd       Y d}~y	 ddd       n# 1 sw Y   nxY wn# t        $ r Y nw xY w|r t        j                  |j                   d   d	d
       | j"                  j%                          Y d}~yd}~ww xY w)z`Check the existence of runtime instance attribute after failing to import the
        attribute.Tr  Nrv   rb   r   r  r   r   r   r   F)r   r   r   r   r   r   r   r   r   r   r  RUNTIME_INSTANCE_ATTRIBUTErU   r   r   r   r   r   r   r7   r  r  r  r   r   s        r/   r   z+RuntimeInstanceAttributeMixin.import_object	  s   	7(D(99 	$++::; $'dll3B6G37==7;{{7Y7Y[C !VF99&A&*&E&E&,#$ $
 B$ $ $   NN388A;YNPHH  "%	sQ    
D1CA5C	2C 	C	C	CD,	C"D,!C""AD,,D1c                T    | j                   | j                  u xs t        |          S r,   )rU   r  r   r  r   s    r/   r  z:RuntimeInstanceAttributeMixin.should_suppress_value_header	  s*    t>>> 746	8r1   c                    | j                   | j                  u r| j                  | j                        ry t        |          S r,   )rU   r  r  r   r   r2  r   s    r/   r2  z%RuntimeInstanceAttributeMixin.get_doc	  s7    KK4:::@@M7?$$r1   r   r   r>   r?   r  r  r  r  )rA   rB   rC   rD   rU   r  r  r  r   r  r2  r   r   s   @r/   r  r  x	  s0    	 "($28% %r1   r  c                  F     e Zd ZdZddZdd fdZd	 fdZd
 fdZ xZS )#UninitializedInstanceAttributeMixinz
    Mixin for AttributeDocumenter to provide the feature for supporting uninitialized
    instance attributes (PEP-526 styled, annotation only attributes).

    Example:

        class Foo:
            attr: int  #: This is a target of this mix-in.
    c                f    t        |d| j                  j                        }| j                  d   |v S )z2Check the subject is an annotation only attribute.Nrv   )r"   r   r  r   )r7   r   r   s      r/   #is_uninitialized_instance_attributezGUninitializedInstanceAttributeMixin.is_uninitialized_instance_attribute	  s.    $VT4;;3S3ST||B;..r1   c                   	 t         |   d      S # t        $ r}	 t        | j                  | j                  dd d| j
                  | j                  j                        }|d   }| j                  |      rt        | _
        || _        Y d}~yn# t        $ r Y nw xY w|r t        j                  |j                  d   d	d
       | j                  j!                          Y d}~yd}~ww xY w)eCheck the exisitence of uninitialized instance attribute when failed to import
        the attribute.Tr  Nrv   rb   r   r  r   r   r   r   F)r   r   r   r   r   r   r   r   r$  r  rU   r   r   r   r   r   r   r  s        r/   r   z1UninitializedInstanceAttributeMixin.import_object	  s    	7(D(99 	
#DLL$,,s2CW/3}}37;;3U3UW Q;;FC"4DK"(DK D   NN388A;YNPHH  "#	s4    	C+A-BC&	BC&BAC&&C+c                H    | j                   t        u xs t        |          S r,   r  r   s    r/   r  z@UninitializedInstanceAttributeMixin.should_suppress_value_header	  r  r1   c                F    | j                   t        u ry t        |          S r,   r  r   s    r/   r2  z+UninitializedInstanceAttributeMixin.get_doc	  s     ;;,,w  r1   r   r  r  r  r  )	rA   rB   rC   rD   r$  r   r  r2  r   r   s   @r/   r"  r"  	  s!    /
08! !r1   r"  c                       e Zd ZU dZdZdZ eej                        Zde	d<   e
ed<   eed<   dZedd	       Ze	 	 dd
       ZdddZddZdd fdZddZd fdZd fdZddZd fdZd fdZ xZS ) AttributeDocumenterz9
    Specialized Documenter subclass for attributes.
    rq  <   r!   r   r9  r  r  c                    t        j                  |       xs, t        j                  |       xs t        j                  |       S r,   )r   r  r  rX  )r|   s    r/   is_function_or_methodz)AttributeDocumenter.is_function_or_method	
  s4    !!#&Y'*;*;C*@YGDTDTUXDYYr1   c                    t        |t              ryt        j                  |      ryt        j                  |      st        |t
              syy)NFT)rP  r  r   r  r  r   r  s        r/   r   z'AttributeDocumenter.can_document_member
  s@     f./((0  (FD1Ir1   c                     y r,   r-   r  s     r/   r}  z$AttributeDocumenter.document_members
  r<   r1   c                   	 t        t        j                  |            }||_        t        j                  |      D ]u  }	 t        |d      }t        |d      }t        j                  |      }|j                          |j                  j                         D ]  \  \  }}}	||k(  s||vs|	||<    w y# t        t        f$ r Y w xY w# t        t        f$ r Y yw xY w)r  rB   rC   N)r  r   r  rK  r  r   r   r  rk  r   r@  rU  r   r  )
r7   r   r   r   r   rl  r   r  r  r9  s
             r/   r  z&AttributeDocumenter.update_annotations
  s    	w55f=>K%0F"~~f- 
)#|<F+C@H-88@H$$&=E=Q=Q=W=W=Y ?9-Hz$0X[5P4>K1? '4 	* 		sB   =C
  A%B5&B5+B52C
 5CC
 CC
 
CCc                    t         |   |      }t        j                  | j                        r| j                  j
                  | _        | j                  r| j                  | j                         |S r,   )r   r   r   isenumattributerU   r  r   r  r  s      r/   r   z!AttributeDocumenter.import_object1
  sS    g#J/""4;;/++++DK;;##DKK0
r1   c                x    | j                  | j                  xs | j                  dd       }|xs | j                  S r  r  r  s     r/   r  z$AttributeDocumenter.get_real_modname:
  r  r1   c                    t         |          ry| j                         }|r,t        dj	                  t        |g                   \  }}d|v ryyr  r  r  s       r/   r  z0AttributeDocumenter.should_suppress_value_header>
  sK    7/1,,.C&7		#c2,8O&P#	88+r1   c                   t         |   |       | j                         }| j                  j                  t
        u s| j                         ry | j                  j                  r*| j                  d| j                  j                  z  |       y | j                  j                  dk7  rt        | j                  d | j                  j                        }| j                  d   |v r| j                  j                  dk(  r*t         |j                   | j                  d         d      }n)t         |j                   | j                  d         d      }| j                  d|z   |       	 | j                  j"                  s%| j%                         st'        | j(                        ry t+        | j(                        }| j                  d|z   |       y # t,        $ r Y y w xY wr  r  r  s        r/   r+  z(AttributeDocumenter.add_directive_headerJ
  s|   $S)((*
<<""h.$2W2W2Y\\$$MM.1H1HH*U{{,,6,T[[$-1[[-M-MO<<#{2{{;;wF"6{t||TVGW7X7>#@ #7{t||TVGW7X7V#XMM,"8*ELL))T-N-N-Pt{{+0=GMM-'"9:F r  c                R   t        j                  |      D ]z  }	 t        |d      }t        |d      }t        j                  |      }|j                          |r8| j                  r,||f}||j                  v rt        |j                  |         c S | y # t        t        f$ r Y w xY w)NrB   rC   )r   r  r   r   r  rk  r   rB  r=  rU  r   )r7   r   r  r   r   rl  r   rq   s           r/   r  z)AttributeDocumenter.get_attribute_commenti
  s    >>&) 	C%c<8'^<)44V<  "#X.Ch000#H$6$6s$;<<	  #K0 s   A4BB&%B&c                   | j                  | j                  | j                  d         }|r|gS 	 | j                  j                  }d| j                  _        t
        |          || j                  _        S # | j                  _        w xY w)Nrv   F)r  r   r   r   r-  r   r2  )r7   r  origr   s      r/   r2  zAttributeDocumenter.get_docz
  sr    ,,T[[$,,r:JK9	: ;;99D5:DKK27?$59DKK2TDKK2s   4A7 7B
c                l    d | _         |
t               }| j                  |       t        |   |       y r,   r  r  s     r/   rE  zAttributeDocumenter.add_content
  s4     %<LL)L)r1   )r|   r   r>   r?   r  r  r  r  r  r  r  r  )r   r   r  r   r>   r  r  r  )rA   rB   rC   rD   r   rs  r  r  r   rK  rg   ri   rj  staticmethodr-  r  r   r}  r  r   r  r  r+  r  r2  rE  r   r   s   @r/   r*  r*  	  s     GL"#8#D#DEKE 1K)K
 HZ Z !% ,,
>": * *r1   r*  c                       e Zd ZdZdZdZej                  dz   Ze	 	 dd       Z	dd fdZ
d fdZdddZdd	Zd fd
Zd Z xZS )PropertyDocumenterz9
    Specialized Documenter subclass for properties.
    r  r+  r   c                   t        |t              rot        j                  |      ryt	        |j
                  di       }|j                  |      }t        |t              xr t        j                  |j                        S y)NTrO  F)	rP  r  r   
ispropertyr   rU   rn   r  __func__)r   rr   r   r   r   rO  r|   s          r/   r   z&PropertyDocumenter.can_document_member
  sc     fo.!!&)'z2Fll:.!#{3X8J8J3<<8XXr1   c                r   t         |   |      }|rt        j                  | j                        s~t        | j                  di       }|j                  | j                  d         }t        |t              r8t        j                  |j                        r|j                  | _        d| _        yyd| _        |S )r&  rO  rv   TF)r   r   r   r>  rU   r   r   rn   r   rP  r  r?  r  )r7   r  r  rO  r|   r   s        r/   r   z PropertyDocumenter.import_object
  s     g#J/w))$++6#DKKR@H,,t||B/0C#{+0B0B3<<0P!ll%)""
r1   c                    | j                         }|y| j                  j                  j                  d|d       t	        |   di |S )Nrw   r  Fr-   )_get_property_getterr   ry   r5  r   r  )r7   r  r%  r   s      r/   r  zPropertyDocumenter.format_args
  sI    ((*< 	<dEJw",V,,r1   c                     y r,   r-   r  s     r/   r}  z#PropertyDocumenter.document_members
  r<   r1   c                x    | j                  | j                  xs | j                  dd       }|xs | j                  S r  r  r  s     r/   r  z#PropertyDocumenter.get_real_modname
  r  r1   c                   t         |   |       | j                         }t        j                  | j
                        r| j                  d|       | j                  r| j                  d|       | j                         }|| j                  j                  dk(  ry 	 t        j                  || j                  j                        }|j                  t        j                  ur\| j                  j                   dk(  rt#        |j                  d      }nt#        |j                  d      }| j                  d|z   |       y y # t$        $ r4}t&        j)                  t+        d	      | j,                  |       Y d }~y d }~wt.        $ r Y y w xY w)
Nr  r  r  r  r
  ru  r  r  r  )r   r+  r$  r   r  rU   r   r  rB  r   r  r  r  rg  r   r;  r  r$   r  r   r   r   r   r]   )r7   r'  r(  r%  r  r  r  r   s          r/   r+  z'PropertyDocumenter.add_directive_header
  sF   $S)((*
##DKK0MM/<MM,j9((*<4;;88FB	))$7;{{7W7WYI**)//A;;777B293N3NPWXG293N3N3RTGlW4jA B  	NN2MN==#/ 		s   B"E 	F
*E99FFc                    t        | j                  dd       r| j                  j                  S t        | j                  dd       r| j                  j                  S y )Nfgetr%  )r   rU   rG  r%  r   s    r/   rB  z'PropertyDocumenter._get_property_getter
  sE    VT2;;###VT2;;###r1   r  r  r  r  r  r  r  )rA   rB   rC   rD   r   rs  r*  rj  r  r   r   r  r}  r  r+  rB  r   r   s   @r/   r<  r<  
  s^     GL #++a/H
!%
 
"-,:r1   r<  c                    | j                   j                  j                         D ]  \  }}t        ||      s |||g| c S  t	        ||g| S )zAlternative getattr() for types)r   autodoc_attrgettrsr@  rP  r   )ry   r|   r{   r   r$  r%  s         r/   r   r   
  sX    \\44::< -	Tc3T,G,,- T,G,,r1   c                   | j                  t               | j                  t               | j                  t               | j                  t               | j                  t
               | j                  t               | j                  t               | j                  t               | j                  t               | j                  dddt        ddd             | j                  dddt        ddd	             | j                  d
ddt        dd             | j                  di d       | j                  ddd       | j                  dg d       | j                  dddt        dddd             | j                  dddt        ddd             | j                  di d       | j                  dddt        dd             | j                  ddd       | j                  ddd       | j                  d       | j                  d        | j                  d!       | j                  d"       | j                  d#       | j                  d$       | j                  d%       | j                  d&       t        j                  dd'S )(Nr  rb   Tra   rc   rt  rY   rZ   r[   rO  mixedrM  autodoc_default_optionsr  r   r  r  r  r  $autodoc_typehints_description_targetall
documenteddocumented_paramsr  r  r
  r   zfully-qualifiedr   r-  r  r4  r  rT  rt  z$sphinx.ext.autodoc.preserve_defaultszsphinx.ext.autodoc.type_commentzsphinx.ext.autodoc.typehints)versionparallel_read_safe)add_autodocumenterr  r  r  r  r  rC  r  r*  r<  add_config_valuer   	add_eventsetup_extensionsphinx__display_version__)ry   s    r/   setuprY  
  s=   +,?+./>*-../+,./-.,gtT&'SY=Z[/nj+FH2GT4Q\C]^2B=6dC/T:,k4k=&&IK?e\3FGI/T:3We/9;14>5tTBMM45MM-.MM-.MM'(MM)*>?9:6711NNr1   )r.   r   r>   r   )rO   r   r>   zobject | list[str])rO   r   r>   zobject | set[str])rO   r   r>   zset[str])rO   r   r>   r   )rO   r   r>   r   )rO   r   r>   r?   )rp   r  r>   r@   )r   N)r   r  r~   r  r   r   r>   r   )NFF)
r   r   r   zSequence[str] | Noner   r?   r   r?   r>   r   )
ry   r(   r|   r   r{   r   r   r   r>   r   )ry   r(   r>   zdict[str, Any])yrD   
__future__r   r   r  r   r   r   r   typingr   r   r   r	   docutils.statemachiner
   rW  sphinx.configr   r   sphinx.deprecationr   sphinx.ext.autodoc.importerr   r   r   sphinx.ext.autodoc.mockr   r   r   sphinx.localer   r   sphinx.pycoder   r   sphinx.utilr   sphinx.util.docstringsr   r   sphinx.util.inspectr   r   r   r   r    sphinx.util.typingr!   r"   r#   r$   collections.abcr%   r&   typesr'   sphinx.applicationr(   sphinx.environmentr)   sphinx.ext.autodoc.directiver*   	getLoggerrA   r   r   __subclasses__MethodDescriptorTyper   VERBOSEr   rY  r0   r3   rF   rK   rR   rU   r  rV  r  rP   rS   rW   r_   rd   rf   rg   ri   rs   r   r   r  r   r   r   r  r  r  r  r  r  rC  r^  r_  r  r  r  r  r  r  r  r  r
  r  r"  r*  r<  r   rY  r-   r1   r/   <module>rp     s   # 	 
  ( 8 8 ,  & 7 W W < <  5 ( G  Y X2 )3=			8	$
 D//0  

 zz BJJ|,    fX xH	@<PR 8+$< "&	%%
% % 	%
 %T	d 	3 3:e
+ e
+P]<z ]<@)J ). ):  )FN Nb2#: 2*}02G }@, *    
H9-/D H9V+/ +4 ,-/ -.%%'> %%Pu*&57Lu*pS%.0D S%l%4 %>*%( *%ZK%$; K%\/!*A /!dZ*+Z7=?U68LZ*z\5-\~-%Or1   