o
    ØÝ2g ã                   @  sx  U d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl	m
Z
mZmZ ddlZddlZddlZddlZddlZddlZddl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!m"Z"m#Z# dd
l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZN ddlOmPZQ ddlRmSZS ddlTmUZUmVZV ddlWmXZXmYZY ddlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZh ddlmiZimjZjmkZkmlZl ddlmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZw ddlxmyZy g d¢Zzde{d< g d¢Z|de{d< h d£Z}de{d< G dd„ dƒZPG dd„ dƒZ~dZde{d< dZ€de{d< d Zde{d < d!Z‚de{d!< d"Zƒde{d"< d#Z„de{d#< d$Z…de{d%< G d&d'„ d'eye† ƒZ‡d–d,d-„Zˆd—d1d2„Z‰G d3d4„ d4ejŠj‹ƒZŒd–d5d6„Zd˜d:d;„ZŽG d<d=„ d=ejjƒZ‘G d>d?„ d?e\ejŠj‹ƒZ’d™dBdC„Z“G dDdE„ dEejŠj‹ƒZ”dšdIdJ„Z•d›dMdN„Z–dœdQdR„Z—ddTdU„Z˜dždWdX„Z™dŸdYdZ„Zšd d_d`„Z›d¡dedf„Zœd¢dhdi„Zd£dmdn„Zžd¤drds„ZŸd¥dudv„Z d¦dydz„Z¡d§d}d~„Z¢dddddd€dœd¨d‰dŠ„Z£d©d‹dŒ„Z¤dZ¥dŽZ¦dªdd‘„Z§d«d¬d“d”„Z¨e©d•kr:e¨ƒ  dS dS )­a,  Generator of dynamically typed draft stubs for arbitrary modules.

The logic of this script can be split in three steps:
* parsing options and finding sources:
  - use runtime imports be default (to find also C modules)
  - or use mypy's mechanisms, if importing is prohibited
* (optionally) semantically analysing the sources using mypy (as a single set)
* emitting the stubs text:
  - for Python modules: from ASTs using ASTStubGenerator
  - for C modules using runtime introspection and (optionally) Sphinx docs

During first and third steps some problematic files can be skipped, but any
blocking error during second step will cause the whole program to stop.

Basic usage:

  $ stubgen foo.py bar.py some_directory
  => Generate out/foo.pyi, out/bar.pyi, and stubs for some_directory (recursively).

  $ stubgen -m urllib.parse
  => Generate out/urllib/parse.pyi.

  $ stubgen -p urllib
  => Generate stubs for whole urllib package (recursively).

For C modules, you can get more precise function signatures by parsing .rst (Sphinx)
documentation for extra information. For this, use the --doc-dir option:

  $ stubgen --doc-dir <DIR>/Python-3.4.2/Doc/library -m curses

Note: The generated stubs should be verified manually.

TODO:
 - maybe use .rst docs also for Python modules
 - maybe export more imported names if there is no __all__ (this affects ssl.SSLError, for example)
   - a quick and dirty heuristic would be to turn this on if a module has something like
     'from x import y as _y'
 - we don't seem to always detect properties ('closed' in 'io', for example)
é    )ÚannotationsN)ÚFinalÚIterableÚIterator)Úbuild)ÚCompileErrorÚErrors)ÚInvalidSourceListÚcreate_source_list)ÚBuildSourceÚFindModuleCacheÚModuleNotFoundReasonÚSearchPathsÚdefault_lib_path)ÚModuleInspectÚis_pyc_only)*Ú	ARG_NAMEDÚARG_POSÚARG_STARÚ	ARG_STAR2ÚIS_ABSTRACTÚNOT_ABSTRACTÚAssignmentStmtÚBlockÚ	BytesExprÚCallExprÚClassDefÚComparisonExprÚComplexExprÚ	DecoratorÚDictExprÚEllipsisExprÚ
ExpressionÚExpressionStmtÚ	FloatExprÚFuncBaseÚFuncDefÚIfStmtÚImportÚ	ImportAllÚ
ImportFromÚ	IndexExprÚIntExprÚListExprÚ
MemberExprÚMypyFileÚNameExprÚOpExprÚOverloadedFuncDefÚSetExprÚStarExprÚ	StatementÚStrExprÚTempNodeÚ	TupleExprÚTypeInfoÚ	UnaryExprÚVar)ÚOptions)ÚMAGIC_METHODS_POS_ARGS_ONLY)ÚArgSigÚFunctionSig)ÚInspectionStubGeneratorÚgenerate_stub_for_c_module)ÚTYPING_BUILTIN_REPLACEMENTSÚBaseStubGeneratorÚ
CantImportÚ	ClassInfoÚFunctionContextÚcommon_dir_prefixÚfail_missingÚfind_module_path_and_all_py3Úgenerate_guardedÚinfer_method_arg_typesÚinfer_method_ret_typeÚremove_misplaced_type_commentsÚreport_missingÚwalk_packages)Úall_yield_expressionsÚhas_return_statementÚhas_yield_expressionÚhas_yield_from_expression)
ÚOVERLOAD_NAMESÚTPDICT_NAMESÚTYPED_NAMEDTUPLE_NAMESÚAnyTypeÚCallableTypeÚInstanceÚ	TupleTypeÚTypeÚUnboundTypeÚget_proper_type)ÚNodeVisitor)ÚpackagesÚvendorÚvendoredÚ_vendorÚ_vendored_packagesr   ÚVENDOR_PACKAGES)z/six.py
z
/vendored/z/vendor/z	/_vendor/z/_vendored_packages/Ú	BLACKLIST>   Ú__eq__Ú__ge__Ú__gt__Ú__le__Ú__lt__Ú__ne__Ú__hash__Ú__iter__ÚMETHODS_WITH_RETURN_VALUEc                   @  s   e Zd ZdZddd„ZdS )r<   zPRepresents stubgen options.

    This class is mutable to simplify testing.
    Ú	pyversionútuple[int, int]Ú	no_importÚboolÚinspectÚdoc_dirÚstrÚsearch_pathú	list[str]ÚinterpreterÚ
parse_onlyÚignore_errorsÚinclude_privateÚ
output_dirÚmodulesr_   ÚfilesÚverboseÚquietÚexport_lessÚinclude_docstringsÚreturnÚNonec                 C  sp   || _ || _|| _|| _|| _|| _|| _|| _|| _|	| _	|
| _
|| _|| _|| _|| _|| _|| _|| _d S ©N)ro   rq   rs   rt   rv   rx   Údecointerpreterry   rz   r{   r|   r}   r_   r~   r   r€   r   r‚   )Úselfro   rq   rs   rt   rv   rx   ry   rz   r{   r|   r}   r_   r~   r   r€   r   r‚   © rˆ   úD/home/garg/my-data/venv/lib/python3.10/site-packages/mypy/stubgen.pyÚ__init__¸   s$   
zOptions.__init__N)$ro   rp   rq   rr   rs   rr   rt   ru   rv   rw   rx   ru   ry   rr   rz   rr   r{   rr   r|   ru   r}   rw   r_   rw   r~   rw   r   rr   r€   rr   r   rr   r‚   rr   rƒ   r„   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__rŠ   rˆ   rˆ   rˆ   r‰   r<   ²   s    r<   c                   @  sD   e Zd ZdZ	dddd„Zddd„Zeddd„ƒZeddd„ƒZdS )Ú
StubSourcez®A single source for stub: can be a Python or C module.

    A simple extension of BuildSource that also carries the AST and
    the value of __all__ detected at runtime.
    NÚmoduleru   Úpathú
str | NoneÚruntime_allúlist[str] | Nonerƒ   r„   c                 C  s   t ||d ƒ| _|| _d | _d S r…   )r   Úsourcer“   Úast)r‡   r   r‘   r“   rˆ   rˆ   r‰   rŠ   è   s   
zStubSource.__init__c                 C  s   d| j › dS )NzStubSource(ú)©r•   ©r‡   rˆ   rˆ   r‰   Ú__repr__ï   ó   zStubSource.__repr__c                 C  ó   | j jS r…   )r•   r   r™   rˆ   rˆ   r‰   r   ò   ó   zStubSource.modulec                 C  rœ   r…   )r•   r‘   r™   rˆ   rˆ   r‰   r‘   ö   r   zStubSource.path)NN)r   ru   r‘   r’   r“   r”   rƒ   r„   )rƒ   ru   )rƒ   r’   )	r‹   rŒ   r   rŽ   rŠ   rš   Úpropertyr   r‘   rˆ   rˆ   rˆ   r‰   r   á   s    ÿ
r   ÚEMPTYÚFUNCÚCLASSÚEMPTY_CLASSÚVARÚ
NOT_IN_ALLz<ERROR>ÚERROR_MARKERc                      sÌ   e Zd ZdZd>‡ fdd„Zd?dd„Zd@dd„ZdAdd„ZdBdd„ZdCdd„Z	dDdd„Z
dEdd„ZdFd!d"„ZdGd$d%„ZdHd'd(„ZdId*d+„ZdJd-d.„ZdKd0d1„ZdLd3d4„ZdMd6d7„ZdNd9d:„ZdOd<d=„Z‡  ZS )PÚAliasPrinterzVisitor used to collect type aliases _and_ type variable definitions.

    Visit r.h.s of the definition to get the string representation of type alias.
    ÚstubgenÚASTStubGeneratorrƒ   r„   c                   s   || _ tƒ  ¡  d S r…   )r§   ÚsuperrŠ   )r‡   r§   ©Ú	__class__rˆ   r‰   rŠ     s   zAliasPrinter.__init__Únoder   ru   c                 C  sÌ   |j  | ¡}g }t|j|j|jƒD ]I\}}}|tkr#| | | ¡¡ q|tkr2| d| | ¡ ¡ q|t	krA| d| | ¡ ¡ q|t
krS| |› d| | ¡› ¡ qtd|› dƒ‚|› dd |¡› dS )	NÚ*ú**ú=zUnknown argument kind z in callú(ú, r—   )ÚcalleeÚacceptÚzipÚ	arg_namesÚargsÚ	arg_kindsr   Úappendr   r   r   Ú
ValueErrorÚjoin)r‡   r¬   r²   r¶   ÚnameÚargÚkindrˆ   rˆ   r‰   Úvisit_call_expr  s   zAliasPrinter.visit_call_exprúNameExpr | MemberExprc                 C  sB   | j  |¡}|tv r| j jt| ddS t|ƒ}| j j |¡ |S )NF)Úrequire)r§   Úget_fullnamerB   Úadd_nameÚget_qualified_nameÚimport_trackerÚrequire_name)r‡   r¬   ÚfullnameÚqualnamerˆ   rˆ   r‰   Ú_visit_ref_expr&  s   zAliasPrinter._visit_ref_exprr0   c                 C  ó
   |   |¡S r…   ©rÈ   ©r‡   r¬   rˆ   rˆ   r‰   Úvisit_name_expr.  ó   
zAliasPrinter.visit_name_exprÚor.   c                 C  rÉ   r…   rÊ   ©r‡   rÎ   rˆ   rˆ   r‰   Úvisit_member_expr1  rÍ   zAliasPrinter.visit_member_exprú7StrExpr | BytesExpr | IntExpr | FloatExpr | ComplexExprc                 C  s
   t |jƒS r…   )ÚreprÚvaluerË   rˆ   rˆ   r‰   Ú_visit_literal_node4  s   
z AliasPrinter._visit_literal_noder6   c                 C  rÉ   r…   ©rÔ   rË   rˆ   rˆ   r‰   Úvisit_str_expr9  rÍ   zAliasPrinter.visit_str_exprr   c                 C  s   d|   |¡› S )NÚbrÕ   rË   rˆ   rˆ   r‰   Úvisit_bytes_expr<  ó   zAliasPrinter.visit_bytes_exprr,   c                 C  rÉ   r…   rÕ   rË   rˆ   rˆ   r‰   Úvisit_int_expr?  rÍ   zAliasPrinter.visit_int_exprr$   c                 C  rÉ   r…   rÕ   rË   rˆ   rˆ   r‰   Úvisit_float_exprB  rÍ   zAliasPrinter.visit_float_exprr   c                 C  rÉ   r…   rÕ   rË   rˆ   rˆ   r‰   Úvisit_complex_exprE  rÍ   zAliasPrinter.visit_complex_exprr+   c                   sÐ   ˆ j  |j¡}|dkr%t|jtƒrd ‡ fdd„|jjD ƒ¡S |j ˆ ¡S |dkr>t|jtƒr5ˆ j  	d¡S |j ˆ ¡› dS |j ˆ ¡}|j ˆ ¡}t
|ƒdkr`| d	¡r`| d
¡r`|dd… }|› d|› dS )Nztyping.Unionz | c                   s   g | ]}|  ˆ ¡‘qS rˆ   ©r³   )Ú.0Úitemr™   rˆ   r‰   Ú
<listcomp>L  s    z1AliasPrinter.visit_index_expr.<locals>.<listcomp>ztyping.Optionalú_typeshed.Incompleteú | Noneé   r°   r—   é   éÿÿÿÿú[ú])r§   rÁ   ÚbaseÚ
isinstanceÚindexr8   rº   Úitemsr³   rÂ   ÚlenÚ
startswithÚendswith)r‡   r¬   Úbase_fullnamerè   rê   rˆ   r™   r‰   Úvisit_index_exprH  s    zAliasPrinter.visit_index_exprr8   c                   ó"   dd  ‡ fdd„|jD ƒ¡› dS )Nr°   r±   c                 3  ó    | ]}|  ˆ ¡V  qd S r…   rÝ   ©rÞ   Únr™   rˆ   r‰   Ú	<genexpr>Y  ó   € z0AliasPrinter.visit_tuple_expr.<locals>.<genexpr>r—   ©rº   rë   rË   rˆ   r™   r‰   Úvisit_tuple_exprX  ó   "zAliasPrinter.visit_tuple_exprr-   c                   rñ   )Nræ   r±   c                 3  rò   r…   rÝ   ró   r™   rˆ   r‰   rõ   \  rö   z/AliasPrinter.visit_list_expr.<locals>.<genexpr>rç   r÷   rË   rˆ   r™   r‰   Úvisit_list_expr[  rù   zAliasPrinter.visit_list_exprr    c                 C  sT   g }|j D ]\}}t|tƒsJ ‚| | | ¡› d| | ¡› ¡ qdd |¡› dS )Nú: Ú{r±   Ú})rë   ré   r6   r¸   r³   rº   )r‡   rÎ   Ú
dict_itemsÚkeyrÓ   rˆ   rˆ   r‰   Úvisit_dict_expr^  s
   "zAliasPrinter.visit_dict_exprr!   c                 C  s   dS )Nú...rˆ   rË   rˆ   rˆ   r‰   Úvisit_ellipsisf  s   zAliasPrinter.visit_ellipsisr1   c                 C  s&   |j  | ¡› d|j› d|j | ¡› S )Nú )Úleftr³   ÚopÚrightrÏ   rˆ   rˆ   r‰   Úvisit_op_expri  s   &zAliasPrinter.visit_op_exprr4   c                 C  s   d|j  | ¡› S )Nr­   )Úexprr³   rÏ   rˆ   rˆ   r‰   Úvisit_star_exprl  ó   zAliasPrinter.visit_star_expr)r§   r¨   rƒ   r„   )r¬   r   rƒ   ru   )r¬   r¿   rƒ   ru   )r¬   r0   rƒ   ru   )rÎ   r.   rƒ   ru   )r¬   rÑ   rƒ   ru   )r¬   r6   rƒ   ru   )r¬   r   rƒ   ru   )r¬   r,   rƒ   ru   )r¬   r$   rƒ   ru   )r¬   r   rƒ   ru   )r¬   r+   rƒ   ru   )r¬   r8   rƒ   ru   )r¬   r-   rƒ   ru   )rÎ   r    rƒ   ru   )r¬   r!   rƒ   ru   )rÎ   r1   rƒ   ru   )rÎ   r4   rƒ   ru   )r‹   rŒ   r   rŽ   rŠ   r¾   rÈ   rÌ   rÐ   rÔ   rÖ   rØ   rÚ   rÛ   rÜ   rð   rø   rú   r   r  r  r	  Ú__classcell__rˆ   rˆ   rª   r‰   r¦   
  s(    















r¦   Úfiler/   rƒ   úset[str]c                 C  ó   t ƒ }|  |¡ |jS r…   )ÚDefinitionFinderr³   Únames©r  Úfinderrˆ   rˆ   r‰   Úfind_defined_namesp  ó   
r  ÚlvaluesúIterable[Expression]úIterator[str]c                 c  s>    | D ]}t |tƒr|jV  qt |tƒrt|jƒE d H  qd S r…   )ré   r0   r»   r8   Úget_assigned_namesrë   )r  Úlvaluerˆ   rˆ   r‰   r  v  s   €


€ür  c                   @  s8   e Zd ZdZddd„Zddd	„Zddd„Zddd„ZdS )r  z:Find names of things defined at the top level of a module.rƒ   r„   c                 C  ó   t ƒ | _d S r…   )Úsetr  r™   rˆ   rˆ   r‰   rŠ     ó   zDefinitionFinder.__init__rÎ   r   c                 C  ó   | j  |j¡ d S r…   ©r  Úaddr»   rÏ   rˆ   rˆ   r‰   Úvisit_class_def…  ó   z DefinitionFinder.visit_class_defr&   c                 C  r  r…   r  rÏ   rˆ   rˆ   r‰   Úvisit_func_def‰  r!  zDefinitionFinder.visit_func_defr   c                 C  s    t |jƒD ]}| j |¡ qd S r…   )r  r  r  r  )r‡   rÎ   r»   rˆ   rˆ   r‰   Úvisit_assignment_stmt  s   ÿz&DefinitionFinder.visit_assignment_stmtN©rƒ   r„   ©rÎ   r   rƒ   r„   ©rÎ   r&   rƒ   r„   ©rÎ   r   rƒ   r„   )r‹   rŒ   r   rŽ   rŠ   r   r"  r#  rˆ   rˆ   rˆ   r‰   r  ~  s    


r  c                 C  r  r…   )ÚReferenceFinderr³   Úrefsr  rˆ   rˆ   r‰   Úfind_referenced_names’  r  r*  r  r"   rr   c                 C  s   t | tƒo	| jdkS )Nr„   )ré   r0   r»   )r  rˆ   rˆ   r‰   Úis_none_expr˜  s   r+  c                      sl   e Zd ZdZddd„Zd ‡ fdd	„Zd!dd„Zd"‡ fdd„Zd#dd„Zd$dd„Z	d%dd„Z
d&dd„Z‡  ZS )'r(  z1Find all name references (both local and global).rƒ   r„   c                 C  r  r…   )r  r)  r™   rˆ   rˆ   r‰   rŠ   ¡  r  zReferenceFinder.__init__Úblockr   c                   ó   |j stƒ  |¡ d S d S r…   ©Úis_unreachabler©   Úvisit_block)r‡   r,  rª   rˆ   r‰   r0  ¥  ó   ÿzReferenceFinder.visit_blockÚer0   c                 C  r  r…   )r)  r  r»   )r‡   r2  rˆ   rˆ   r‰   rÌ   ©  r
  zReferenceFinder.visit_name_exprÚtrY   c                   s   |   |jj¡ tƒ  |¡ d S r…   )Úadd_refÚtyper»   r©   Úvisit_instance©r‡   r3  rª   rˆ   r‰   r6  ¬  s   zReferenceFinder.visit_instancer\   c                 C  s   |j r|  |j ¡ d S d S r…   )r»   r4  r7  rˆ   rˆ   r‰   Úvisit_unbound_type°  r1  z"ReferenceFinder.visit_unbound_typerZ   c                 C  s   |j D ]}| | ¡ qd S r…   )rë   r³   )r‡   r3  rß   rˆ   rˆ   r‰   Úvisit_tuple_type´  s   
ÿz ReferenceFinder.visit_tuple_typerX   c                 C  s&   |j D ]}| | ¡ q|j | ¡ d S r…   )Ú	arg_typesr³   Úret_type)r‡   r3  r¼   rˆ   rˆ   r‰   Úvisit_callable_type¹  s   
z#ReferenceFinder.visit_callable_typerÆ   ru   c                 C  s@   | j  |¡ d|v r| dd¡d }| j  |¡ d|v s
d S d S )NÚ.rä   r   )r)  r  Úrsplit)r‡   rÆ   rˆ   rˆ   r‰   r4  ¿  s
   þzReferenceFinder.add_refr$  )r,  r   rƒ   r„   )r2  r0   rƒ   r„   )r3  rY   rƒ   r„   )r3  r\   rƒ   r„   )r3  rZ   rƒ   r„   )r3  rX   rƒ   r„   )rÆ   ru   rƒ   r„   )r‹   rŒ   r   rŽ   rŠ   r0  rÌ   r6  r8  r9  r<  r4  r  rˆ   rˆ   rª   r‰   r(  œ  s    




r(  c                      sÊ  e Zd ZdZ					d…d†‡ fdd„Zd‡‡ fdd„Zdˆdd„Zd‰dd„ZdŠdd„Zd‹d!d"„Z	dŒd$d%„Z
dd&d'„ZdŽd)d*„ZdŽd+d,„Zdd0d1„Zd‡ fd3d4„Zd‘d7d8„Zd‘d9d:„Zd’d;d<„Zd“‡ fd>d?„Zd”dAdB„Zd•dDdE„Zd•dFdG„Zd–dJdK„Zd—dOdP„Zd•dQdR„Zd—dSdT„Zd˜dUdV„Zd™dšdYdZ„Zd›d[d\„Zdœ‡ fd^d_„Zddadb„Zdžddde„Z dŸdgdh„Z!	d d¡dkdl„Z"d¢dmdn„Z#d£d¤dqdr„Z$d¥dsdt„Z%d¦dvdw„Z&	Wd§d¨dzd{„Z'd©d|d}„Z(dªdd€„Z)d«‡ fdƒd„„Z*‡  Z+S )¬r¨   z#Generate stub text from a mypy AST.NFÚ_all_r”   r{   rr   Úanalyzedr   r‚   rƒ   r„   c                   sJ   t ƒ  ||||¡ g | _g g| _t| _d | _|| _tƒ | _	d| _
d| _d S ©NF)r©   rŠ   Ú_decoratorsÚ_varsrŸ   Ú_stateÚ_current_classr@  r  Úmethod_namesÚprocessing_enumÚprocessing_dataclass)r‡   r?  r{   r@  r   r‚   rª   rˆ   r‰   rŠ   É  s   
zASTStubGenerator.__init__rÎ   r/   c                   s@   |j | _|j| _|  t|ƒ¡ t|ƒ| _tƒ  |¡ |  	¡  d S r…   )
rÆ   Úmodule_namer‘   Úset_defined_namesr  r*  Úreferenced_namesr©   Úvisit_mypy_fileÚcheck_undefined_namesrÏ   rª   rˆ   r‰   rL  ß  s   
z ASTStubGenerator.visit_mypy_filer2   c                 C  s|   d}|j D ]6}t|tƒsq|  |jj|jj¡rq|  |¡ |s,|  |j¡ |jj	r+d}q|jj	r7|  |j¡ q|  
¡  qdS )zD@property with setters and getters, @overload chain and some others.FTN)rë   ré   r   Úis_private_nameÚfuncr»   rÆ   Úprocess_decoratorr"  Úis_overloadÚclear_decorators)r‡   rÎ   Úoverload_chainrß   rˆ   rˆ   r‰   Úvisit_overloaded_func_defç  s    


€
ñz*ASTStubGenerator.visit_overloaded_func_defÚfunc_defr&   ÚctxrF   r?   c                 C  s&   |   ||¡}|  ||¡}t|j||ƒS r…   )Ú_get_func_argsÚ_get_func_returnr?   r»   )r‡   rU  rV  r¶   Úretnamerˆ   rˆ   r‰   Úget_default_function_sigû  s   z)ASTStubGenerator.get_default_function_sigúlist[ArgSig]c              	   C  s¸  g }|j tv}d}t|jƒD ]Ÿ\}}|j}|j}	|j }
t|jtƒr'|jj	| nd }|dko0|
dk}|dko8|
dk}d }|rM|sM|sMtt
|ƒtƒsM|  |¡}|rV|jrV|d7 }|	 ¡ rjtdd„ |D ƒƒsj| tdƒ¡ d}|jrŒ|sy|  |jd	d
¡}|  |j¡\}}|r‹t|ƒdkr‹|}n|	tkr–d|
› }
n	|	tkrŸd|
› }
| t|
|t|jƒ|d¡ q|r¸| |tdƒ¡ |jd urÚtdd„ |D ƒƒrÚt|j |jjdd„ |D ƒƒ}|d urÚ|}|S )Nr   r‡   Úclsrä   c                 s  s    | ]	}|j  d ¡V  qdS )r­   N)r»   rí   ©rÞ   r¼   rˆ   rˆ   r‰   rõ     ó   € z2ASTStubGenerator._get_func_args.<locals>.<genexpr>r­   r  TFéÈ   r®   )ÚdefaultÚdefault_valueú/c                 s  s$    | ]}|j d u o|jdu V  qd S rA  )r5  r`  r]  rˆ   rˆ   r‰   rõ   2  s   € 
ÿc                 S  ó   g | ]}|j ‘qS rˆ   )r»   r]  rˆ   rˆ   r‰   rà   6  ó    z3ASTStubGenerator._get_func_args.<locals>.<listcomp>)r»   r=   Ú	enumerateÚ	argumentsÚvariabler½   ré   Úunanalyzed_typerX   r:  r]   rW   Úprint_annotationÚpos_onlyÚis_namedÚanyr¸   r>   ÚinitializerÚget_str_type_of_nodeÚget_str_default_of_noderì   r   r   rr   ÚinsertÚ
class_infoÚallrK   Úself_var)r‡   rÎ   rV  r¶   Úactually_pos_only_argsÚpos_only_marker_positionÚiÚarg_Úvarr½   r»   Úannotated_typeÚis_self_argÚ
is_cls_argÚtypenamer`  Úpotential_defaultÚvalidÚnew_argsrˆ   rˆ   r‰   rW     s^   

ÿý

€
ÿÿÿzASTStubGenerator._get_func_argsr’   c           
      C  sn  |j dkrt|jtƒrtt|jjƒtƒrd S |  |jj¡S |jt	ks'|j t
v r)d S t|j ƒ}|d ur4|S t|ƒs<t|ƒrª|  d¡}d}d }d }t|ƒrS|  d¡ }}nt|ƒD ]\}}	|jd urjt|jƒsj|  d¡}|	rq|  d¡}qWt|ƒr{|  d¡}|d ur“|d u r…d}|› d|› d|› d|› dS |d ur¢|› d|› d|› dS |› d|› dS t|ƒsµ|jtkrµdS d S )NrŠ   zcollections.abc.Generatorr„   rá   ræ   r±   rç   )r»   ré   rh  rX   r]   r;  rW   ri  Úabstract_statusr   rn   rL   rR   rS   rÂ   rP   r  r+  rQ   r   )
r‡   rÎ   rV  rY  Úgenerator_nameÚ
yield_nameÚ	send_nameÚreturn_namer  Úin_assignmentrˆ   rˆ   r‰   rX  =  sD   



€
z!ASTStubGenerator._get_func_returnr¬   c                 C  s:   |j j sd S |j j d }t|tƒrt|jtƒr|jjS d S )Nr   )Úbodyré   r#   r  r6   rÓ   )r‡   r¬   r  rˆ   rˆ   r‰   Ú_get_func_docstringg  s   z$ASTStubGenerator._get_func_docstringc                 C  s  | j o| jo|jj|j j}|r|jdkrd S |  |j|j¡s.|  |j¡s.|  	|j¡r4|j
s4|  ¡  d S |  ¡ rD| jttfvrD|  d¡ |  ¡ sft|ƒ}|D ]\}}|| jv rXqN|  ||¡}|re|  |¡ qN| jd ur‚t|jƒrx|jd jj}nd}t| jj|ƒ}nd }t| j|j|  |¡|jtk|d}	|  |j¡ |  ||	¡}
|   |
| j!|	¡}| j"||j#| j$|	j%dD ]	}|  |d ¡ qµ|  ¡  t| _d S )NrŠ   Ú
r   r‡   )rI  r»   Ú	docstringÚis_abstractrq  )Úis_coroutineÚ
decoratorsr‰  )&r@  rH  Úinfor  r»   Úplugin_generatedrN  rÆ   Úis_not_in_allÚis_recorded_namerQ  rR  Úis_top_levelrD  rŸ   r    r  Úfind_self_initializersrF  Úget_initrE  rì   rf  rg  rE   rF   rI  r‡  r€  r   Úrecord_namerZ  Úget_signaturesÚsig_generatorsÚformat_func_defr‹  rB  r‰  )r‡   rÎ   Úis_dataclass_generatedÚ
self_initsÚinitrÓ   Ú	init_coders  rq  rV  Údefault_sigÚsigsÚoutputrˆ   rˆ   r‰   r"  o  s^   ÿÿ
þ
ýý


€

û
ÿ
zASTStubGenerator.visit_func_defr   c                 C  s2   |   |jj|jj¡rd S |  |¡ |  |j¡ d S r…   )rN  rO  r»   rÆ   rP  r"  rÏ   rˆ   rˆ   r‰   Úvisit_decorator§  s   
z ASTStubGenerator.visit_decoratorc                 C  s0  d|j _|jD ]Ž}t|ttfƒsqt|ƒ}|  |¡}|dv r&| j|dd q|dv r6d|j _	| j|dd q|dkrF| j|dd t
|j _q|dv ry| d¡d	 }|sY| j d
¡ |tdƒd… }| j|dd | j|pmd
› ddd t
|j _q|tv r‰| j|dd d|j _q| d¡r•| j|dd qdS )zsProcess a series of decorators.

        Only preserve certain special decorators such as @abstractmethod.
        F)zbuiltins.propertyzbuiltins.staticmethodzbuiltins.classmethodzfunctools.cached_propertyT)rÅ   )zasyncio.coroutinezasyncio.coroutines.coroutineztypes.coroutinezabc.abstractmethod)zabc.abstractpropertyzabc.abstractstaticmethodzabc.abstractclassmethodr=  r   Úabczabc.abstractNz.abstractmethod)z.setterz.deleter)rO  rQ  Úoriginal_decoratorsré   r0   r.   rÃ   rÁ   Úadd_decoratorÚis_awaitable_coroutiner   r€  Ú
rpartitionrÄ   Ú
add_importrì   rT   rî   )r‡   rÎ   Ú	decoratorrÇ   rÆ   Ú
abc_moduleÚbuiltin_decorator_replacementrˆ   rˆ   r‰   rP  ­  s:   





€Úz"ASTStubGenerator.process_decoratorr  r"   ru   c                 C  sF   | j rt|ttfƒr|jrt|jtƒr|jjs|jS t|ƒ}|  	|¡S )z"Return the expression's full name.)
r@  ré   r0   r.   rÆ   r¬   r;   Úis_suppressed_importrÃ   Úresolve_name)r‡   r  r»   rˆ   rˆ   r‰   rÁ   Û  s   ÿþý
üü
zASTStubGenerator.get_fullnamer   c                   sP  || _ t|jjƒ| _d }|  ¡ r| jtkrt| j	ƒ}|  
d¡ |  |¡}|D ]}|  
| j› d|› d¡ q&|  |j¡ |  |¡}|rM|D ]}| j |¡ qD| jrW|jjrWd| _t|jttfƒro|j t| ƒ¡}| d| ¡ n| jr‹|jjr‹|jjs‹| d¡ | j d¡ | j d¡ |r–dd  |¡› d	nd
}|  
| j› d|j› |› d¡ |  !¡  | j"rÃ|j#rÃt$j% &|j#¡}	|  
| j› |	› d¡ t| j	ƒ}
| j' g ¡ t(ƒ  )|¡ |  *¡  | j' +¡  | j'd  |j¡ t| j	ƒ|
kr| jt,krü|d urüd
| j	|< | j"r|j#s| j	d d d… d | j	d< t,| _nt-| _t.ƒ | _d| _/d| _d | _ d S )Nrˆ  ú@Tz
metaclass=zmetaclass=abc.ABCMetar   r°   r±   r—   Ú úclass z:
rå   ú ...
F)0rE  Úfind_method_namesÚdefsr†  rF  r‘  rD  rŸ   rì   Ú_outputr  Úget_class_decoratorsÚ_indentr”  r»   Úget_base_typesrÄ   rÅ   r@  r  Úis_enumrG  ré   Ú	metaclassr0   r.   r³   r¦   r¸   rŠ  Úis_protocolr¥  rº   ÚindentÚ_include_docstringsr‰  ÚmypyÚutilÚquote_docstringrC  r©   r   ÚdedentÚpopr¢   r¡   r  rH  )r‡   rÎ   ÚseprŒ  ÚdÚ
base_typesrè   ÚmetaÚbasesr‰  rô   rª   rˆ   r‰   r   ç  s\   








z ASTStubGenerator.visit_class_defÚcdefrw   c              	   C  sj  g }t | ƒ}|j|j D ]†}t|ttfƒr$|  |¡dkr#| t|ƒ¡ qt|t	ƒr2| | 
|¡¡ qt|tƒr’|  |¡r||  |¡}t|jd tƒsKJ ‚|jd j}|du r^| |  d¡¡ qd dd„ |D ƒ¡}|  d¡}| |› d	|›d
|› d¡ q|  |¡rŠ| | 
|¡¡ q| |  d¡¡ q|j ¡ D ]\}	}
|	dkr¡q˜|
 
|¡p§d}| |	› d|› ¡ q˜|S )z%Get list of base classes for a class.zbuiltins.objectr   Nrá   r±   c                 s  s&    | ]\}}d |›d|› dV  qdS )r°   r±   r—   Nrˆ   )rÞ   Úfr3  rˆ   rˆ   r‰   rõ   4  s   €$ z2ASTStubGenerator.get_base_types.<locals>.<genexpr>útyping.NamedTupler°   z, [z])r¶  r  r¯   )r¦   Úbase_type_exprsÚremoved_base_type_exprsré   r0   r.   rÁ   r¸   rÃ   r+   r³   r   Úis_namedtupleÚ_get_namedtuple_fieldsr¶   r6   rÓ   rÂ   rº   Úis_typed_namedtupleÚkeywordsrë   )r‡   rÄ  rÁ  Úprè   Ú	nt_fieldsr|  Ú
fields_strÚnamedtuple_namer»   rÓ   Úprocessed_valuerˆ   rˆ   r‰   r´    s<   €






€zASTStubGenerator.get_base_typesc                 C  sL   g }t | ƒ}|jD ]}|  |¡r#| | |¡¡ | j t|ƒ¡ d| _q	|S )NT)	r¦   rŒ  Úis_dataclassr¸   r³   rÄ   rÅ   rÃ   rH  )r‡   rÄ  rŒ  rÍ  rÀ  rˆ   rˆ   r‰   r²  D  s   

€z%ASTStubGenerator.get_class_decoratorsc                 C  s   t |tƒr|j}|  |¡dkS )Nzdataclasses.dataclass)ré   r   r²   rÁ   ©r‡   r  rˆ   rˆ   r‰   rÒ  N  s   
zASTStubGenerator.is_dataclassr   c                   r-  r…   r.  rÏ   rª   rˆ   r‰   r0  S  s   ÿzASTStubGenerator.visit_blockr   c                 C  sš  g }|j D ]¼}t|tƒr>t|jtƒr>|  |j¡s|  |j¡r+|  ||j¡ | d¡ q|  	|j¡r>|  
||j¡ | d¡ qt|tƒrZ|  |j¡sZ|jsZ|  |j¡rZ|  ||j¡ qt|ttfƒrw|j}t|jtƒro|jj}nd gt|ƒ }n|g}|jg}d}d}t||ƒD ]4\}}	t|tƒr»|  |j|j|	¡}
|
r»d}|s°|  ¡ r°| jttfvr°d|
 }
d}|  |
¡ |  |j¡ q‡| |¡ qt|ƒrËt| _d S d S )NFTrˆ  )r  ré   r0   Úrvaluer   rÉ  rË  Úprocess_namedtupler¸   Úis_typeddictÚprocess_typeddictrN  r»   rh  Úis_alias_expressionÚprocess_typealiasr8   r-   rë   rZ   rì   r´   r“  r‘  rD  rŸ   r£   r  r”  rr  )r‡   rÎ   Úfoundlr  rë   r   r¿  Úfoundrß   Ú
annotationrš  rˆ   rˆ   r‰   r#  Y  sZ   


ÿ
þü
û


€
ÿz&ASTStubGenerator.visit_assignment_stmtr   c                 C  s   |   |j¡dkS )Nzcollections.namedtuple)rÁ   r²   rÓ  rˆ   rˆ   r‰   rÉ  ‰  rÙ   zASTStubGenerator.is_namedtuplec                 C  ó   |   |j¡tv S r…   )rÁ   r²   rV   rÓ  rˆ   rˆ   r‰   rË  Œ  rÙ   z$ASTStubGenerator.is_typed_namedtupleÚcallúlist[tuple[str, str]] | Nonec           	        s*  |   |¡rK|jd }t|tƒr|j dd¡ ¡ }n t|ttfƒr7g }|j	D ]}t|tƒs/ d S | 
|j¡ q%nd S |rI|  d¡‰ ‡ fdd„|D ƒS g S |  |¡r“|jd }t|ttfƒs^d S g }t| ƒ}|j	D ])}t|tƒrut|j	ƒdksx d S |j	\}}t|tƒs… d S | 
|j| |¡f¡ qg|S d S )Nrä   ú,r  rá   c                   s   g | ]}|ˆ f‘qS rˆ   rˆ   )rÞ   Ú
field_name©Ú
incompleterˆ   r‰   rà   ž  s    z;ASTStubGenerator._get_namedtuple_fields.<locals>.<listcomp>rã   )rÉ  r¶   ré   r6   rÓ   ÚreplaceÚsplitr-   r8   rë   r¸   rÂ   rË  r¦   rì   r³   )	r‡   rÞ  Ú
fields_argÚfield_namesÚfieldÚfieldsrÍ  rá  Ú
field_typerˆ   râ  r‰   rÊ    s>   




ý





z'ASTStubGenerator._get_namedtuple_fieldsr  r0   rÔ  c              	   C  sú   | j tkr
|  d¡ t|jd tƒs|  |¡ d S |  |¡}|d u r)|  |¡ d S |  d¡}| j	› d|j
› d|› d}t|ƒdkrN|  |› d¡ t| _ d S | j ttfvrZ|  d¡ |  |› d¡ |D ]\}}|  | j	› d|› d	|› d¡ qdt| _ d S )
Nrˆ  r   rÆ  r­  r°   ú):r®  ú    rû   )rD  r¡   r  ré   r¶   r6   Úannotate_as_incompleterÊ  rÂ   r³  r»   rì   r¢   rŸ   )r‡   r  rÔ  ré  rÃ  Ú	class_defÚf_nameÚf_typerˆ   rˆ   r‰   rÕ  ³  s(   







 
z#ASTStubGenerator.process_namedtuplec                 C  rÝ  r…   )rÁ   r²   rU   rÓ  rˆ   rˆ   r‰   rÖ  Í  rÙ   zASTStubGenerator.is_typeddictc              
   C  sn  | j tkr
|  d¡ t|jd tƒs|  |¡ d S g }d }t|jƒdkr||jd t	kr|t|jd t
ƒs:|  |¡ d S |jd jD ]\}}t|tƒsQ|  |¡  d S | |j|f¡ q@t|jƒdkr{|jd tkso|jd dkrv|  |¡ d S |jd }n/t|jdd … |jdd … ƒD ]\}}t|tƒsœ|  |¡  d S |dkr£|}q‹| ||f¡ q‹t| ƒ}	tdd„ |D ƒƒrÏ|  | j› |j› d| |	¡› d¡ t| _ d S |  d	¡}
|d urâ|
d
| |	¡› 7 }
| j› d|j› d|
› d}t|ƒdkr|  |› d¡ t| _ d S | j ttfvr|  d¡ |  |› d¡ |D ]\}}|  | j› d|› d| |	¡› d¡ qt| _ d S )Nrˆ  r   rä   rã   Útotalc                 s  s(    | ]\}}|  ¡  pt |¡V  qd S r…   )ÚisidentifierÚkeywordÚ	iskeyword)rÞ   rÿ   Ú_rˆ   rˆ   r‰   rõ   ò  s   €& z5ASTStubGenerator.process_typeddict.<locals>.<genexpr>ú = ztyping_extensions.TypedDictz, total=r­  r°   rë  r®  rì  rû   )rD  r¡   r  ré   r¶   r6   rí  rì   r·   r   r    rë   r¸   rÓ   r   rµ   r´   ru   r¦   rl  r³  r»   r³   r£   rÂ   r¢   rŸ   )r‡   r  rÔ  rë   rñ  Ú	attr_nameÚ	attr_typeÚarg_namer¼   rÍ  rÃ  rî  rÿ   Úkey_typerˆ   rˆ   r‰   r×  Ð  s\   







€&

$



(
z"ASTStubGenerator.process_typeddictc                 C  s2   |   d¡}|  | j› |j› d|› d¡ t| _d S )Nrá   rû   rˆ  )rÂ   r  r³  r»   r£   rD  )r‡   r  rã  rˆ   rˆ   r‰   rí    s   

z'ASTStubGenerator.annotate_as_incompleteTÚ	top_levelc                   s²  t |tƒrˆ  |j¡dv rdS t |tƒr| S t |tƒr2|jdv r#dS |jdkr+| S ˆ  |j¡ S t |tƒrSˆ j	rS|rEt |j
tttfƒpJt |j
tƒoRˆ  |j
j¡ S t |tƒr½t |jtƒreˆ  |jj¡r|t |jtƒr½ˆ  t|jƒ¡s½ˆ  |j¡ d¡r½t |jtƒr‡|jj}n|jg}|jjdkr²t|ƒdkr²|\}}t |tƒr¤|g}nt |tƒr°|j|g }ndS t‡ fd	d
„|D ƒƒS t |tƒr×|jdkr×ˆ j|jddoÖˆ j|jddS dS )z©Return True for things that look like target for an alias.

        Used to know if assignments look like type aliases, function alias,
        or module alias.
        )ztyping.TypeVarztyping_extensions.TypeVarztyping.ParamSpecztyping_extensions.ParamSpecztyping.TypeVarTupleztyping_extensions.TypeVarTupleT©ÚTrueÚFalseFr„   )z	builtins.ztyping.ztyping_extensions.zcollections.abc.ÚCallablerã   c                 3  s    | ]
}ˆ j |d dV  qdS )F©rû  N)rØ  )rÞ   rv  r™   rˆ   r‰   rõ   B  s   € z7ASTStubGenerator.is_alias_expression.<locals>.<genexpr>ú|r   ) ré   r   rÁ   r²   r!   r0   r»   rN  r.   r@  r¬   r&   r   r/   r9   Úis_private_memberrÆ   r+   rè   rÃ   rí   rê   r8   rë   rì   r-   rr  r1   r  rØ  r  r  )r‡   r  rû  Úindicesr¶   Úretrˆ   r™   r‰   rØ    sb   



ÿ
ýü

ÿÿ
ýüÿû



ÿþz$ASTStubGenerator.is_alias_expressionc                 C  sN   t | ƒ}|  | j› |j› d| |¡› d¡ |  |j¡ | jd  |j¡ d S )Nrö  rˆ  rå   )r¦   r  r³  r»   r³   r”  rC  r¸   )r‡   r  rÔ  rÍ  rˆ   rˆ   r‰   rÙ  J  s   $z"ASTStubGenerator.process_typealiasr'   c                   sh   |j d }t|tƒr,t|jd tƒr,t|jd tƒr,|jd jdkr,d|jd jv r,d S tƒ  	|¡ d S )Nr   rä   r‹   Ú__main__)
r  ré   r   Úoperandsr0   r6   r»   rÓ   r©   Úvisit_if_stmt)r‡   rÎ   r  rª   rˆ   r‰   r  P  s   
ÿþýzASTStubGenerator.visit_if_stmtr)   c                 C  s"   |   dd|j › |j› d¡ d S )Nzfrom r=  z
 import *
)Úadd_import_lineÚrelativeÚidrÏ   rˆ   rˆ   r‰   Úvisit_import_all]  rù   z!ASTStubGenerator.visit_import_allr*   c                   s.  t ƒ }g }t|j|jƒ\}}ˆ jr&tj ˆ j||ˆ j 	d¡¡\}}|s%|}n|}|dkr.d S |j
D ])\}}	|dkrBˆ  tdgƒ¡ q1ˆ  |||	d u¡rSˆ j |¡ |}	| ||	f¡ q1ˆ j d| | |¡ ˆ jd  dd„ |D ƒ¡ |D ]\}}
ˆ  |
p~|¡ quˆ jr•‡ fd	d
„|j
D ƒ}| |¡ d S d S )Nz.__init__.pyÚ
__future__Úsix)r  Nr=  rå   c                 s  s    | ]	\}}|p	|V  qd S r…   rˆ   ©rÞ   r»   Úaliasrˆ   rˆ   r‰   rõ   x  r^  z5ASTStubGenerator.visit_import_from.<locals>.<genexpr>c                   s0   g | ]\}}|ˆ j v r|d u r|ˆ jvr|‘qS r…   )r?  ÚIGNORED_DUNDERSr  r™   rˆ   r‰   rà   ~  s
    þz6ASTStubGenerator.visit_import_from.<locals>.<listcomp>)r  Útranslate_module_namer
  r	  rI  rº  r»  Úcorrect_relative_importr‘   rî   r  Úvisit_importr(   Úshould_reexportrÄ   Úreexportr¸   Úadd_import_fromrC  Úextendr”  r?  Úupdate)r‡   rÎ   Úexported_namesÚimport_namesr   r	  Úfull_moduleÚokr»   Úas_namer  r  rˆ   r™   r‰   Úvisit_import_from`  s>   ÿ€
þùz"ASTStubGenerator.visit_import_fromr(   c                 C  sX   |j D ]&\}}| j ||¡ |d u r| d¡d }n|}| jd  |¡ |  |¡ qd S )Nr=  r   rå   )ÚidsrÄ   r¥  rå  rC  r¸   r”  )r‡   rÎ   r
  Úas_idÚtarget_namerˆ   rˆ   r‰   r  …  s   ùzASTStubGenerator.visit_importrÜ  úType | Nonec                 C  s  || j d v r	dS |  |¡s|  |¡rdS | j d  |¡ |durK|  |¡}t|tƒrJ|jsJ|jdkrJ| j	j
 d¡| jv rJ|  |¡}|d|› d7 }n%| jr`|  |¡\}}| j› |› d|› dS | jrk| j› |› dS |  |¡}|  |¡}| j› |› d	|› |› dS )
zReturn initializer for a variable.

        Return None if we've generated one already or if the variable is internal.
        rå   Nr   ræ   rç   rö  rˆ  z = ...
rû   )rC  rN  r  r¸   ri  ré   r\   r¶   r»   rÄ   Ú
module_forÚgetÚTYPING_MODULE_NAMESrn  rG  ro  r³  rH  Úget_assign_initializer)r‡   r  rÔ  rÜ  r|  Ú	final_argrm  rõ  rˆ   rˆ   r‰   r“    s0   
ÿþ

€

zASTStubGenerator.get_initc                 C  sH   | j sdS | j jr| j jjrt|tƒsdS | jr"t|tƒr |js"dS dS )z5Does this rvalue need some special initializer value?r¬  z = ...)rE  r  Úis_named_tupleré   r7   rH  Úno_rhs)r‡   rÔ  rˆ   rˆ   r‰   r&  ³  s   ÿþýz'ASTStubGenerator.get_assign_initializerr»   rÅ   c                 C  s&   |r| j  |¡ | j d|› ¡ d S )Nr«  )rÄ   rÅ   rB  r¸   )r‡   r»   rÅ   rˆ   rˆ   r‰   r¢  Ç  s   zASTStubGenerator.add_decoratorc                 C  s   | j  ¡  d S r…   )rB  Úclearr™   rˆ   rˆ   r‰   rR  Ì  r›   z!ASTStubGenerator.clear_decoratorsrÆ   c                   s    |  d¡}t‡ fdd„|D ƒƒS )Nr=  c                 3  s    | ]}ˆ   |¡V  qd S r…   )rN  )rÞ   Úpartr™   rˆ   r‰   rõ   Ñ  rö   z5ASTStubGenerator.is_private_member.<locals>.<genexpr>)rå  rl  )r‡   rÆ   Úpartsrˆ   r™   r‰   r  Ï  s   
z"ASTStubGenerator.is_private_memberÚcan_infer_optionalÚ
can_be_anyc                 C  sÞ   |   |¡}t|tƒrdS t|tƒrdS t|tƒrdS t|tƒr!dS t|tƒr(dS t|tƒrF|jdv rFt|   |j	¡tƒsDt|   |j
¡tƒrFdS t|tƒrR|jdv rRdS |rft|tƒrf|jd	krf|  d
¡› dS |rm|  d
¡S dS )NÚintru   ÚbytesÚfloatÚcomplex)ú-ú+rü  rr   r„   rá   râ   r¬  )Úmaybe_unwrap_unary_exprré   r,   r6   r   r$   r   r1   r  r  r  r0   r»   rÂ   )r‡   rÔ  r-  r.  rˆ   rˆ   r‰   rn  Ó  s.   





ÿ
z%ASTStubGenerator.get_str_type_of_nodec                 C  sÈ   t |tƒs|S d}|j|v r/t |tƒr-|j|vs"t |jttttfƒs%	 |S |j}t |tƒs|S |jdkrbt |tƒr`|jdksFt |jttfƒsI	 |S t |jtƒrX|jjdvrX	 |S |j}t |tƒs9|S |S )a
  Unwrap (possibly nested) unary expressions.

        But, some unary expressions can change the type of expression.
        While we want to preserve it. For example, `~True` is `int`.
        So, we only allow a subset of unary expressions to be unwrapped.
        )r4  r3  Únotrü  )	ré   r:   r  r  r,   r$   r   r0   r»   )r‡   r  Úmath_opsrˆ   rˆ   r‰   r5  ð  s2   


ÿÿ
û

ýÿ
ûz(ASTStubGenerator.maybe_unwrap_unary_exprútuple[str, bool]c                 C  sX  t |tƒr|jdv r|jdfS dS t |ttfƒr|j› dfS t |tƒr8t |jttfƒr6|j› |jj› dfS dS t |t	ƒrDt
|jƒdfS t |tƒrVdt
|jƒ dd¡ dfS t |tƒr‹g }|jD ]}|  |¡\}}|sn dS | |¡ q`t|ƒdkr|dnd}d	d
 |¡ | }|dfS t |tƒr¶g }|jD ]}|  |¡\}}|s£ dS | |¡ q•dd
 |¡ d }|dfS t |tƒråg }|jD ]}|  |¡\}}|sÎ dS | |¡ qÀ|rãdd
 |¡ d }|dfS dS t |tƒr*g }|jD ],\}}	|du rû dS |  |¡\}
}|  |	¡\}}|r|s dS | |
› d|› ¡ qðdd
 |¡ d }|dfS dS )zŽGet a string representation of the default value of a node.

        Returns a 2-tuple of the default and whether or not it is valid.
        )r„   rý  rþ  Tr×   z\\ú\rä   z,)r—   r°   r±   ræ   rç   rü   rý   Nrû   )r  F)ré   r0   r»   r,   r$   rÓ   r:   r  r  r6   rÒ   r   rä  r8   rë   ro  r¸   rì   rº   r-   r3   r    )r‡   rÔ  Úitems_defaultsr2  Ú	e_defaultr~  Úclosingr`  ÚkÚvÚ	k_defaultÚk_validÚ	v_defaultÚv_validrˆ   rˆ   r‰   ro    s|   


7Ê
2
Ï


(Ù

ä

îó	øüz(ASTStubGenerator.get_str_default_of_noder  Úname_is_aliasc                   sX   |   ||d | ¡}|s$|| jvr$| jr|| jv r$|s$|d| j vr$dS tƒ  |||¡S )Nr=  )r   ÚasyncioT)rN  rK  r?  r  r%  r©   r  )r‡   r»   r  rC  Ú
is_privaterª   rˆ   r‰   r  R  s   ÿ
ÿ
ÿz ASTStubGenerator.should_reexport)NFFFF)r?  r”   r{   rr   r@  rr   r   rr   r‚   rr   rƒ   r„   )rÎ   r/   rƒ   r„   )rÎ   r2   rƒ   r„   )rU  r&   rV  rF   rƒ   r?   )rÎ   r&   rV  rF   rƒ   r[  )rÎ   r&   rV  rF   rƒ   r’   )r¬   r&   rƒ   r’   r&  )rÎ   r   rƒ   r„   )r  r"   rƒ   ru   r%  )rÄ  r   rƒ   rw   ©r  r"   rƒ   rr   )rÎ   r   rƒ   r„   r'  )r  r   rƒ   rr   )rÞ  r   rƒ   rß  )r  r0   rÔ  r   rƒ   r„   )r  r0   rƒ   r„   )T)r  r"   rû  rr   rƒ   rr   )r  r0   rÔ  r"   rƒ   r„   )rÎ   r'   rƒ   r„   )rÎ   r)   rƒ   r„   )rÎ   r*   rƒ   r„   )rÎ   r(   rƒ   r„   r…   )r  ru   rÔ  r"   rÜ  r"  rƒ   r’   )rÔ  r"   rƒ   ru   )F)r»   ru   rÅ   rr   rƒ   r„   r$  )rÆ   ru   rƒ   rr   )FT)rÔ  r"   r-  rr   r.  rr   rƒ   ru   )r  r"   rƒ   r"   )rÔ  r"   rƒ   r8  )r»   ru   r  ru   rC  rr   rƒ   rr   ),r‹   rŒ   r   rŽ   rŠ   rL  rT  rZ  rW  rX  r‡  r"  rŸ  rP  rÁ   r   r´  r²  rÒ  r0  r#  rÉ  rË  rÊ  rÕ  rÖ  r×  rí  rØ  rÙ  r  r  r  r  r“  r&  r¢  rR  r  rn  r5  ro  r  r  rˆ   rˆ   rª   r‰   r¨   Æ  s`    ú



=
*

8

.
1
,



0


$


7
>


%ÿ
$

ÿ

"@r¨   r°  úlist[Statement]c                 C  sl   t ƒ }| D ].}t|tƒr| |j¡ qt|tƒr | |jj¡ qt|tƒr3|jD ]
}| 	t
|gƒ¡ q(q|S r…   )r  ré   r&   r  r»   r   rO  r2   rë   r  r¯  )r°  ÚresultÚdefnrß   rˆ   rˆ   r‰   r¯  b  s   



€r¯  c                   @  s    e Zd Zd
dd„Zddd„Zd	S )ÚSelfTraverserrƒ   r„   c                 C  s
   g | _ d S r…   )Úresultsr™   rˆ   rˆ   r‰   rŠ   q  rÍ   zSelfTraverser.__init__rÎ   r   c                 C  sP   |j d }t|tƒr"t|jtƒr$|jjdkr&| j |j|jf¡ d S d S d S d S )Nr   r‡   )	r  ré   r.   r  r0   r»   rK  r¸   rÔ  )r‡   rÎ   r  rˆ   rˆ   r‰   r#  t  s   
ÿ
þûz#SelfTraverser.visit_assignment_stmtNr$  r'  )r‹   rŒ   r   rŠ   r#  rˆ   rˆ   rˆ   r‰   rJ  p  s    
rJ  Úfdefr%   úlist[tuple[str, Expression]]c                 C  r  )znFind attribute initializers in a method.

    Return a list of pairs (attribute name, r.h.s. expression).
    )rJ  r³   rK  )rL  Ú	traverserrˆ   rˆ   r‰   r’  ~  s   
r’  rÎ   ru   c                 C  s4   t | tƒr| jS t | tƒrt| jƒ› d| j› S tS )Nr=  )ré   r0   r»   r.   rÃ   r  r¥   )rÎ   rˆ   rˆ   r‰   rÃ   ˆ  s
   

rÃ   r}   úlist[StubSource]c                 C  s   dd„ | D ƒS )Nc                 S  s$   g | ]}|j d u st|j ƒs|‘qS r…   )r‘   Úis_blacklisted_path©rÞ   r   rˆ   rˆ   r‰   rà   ’  s    z.remove_blacklisted_modules.<locals>.<listcomp>rˆ   )r}   rˆ   rˆ   r‰   Úremove_blacklisted_modules‘  s   ÿrR  ú)tuple[list[StubSource], list[StubSource]]c                 C  s:   g }g }| D ]}t |jƒr| |¡ q| |¡ q||fS r…   )r   r‘   r¸   )r}   Ú
py_modulesÚpyc_modulesÚmodrˆ   rˆ   r‰   Úsplit_pyc_from_py—  s   
rW  r‘   c                   s   t ‡ fdd„tD ƒƒS )Nc                 3  s     | ]}|t ˆ ƒd  v V  qdS )rˆ  N)Únormalize_path_separators)rÞ   Úsubstr©r‘   rˆ   r‰   rõ   £  s   € z&is_blacklisted_path.<locals>.<genexpr>)rl  re   rZ  rˆ   rZ  r‰   rP  ¢  s   rP  c                 C  s   t jdkr|  dd¡S | S )NÚwin32r9  rb  )ÚsysÚplatformrä  rZ  rˆ   rˆ   r‰   rX  ¦  s   
rX  ÚoptionsÚ	mypy_optsÚMypyOptionsú;tuple[list[StubSource], list[StubSource], list[StubSource]]c              
   C  s²   | j s| jr%| jrt| j| j | j| jƒ}g }n3t| j| j | j| jƒ\}}n%zt	| j
|ƒ}W n ty@ } ztt|ƒƒ|‚d}~ww dd„ |D ƒ}g }t|ƒ}t|ƒ\}}|||fS )zsCollect files for which we need to generate stubs.

    Return list of py modules, pyc modules, and C modules.
    Nc                 S  ó   g | ]	}t |j|jƒ‘qS rˆ   ©r   r   r‘   ©rÞ   Úmrˆ   rˆ   r‰   rà   Ä  ó    z)collect_build_targets.<locals>.<listcomp>)r_   r}   rq   Úfind_module_paths_using_searchrv   ro   Úfind_module_paths_using_importsr   r€   r
   r~   r	   Ú
SystemExitru   rR  rW  )r^  r_  rT  Ú	c_modulesÚsource_listr2  Úpyc_modÚpy_modrˆ   rˆ   r‰   Úcollect_build_targets¬  s(   ÿ
ÿ€ÿ
rn  rw   r_   r   r€   c                 C  sø   t ƒ o}g }g }tt|||ƒƒ}| | } dd„ | D ƒ} | D ]I}zt|||ƒ}	W n' tyN }
 zt ¡ }|r;tj 	|¡ |sDt
||
j|ƒ W Y d}
~
qd}
~
ww |	sY| t|ƒ¡ q|	\}}| t|||ƒ¡ q||fW  d  ƒ S 1 suw   Y  dS )zšFind path and runtime value of __all__ (if possible) for modules and packages.

    This function uses runtime Python imports to get the information.
    c                 S  s   g | ]}t |ƒs|‘qS rˆ   )Úis_non_library_module)rÞ   rV  rˆ   rˆ   r‰   rà   Ø  s
    ÿÿz3find_module_paths_using_imports.<locals>.<listcomp>N)r   ÚlistrO   rI   rD   Ú	tracebackÚ
format_excr\  ÚstdoutÚwriterN   Úmessager¸   r   )r}   r_   r   r€   rs   rT  rj  rÛ  rV  rH  r2  Útbr‘   r“   rˆ   rˆ   r‰   rh  Ì  s4   ÿ€ú$érh  r   c                 C  sN   |   d¡rdS |  d¡d  d¡rdS d| v s#d| v s#d| v s#d	| v r%dS d
S )z0Does module look like a test module or a script?)z.testsz.testz.testingÚ_testsÚ_test_suiteÚ	test_utilÚ
test_utilsÚ	test_basez	.__main__z	.conftestz.setupTr=  rå   Útest_z.tests.z.test.z	.testing.z
.SelfTest.F)rî   rå  rí   ©r   rˆ   rˆ   r‰   ro  í  s   ÿro  r	  r/  útuple[str, int]c                 C  sŽ   t D ]@}dD ];}|› d|› }|  d| ¡s| |kr$|r$|df    S d| d | v rA|d |  d| d ¡d  df    S qq| |fS )N)z	six.movesr  r=  r   rã   )rd   rî   Ú	partition)r   r	  ÚpkgÚaltrY  rˆ   rˆ   r‰   r    s   *ÿür  rv   ro   rp   c                 C  sÎ   g }t tj ¡ |dƒ}tdt|ƒ ddt|ƒƒ}t|ddd}| D ]}| |¡}	t|	t	ƒr5t
||	ƒ d}
n|	}
| t||
ƒ¡ q!|D ]}| |¡}|rQt
|t	jƒ dd„ |D ƒ}| |¡ qBdd„ |D ƒ}|S )a  Find sources for modules and packages requested.

    This function just looks for source files at the file system level.
    This is used if user passes --no-import, and will not find C modules.
    Exit if some of the modules or packages can't be found.
    N)r=  rˆ   )Úfscacher^  c                 S  rb  rˆ   rc  rd  rˆ   rˆ   r‰   rà   /  rf  z2find_module_paths_using_search.<locals>.<listcomp>c                 S  s   g | ]	}t |jƒs|‘qS rˆ   )ro  r   rd  rˆ   rˆ   r‰   rà   2  rf  )r   rº  r   Údefault_data_dirr   Útupler   Úfind_moduleré   r   rH   r¸   r   Úfind_modules_recursiveÚ	NOT_FOUNDr  )r}   r_   rv   ro   rH  Útypeshed_pathÚsearch_pathsÚcacher   Úm_resultÚmodule_pathÚpackageÚp_resultÚsourcesrˆ   rˆ   r‰   rg    s&   	



rg  Ústubgen_optionsc                 C  sn   t ƒ }d|_d|_d|_d|_| j|_d|_t|_	d|_
| j|_t dd¡}| ¡ r-||_tj |j¡|_|S )z4Generate mypy options using the flag passed by user.ÚskipFTÚMYPY_CACHE_DIRr¬  )r`  Úfollow_importsÚincrementalrz   Úsemantic_analysis_onlyro   Úpython_versionÚshow_tracebackrM   Útransform_sourceÚpreserve_astsr‚   ÚosÚgetenvÚstripÚ	cache_dirr‘   Ú
expanduser)r  r^  Úenviron_cache_dirrˆ   rˆ   r‰   Úmypy_options7  s   r   rV  r„   c                 C  sº   | j dus	J dƒ‚t| j dƒ}| ¡ }W d  ƒ n1 sw   Y  tj |¡}t|ƒ}tjj|| j | j||d| _	| j| j	_
| ¡ r[| ¡ D ]}tj |› d¡ qHt d¡ dS dS )zœParse a source file.

    On success, store AST in the corresponding attribute of the stub source.
    If there are syntax errors, print them and exit.
    Nú Not found module was not skippedÚrb)Úfnamr   Úerrorsr^  rˆ  rä   )r‘   ÚopenÚreadrº  r»  Údecode_python_encodingr   Úparser   r–   Ú	_fullnameÚis_blockersÚnew_messagesr\  Ústderrrt  Úexit)rV  r   rÅ  Údatar•   r¤  re  rˆ   rˆ   r‰   Úparse_source_fileM  s   
ÿÿ
ür¯  rT  ry   c              
   C  s¸   | sdS |rt dt| ƒ› dƒ |r| D ]}t||ƒ qdS ztdd„ | D ƒ|ƒ}W n ty> } ztd|› ƒ|‚d}~ww | D ]}|j|j j|_	|j
du rY|jjj|j |_
qAdS )z8Use mypy to parse (and optionally analyze) source files.NzProcessing z	 files...c                 S  rc  rˆ   r˜   rQ  rˆ   rˆ   r‰   rà   q  rd  z-generate_asts_for_modules.<locals>.<listcomp>z)Critical error during semantic analysis: )Úprintrì   r¯  r   r   ri  Úgraphr   Útreer–   r“   ÚmanagerÚsemantic_analyzerÚ
export_map)rT  ry   r   r   rV  Úresr2  rˆ   rˆ   r‰   Úgenerate_asts_for_modulesc  s(   €ÿ
€ür·  Fr¬  )ry   rs   r{   r   r‚   rt   Útargetrs   r{   r   r‚   rt   Úall_modulesc             	   C  sÐ   |rt | j|| j||||d}	|	 ¡  |	 ¡ }
nt| j|| ||d}| jdus,J dƒ‚| j |¡ | ¡ }
tj	 
|¡}|rItj	 |¡sIt |¡ t|ddd}| |
¡ W d  ƒ dS 1 saw   Y  dS )z°Use analysed (or just parsed) AST to generate type stub for single file.

    If directory for target doesn't exist it will created. Existing stub
    will be overwritten.
    )rI  Úknown_modulesr?  rt   r{   r   r‚   )r{   r@  r   r‚   Nz5This function must be used only with analyzed modulesÚwzutf-8)Úencoding)r@   r   r“   Úgenerate_modulerž  r¨   r–   r³   rš  r‘   ÚdirnameÚisdirÚmakedirsr¥  rt  )rV  r¸  ry   rs   r{   r   r‚   rt   r¹  Úngenrž  ÚgenÚsubdirr  rˆ   rˆ   r‰   Úgenerate_stub_for_py_module|  s8   ù	
û
"ÿrÄ  c           
        s<  t | ƒ}t| |ƒ\}}}|| | }tdd„ |D ƒƒ}t|| j|| jƒ g }|| D ]b‰ ˆ jdus5J dƒ‚ˆ j dd¡}t	j 
ˆ j¡dv rJ|d7 }n|d	7 }t	j | j|¡}| |¡ tˆ j|| j| jƒ tˆ || j| jpqˆ |v | j| j| j| j|d
	 W d  ƒ n1 s‡w   Y  q*|D ]W‰ t‡ fdd„|D ƒƒr¦ˆ j dd¡d }n	ˆ j dd¡d	 }t	j | j|¡}| |¡ tˆ j|| j| jƒ tˆ j||| j| j| j| jd W d  ƒ n1 sáw   Y  qt|ƒ}	| js|	dkrtd|	 ƒ t|ƒdkrtd|d › ƒ dS tdt|ƒ› t	j ƒ dS dS dS )z!Main entry point for the program.c                 s  s    | ]}|j V  qd S r…   r}  rd  rˆ   rˆ   r‰   rõ   ³  s   € z!generate_stubs.<locals>.<genexpr>Nr¡  r=  rb  )z__init__.pyz__init__.pycz/__init__.pyiz.pyi)ry   rs   r{   r   r‚   rt   r¹  c                 3  s"    | ]}|j  ˆ j d  ¡V  qdS )r=  N)r   rí   )rÞ   rm  ©rV  rˆ   r‰   rõ   Ï  s   €  )rº  rt   r{   r   r‚   r   zProcessed %d modulesrä   z
Generated zGenerated files under )r   rn  Úsortedr·  ry   r   r‘   r   rä  rš  Úbasenamerº   r|   r¸   rJ   rz   rÄ  rs   r{   r   r‚   rt   rl  rA   rì   r€   r°  rG   r¿  )
r^  r_  rT  rU  rj  r¹  Úall_module_namesr~   r¸  Únum_modulesrˆ   rÅ  r‰   Úgenerate_stubs®  sj   

÷ÿ€
ùÿ€
ûrÊ  z^%(prog)s [-h] [more options, see -h]
                     [-m MODULE] [-p PACKAGE] [files ...]z 
Generate draft stubs for modules.

Stubs are generated in directory ./out, to avoid overriding files with
manual changes.  This directory is assumed to exist.
r¶   c              	   C  sL  t jdttd}|jdddd |jdddd |jd	d
dddd |jddddd |jdddd |jdddd |jdddd |jddddd |jddddd |jdddd d! |jd"ddd#d! |jd$d%dd&d'd(d) |jd*d+d,d-d.g d/d0 |jd1d2d,d3d4g d5d0 |jd6d7d6d8d9 |jd:d;d<tjj d= | | ¡}t	j
d d>… }t	j|_|j|j r½|jr½| d?¡ |jrÈ|jrÈ| d@¡ |jrÓ|jrÓ| dA¡ tj|jdBdC tdPi dD|“dE|j“d|j“dF|j“dG|j dH¡“dI|j“dJ|j“d|j“dK|j“d&|j“d.|j“d4|j“d6|j“dL|j“dM|j“dN|j“dO|j “ŽS )QNr§   )ÚprogÚusageÚdescriptionz--ignore-errorsÚ
store_truez7ignore errors when trying to generate stubs for modules)ÚactionÚhelpz--no-importz{don't import the modules, just parse and analyze them (doesn't work with C extension modules and might not respect __all__)z--no-analysisz--parse-onlyry   zŸdon't perform semantic analysis of sources, just parse them (only applies to Python modules, might affect quality of stubs. Not compatible with --inspect-mode))ÚdestrÏ  rÐ  z--inspect-moders   zÍimport and inspect modules instead of parsing source code.This is the default behavior for c modules and pyc-only packages, but it is also useful for pure python modules with dynamically generated members.z--include-privatezqgenerate stubs for objects and members considered private (single leading underscore and no trailing underscores)z--export-lesszQdon't implicitly export all names imported from other modules in the same packagez--include-docstringsz*include existing docstrings with the stubsz-vz	--verbosezshow more verbose messagesz-qz--quietzshow fewer messagesz	--doc-dirÚPATHr¬  z…use .rst documentation in PATH (this may result in better stubs in some cases; consider setting this to DIR/Python-X.Y.Z/Doc/library))Úmetavarr`  rÐ  z--search-pathzaspecify module search directories, separated by ':' (currently only used if --no-import is given)z-oz--outputr|   Úoutz2change the output directory [default: %(default)s])rÓ  rÑ  r`  rÐ  z-mz--moduler¸   ÚMODULEr}   z5generate stub for module; can repeat for more modules)rÏ  rÓ  rÑ  r`  rÐ  z-pz	--packageÚPACKAGEr_   z7generate stubs for package recursively; can be repeatedr~   r­   z-generate stubs for given files or directories)rÓ  ÚnargsrÑ  rÐ  z	--versionÚversionz	%(prog)s )rÏ  rØ  rã   z3May only specify one of: modules/packages or files.z.Cannot specify both quiet and verbose messageszACannot specify both --parse-only/--no-analysis and --inspect-modeT)Úexist_okro   rq   rt   rv   ú:rx   rz   r{   r   r€   r   r‚   rˆ   )!ÚargparseÚArgumentParserÚHEADERÚDESCRIPTIONÚadd_argumentrº  rØ  Ú__version__Ú
parse_argsr\  Úversion_infoÚ
executablerx   r}   r_   r~   Úerrorr€   r   rs   ry   rš  rÀ  r|   r<   rq   rt   rv   rå  rz   r{   r   r‚   )r¶   ÚparserÚnsro   rˆ   rˆ   r‰   Úparse_optionsó  s
  ýýû	üýýýüüúù	ù	üÿ



ÿþýüûúùø	÷
öõôóòñðïrç  r”   c                 C  sX   t j d¡ dtjv sdtjv stj dd¡ t| d u r#tjdd … n| ƒ}t|ƒ d S )Nr§   r¬  r=  r   rä   )	rº  r»  Úcheck_python_versionr\  r‘   rp  rç  ÚargvrÊ  )r¶   r^  rˆ   rˆ   r‰   Úmain|  s
   rê  r  )r  r/   rƒ   r  )r  r  rƒ   r  rF  )r°  rG  rƒ   r  )rL  r%   rƒ   rM  )rÎ   r"   rƒ   ru   )r}   rO  rƒ   rO  )r}   rO  rƒ   rS  )r‘   ru   rƒ   rr   )r‘   ru   rƒ   ru   )r^  r<   r_  r`  rƒ   ra  )
r}   rw   r_   rw   r   rr   r€   rr   rƒ   rS  )r   ru   rƒ   rr   )r   ru   r	  r/  rƒ   r~  )
r}   rw   r_   rw   rv   rw   ro   rp   rƒ   rO  )r  r<   rƒ   r`  )rV  r   r   r`  rƒ   r„   )
rT  rO  ry   rr   r   r`  r   rr   rƒ   r„   )rV  r   r¸  ru   ry   rr   rs   rr   r{   rr   r   rr   r‚   rr   rt   ru   r¹  rw   rƒ   r„   )r^  r<   rƒ   r„   )r¶   rw   rƒ   r<   r…   )r¶   r”   rƒ   r„   )ªrŽ   r  r   rÛ  ró  rš  Úos.pathr\  rq  Útypingr   r   r   Ú
mypy.buildrº  Úmypy.mixedtraverserÚ
mypy.parseÚmypy.traverserÚ	mypy.utilÚmypy.versionr   Úmypy.errorsr   r   Úmypy.find_sourcesr	   r
   Úmypy.modulefinderr   r   r   r   r   Úmypy.moduleinspectr   r   Ú
mypy.nodesr   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   Úmypy.optionsr<   r`  Úmypy.sharedparser=   Úmypy.stubdocr>   r?   Úmypy.stubgencr@   rA   Úmypy.stubutilrB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   Ú
mypy.typesrT   rU   rV   rW   rX   rY   rZ   r[   r\   r]   Úmypy.visitorr^   rd   Ú__annotations__re   rn   r   rŸ   r    r¡   r¢   r£   r¤   r¥   ru   r¦   r  r  rN  ÚTraverserVisitorr  r*  r+  ÚmixedtraverserÚMixedTraverserVisitorr(  r¨   r¯  rJ  r’  rÃ   rR  rW  rP  rX  rn  rh  ro  r  rg  r   r¯  r·  rÄ  rÊ  rÝ  rÞ  rç  rê  r‹   rˆ   rˆ   rˆ   r‰   Ú<module>   s°   (°,@0	/
f


*       
#



	




 
!


!

÷
2:
 


ÿ