V]c@svdZddlZddlZddlZddlZddlmZddlmZm Z m Z ddl m Z ddl mZddl mZddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZmZddlmZddlm Z ddlm!Z!ddl"m#Z#ddl$m%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8ej9dde:fdYZ;d e;fd!YZ<e=e=d"e>e?e>e=d#Z@d$ZAejBe?e?e?d%ZCdS(&s The API basically only provides one class. You can create a :class:`Script` and use its methods. Additionally you can add a debug function with :func:`set_debug_function`. Alternatively, if you don't need a custom function and are happy with printing debug messages to stdout, simply call :func:`set_debug_function` without arguments. .. warning:: Please, note that Jedi is **not thread safe**. iN(ttree(t force_unicodet cast_pathtis_py3(tget_executable_nodes(tdebug(tsettings(tcache(tKnownContentFileIO(tclasses(t interpreter(thelpers(t Completion(tInterpreterEnvironment(tget_default_projecttProject(t Evaluator(timports(tusages(ttry_iter_content(tget_module_namestevaluate_call_of_leaf(ttransform_path_to_dotted(tTreeNameDefinitiont ParamName(ttree_name_to_contexts(t ModuleContext(t ContextSet(tunpack_tuple_to_dict(t convert_namestconvert_contexts(tload_proper_stub_modulei tScriptc BseZdZd d d d dd d d dZejdZdZdZ dZ e e dZ e e dZ e e d Zdd Zd Zd ZRS(s A Script is the base for completions, goto or whatever you want to do with |jedi|. You can either use the ``source`` parameter or ``path`` to read a file. Usually you're going to want to use both of them (in an editor). The script might be analyzed in a different ``sys.path`` than |jedi|: - if `sys_path` parameter is not ``None``, it will be used as ``sys.path`` for the script; - if `sys_path` parameter is ``None`` and ``VIRTUAL_ENV`` environment variable is defined, ``sys.path`` for the specified environment will be guessed (see :func:`jedi.evaluate.sys_path.get_venv_path`) and used for the script; - otherwise ``sys.path`` will match that of |jedi|. :param source: The source code of the current file, separated by newlines. :type source: str :param line: The line to perform actions on (starting with 1). :type line: int :param column: The column of the cursor (starting with 0). :type column: int :param path: The path of the file in the file system, or ``''`` if it hasn't been saved yet. :type path: str or None :param encoding: The encoding of ``source``, if it is not a ``unicode`` object (default ``'utf-8'``). :type encoding: str :param sys_path: ``sys.path`` to use during analysis of the script :type sys_path: list :param environment: TODO :type environment: Environment sutf-8c Cs||_|r!tjj|nd|_|dkr]t|d} | j}WdQXntj|_ |dk rt rt t t |}n|} | dkrt|rtjj|jn tj} n|dk r|| _nt| d|d|j|_tjd|jjd|d|jd|d|oO|jd d td tjd tj\|_}tjd tj|dt|_||_ |dkrt!t"|jdn|}d|kot"|jknst#dn|j|d} t"| } | jdr;| d8} n| jdrW| d8} n|dkri| n|}d|ko| knst#d|| || fn||f|_$t%j&tj'dS(Ntrbt environmentt script_pathtinittcodetpathtencodingtuse_latest_grammars.pyiRt diff_cachet cache_pathtparsedtkeependsiis)`line` parameter is not in a valid range.s s sH`column` parameter (%d) is not in a valid range (0-%d) for line %d (%r).((t _orig_pathtosR&tabspathtNonetopentreadtparsot load_grammart_grammarRtlisttmapRRtdirnametgetcwdt _sys_pathRt _evaluatorRtspeedtparse_and_get_codetendswithtFalseRt fast_parsertcache_directoryt _module_nodet split_linestTruet _code_linest_codetmaxtlent ValueErrort_posRtclear_time_cachest reset_time( tselftsourcetlinetcolumnR&R'tsys_pathR"t_projecttftprojectt line_stringtline_len((s0lib/python2.7/site-packages/jedi/api/__init__.pyt__init__WsX !  -        *%    c CsZd}t}|jdk r`t|jjdt|j\}}|dk r`|}|}q`n|jdkrxd}ntt|j|j}|jdk r|jj drt |j|||j }|dk r|Sn|dkrd }nt |j|j |d|d|j d|}|dd krV|jjj|t|gn|S( Ntadd_parent_pathss.pyit__main__t string_namest code_linest is_packageitbuiltinst __builtin__ttyping(RY(R]R^R_(R0R?R&RR;t get_sys_pathRRRFR>RRBRREt module_cachetaddR(RMtnamesR\t import_namestis_ptfile_iot stub_moduletmodule((s0lib/python2.7/site-packages/jedi/api/__init__.pyt _get_modules<   !      "cCs&d|jjt|j|jjfS(Ns <%s: %s %r>(t __class__t__name__treprR-R;R"(RM((s0lib/python2.7/site-packages/jedi/api/__init__.pyt__repr__s  c CsNtjd9t|j|j|j|j|j}|jSWdQXdS(s Return :class:`classes.Completion` objects. Those objects contain information about the completions, more than just names. :return: Completion objects, sorted by name and __ comes last. :rtype: list of :class:`classes.Completion` t completionsN( Rtincrease_indent_cmR R;RiRERJtcall_signaturesRn(RMt completion((s0lib/python2.7/site-packages/jedi/api/__init__.pyRns cKs'tjd|j|SWdQXdS(s Return the definitions of a the path under the cursor. goto function! This follows complicated paths and returns the end, not the first definition. The big difference between :meth:`goto_assignments` and :meth:`goto_definitions` is that :meth:`goto_assignments` doesn't follow imports and statements. Multiple objects may be returned, because Python itself is a dynamic language, which means depending on an option you can have two different versions of a function. :param only_stubs: Only return stubs for this goto call. :param prefer_stubs: Prefer stubs to Python objects for this type inference call. :rtype: list of :class:`classes.Definition` tgoto_definitionsN(RRot_goto_definitions(RMtkwargs((s0lib/python2.7/site-packages/jedi/api/__init__.pyRrscCs|jj|j}|dkrI|jj|j}|dkrIgSn|jj|j|}tj |j||}t |d|d|}g|D]}t j |j|j ^q}tjt|S(Nt only_stubst prefer_stubs(RBtget_name_of_positionRJR0tget_leaf_for_positionR;tcreate_contextRiR tevaluate_goto_definitionRR t Definitiontnametsorted_definitionstset(RMRuRvtleaftcontexttcontextstctdefs((s0lib/python2.7/site-packages/jedi/api/__init__.pyRss   +cKs-tjd|j|||SWdQXdS(s4 Return the first definition found, while optionally following imports. Multiple objects may be returned, because Python itself is a dynamic language, which means depending on an option you can have two different versions of a function. .. note:: It is deprecated to use follow_imports and follow_builtin_imports as positional arguments. Will be a keyword argument in 0.16.0. :param follow_imports: The goto call will follow imports. :param follow_builtin_imports: If follow_imports is True will decide if it follow builtin imports. :param only_stubs: Only return stubs for this goto call. :param prefer_stubs: Prefer stubs to Python objects for this goto call. :rtype: list of :class:`classes.Definition` tgoto_assignmentsN(RRot_goto_assignments(RMtfollow_importstfollow_builtin_importsRt((s0lib/python2.7/site-packages/jedi/api/__init__.pyRsc sfd|jj|j}|dkrI|jd|d|S|jj|j|}t|jj ||}|r|d}nt |d|d|}gt |D]}t j |j|^q} tj| S(Nc3sx|D]}||rt|j|}t}rlx)|D]}|jdkrGt}qGqGWn|rz|Vqx|D] }|VqWq|VqWdS(N(R6tgotoR?t start_posR0RD(RctcheckR|t new_namest found_builtintnew_name(tfilter_follow_importsR(s0lib/python2.7/site-packages/jedi/api/__init__.pyRs     RuRvcSs |jS(N(t is_import(R|((s0lib/python2.7/site-packages/jedi/api/__init__.pyt2t(RBRwRJR0RrR;RyRiR6RRR~R R{R R}( RMRRRuRvt tree_nameRRctdR((RRs0lib/python2.7/site-packages/jedi/api/__init__.pyRs  .c s;|rtjdtddntfd}||S(s< Return :class:`classes.Definition` objects, which contain all names that point to the definition of the name under the cursor. This is very useful for refactoring (renaming), or to show all usages of a variable. .. todo:: Implement additional_module_paths :param additional_module_paths: Deprecated, never ever worked. :param include_builtins: Default True, checks if a usage is a builtin (e.g. ``sys``) and in that case does not return it. :rtype: list of :class:`classes.Definition` sHDeprecated since version 0.12.0. This never even worked, just ignore it.t stacklevelicsjjj}|dkr%gStjj|}g|D]}tjj|^qD}|sg|D]}|j sr|^qr}nt j |S(N( RBRwRJR0RRiR R{R;tin_builtin_moduleR R}(tinclude_builtinsRRctnt definitionsR(RM(s0lib/python2.7/site-packages/jedi/api/__init__.pyt_usagesQs (((twarningstwarntDeprecationWarningRD(RMtadditional_module_pathsRtR((RMs0lib/python2.7/site-packages/jedi/api/__init__.pyR<s  cCstj|j|j}|dkr(gS|jj|j|j}tj |j||j|j |j}t j dg|j D]}tj|j||^qS(sh Return the function object of the call you're currently in. E.g. if the cursor is here:: abs(# <-- cursor is here This would return the ``abs`` function. On the other hand:: abs()# <-- cursor is here This would return an empty list.. :rtype: list of :class:`classes.CallSignature` sfunc_call followedN(R tget_call_signature_detailsRBRJR0R;RyRit bracket_leaftcache_call_signaturesRERR<tget_signaturesR t CallSignature(RMt call_detailsRRt signature((s0lib/python2.7/site-packages/jedi/api/__init__.pyRp_s      c Cst|j_|jg|j_|j}zxht|jD]W}|j|}|jd kr~t |j||j dn t |t j rt|j}|jr|td|jDO}nx|D]}tj||qWn|jdkrG|j|}xq|j dddD]}t|||q*Wn@|jdkrn|jj||}nt||}t||jjq=Wg|jjD]} |j| jkr| ^q} tt| d d SWdt|j_XdS( Ntfuncdeftclassdeficss|]}|dVqdS(iN((t.0R&((s0lib/python2.7/site-packages/jedi/api/__init__.pys st expr_stmtiiR|tkeycSs|jS(N(RO(tx((s0lib/python2.7/site-packages/jedi/api/__init__.pyRR(RR(RDR;t is_analysisRBtanalysis_modulesRiRRyttypeRtchildrent isinstanceRtImportR~tget_defined_namest is_nestedt get_pathsRt infer_importt eval_nodeRRrRRtreset_recursion_limitationstanalysisR&tsortedR?( RMRhtnodeRRdRttypesttestlistRtatana((s0lib/python2.7/site-packages/jedi/api/__init__.pyt _analysiss4   #  1N((Rkt __module__t__doc__R0RWRtmemoize_methodRiRmRnRrR?RsRRRRpR(((s0lib/python2.7/site-packages/jedi/api/__init__.pyR 2s$   @*   & # &t InterpretercBs&eZdZeZdZdZRS(s Jedi API for Python REPLs. In addition to completion of simple attribute access, Jedi supports code completion based on static code analysis. Jedi can complete attributes of object which is not initialized yet. >>> from os.path import join >>> namespace = locals() >>> script = Interpreter('join("").up', [namespace]) >>> print(script.completions()[0].name) upper cKsy#g|D]}t|^q }Wntk rBtdnX|jdd}|dkrmt}nt|tstdntt|j |d|dt t j |||_ |j|j_dS(s Parse `source` and mixin interpreted Python objects from `namespaces`. :type source: str :arg source: Code to parse. :type namespaces: list of dict :arg namespaces: a list of namespace dictionaries such as the one returned by :func:`locals`. Other optional arguments are same as the ones for :class:`Script`. If `line` and `column` are None, they are assumed be at the end of `source`. s-namespaces must be a non-empty list of dicts.R"s?The environment needs to be an InterpreterEnvironment subclass.RRN(tdictt Exceptiont TypeErrortgetR0R RtsuperRRWRR.R9t namespacest!_allow_descriptor_getattr_defaultR;tallow_descriptor_getattr(RMRNRtkwdsRR"((s0lib/python2.7/site-packages/jedi/api/__init__.pyRWs#    cCs:tj|j|j|jdt|j|jd|jS(NRfR[( R tMixedModuleContextR;RBRRR&RFRE(RM((s0lib/python2.7/site-packages/jedi/api/__init__.pyRis  (RkRRRDRRWRi(((s0lib/python2.7/site-packages/jedi/api/__init__.pyRs sutf-8c sfd}fd}t|ddddd|d|d |} | jgt| j|D]!} tj| j|| ^qj} tt|| d d S( s Returns a list of `Definition` objects, containing name parts. This means you can call ``Definition.goto_assignments()`` and get the reference of a name. The parameters are the same as in :py:class:`Script`, except or the following ones: :param all_scopes: If True lists the names of all scopes instead of only the module namespace. :param definitions: If True lists the names that have been defined by a class, function or a statement (``a = b`` returns ``a``). :param references: If True lists all the names that are not listed by ``definitions=True``. E.g. ``a = b`` returns ``b``. cs)|jjj}r|p(o(| S(N(t_nameRt is_definition(t_deftis_def(Rt references(s0lib/python2.7/site-packages/jedi/api/__init__.pytdef_ref_filterscs7|jjdkrt}nt}|j||S(Ntparam(tparentRRRRy(R|tcls(tmodule_context(s0lib/python2.7/site-packages/jedi/api/__init__.pyt create_names   ROiRPiR&R'R"RcSs|j|jfS(N(RORP(R((s0lib/python2.7/site-packages/jedi/api/__init__.pyR R( R RiRRBR R{R;Rtfilter( RNR&R't all_scopesRRR"RRtscriptR|R((RRRs0lib/python2.7/site-packages/jedi/api/__init__.pyRcs * 7cGs>x7|D]/}d|}t|dt|djqWdS(s Preloading modules tells Jedi to load a module now, instead of lazy parsing of modules. Usful for IDEs, to control which modules to load on startup. :param modules: different module names, list of string. simport %s as x; x.iN(R RHR0Rn(tmodulestmts((s0lib/python2.7/site-packages/jedi/api/__init__.pytpreload_module s  cCs(|t_|t_|t_|t_dS(s Define a callback debug function to get all the debug messages. If you don't specify any arguments, debug messages will be printed to stdout. :param func_cb: The callback function for debug messages, with n params. N(Rtdebug_functiontenable_warningt enable_noticet enable_speed(tfunc_cbRtnoticesR<((s0lib/python2.7/site-packages/jedi/api/__init__.pytset_debug_functions   (DRR.tsysRR3t parso.pythonRtjedi._compatibilityRRRtjedi.parser_utilsRtjediRRRt jedi.file_ioRtjedi.apiR R R tjedi.api.completionR tjedi.api.environmentR tjedi.api.projectRRt jedi.evaluateRRRtjedi.evaluate.argumentsRtjedi.evaluate.helpersRRtjedi.evaluate.sys_pathRtjedi.evaluate.namesRRtjedi.evaluate.syntax_treeRtjedi.evaluate.contextRtjedi.evaluate.base_contextRtjedi.evaluate.context.iterableRt jedi.evaluate.gradual.conversionRRtjedi.evaluate.gradual.utilsRtsetrecursionlimittobjectR RR0R?RDRcRtprint_to_stdoutR(((s0lib/python2.7/site-packages/jedi/api/__init__.pyt sN     w: )