a lc'z@sdZddlZddlmZddlZddlmZddlmZddl m Z ddl m Z ddl m Z dd l mZdd lmZdd lmZdd lmZdd lmZddlmZmZddlmZddlmZddlmZmZddlm Z ddlm!Z!ddl"m#Z#m$Z$ddl%m&Z&ddl%m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9m:Z:dd l;mZ>e?d"Gd#d$d$Z@Gd%d&d&e@ZAd'd(ZBe jCd)d)d)fd*d+ZDdS),aQ 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. N)Path)tree)get_executable_nodes)debug)settings)cache)KnownContentFileIO)classes) interpreter)helpers)validate_line_column) Completionsearch_in_module) KeywordName)InterpreterEnvironment)get_default_projectProject)parso_to_jedi_errors) refactoring)extract_functionextract_variable)InferenceState)imports)find_references)try_iter_content)infer_call_of_leaf)transform_path_to_dotted)tree_name_to_values) ModuleValue)ValueSet)unpack_tuple_to_dict) convert_namesconvert_values)load_proper_stub_module)to_listi c@s@eZdZdZd7ddddddZejddZdd Zd d Z e d8d d ddZ e d9d d dddZ e d:d d d d dddZ d dddZed;ddZddZe dd!d"Ze d?d#d$Zd%d&Zd'd(Zd)d*Zd@d,d-ZdAd.d/Ze ddd0d1d2Ze ddd0d3d4ZdBd5d6ZdS)CScriptaK A Script is the base for completions, goto or whatever you want to do with Jedi. The counter part of this class is :class:`Interpreter`, which works with actual dictionaries and can work with a REPL. This class should be used when a user edits code in an editor. You can either use the ``code`` parameter or ``path`` to read a file. Usually you're going to want to use both of them (in an editor). The Script's ``sys.path`` is very customizable: - If `project` is provided with a ``sys_path``, that is going to be used. - If `environment` is provided, its ``sys.path`` will be used (see :func:`Environment.get_sys_path `); - Otherwise ``sys.path`` will match that of the default environment of Jedi, which typically matches the sys path that was used at the time when Jedi was imported. Most methods have a ``line`` and a ``column`` parameter. Lines in Jedi are always 1-based and columns are always zero based. To avoid repetition they are not always documented. You can omit both line and column. Jedi will then just do whatever action you are calling at the end of the file. If you provide only the line, just will complete at the end of that line. .. warning:: By default :attr:`jedi.settings.fast_parser` is enabled, which means that parso reuses modules (i.e. they are not immutable). With this setting Jedi is **not thread safe** and it is also not safe to use multiple :class:`.Script` instances and its definitions at the same time. If you are a normal plugin developer this should not be an issue. It is an issue for people that do more complex stuff with Jedi. This is purely a performance optimization and works pretty well for all typical usages, however consider to turn the setting off if it causes you problems. See also `this discussion `_. :param code: The source code of the current file, separated by newlines. :type code: str :param path: The path of the file in the file system, or ``''`` if it hasn't been saved yet. :type path: str or pathlib.Path or None :param Environment environment: Provide a predefined :ref:`Environment ` to work with a specific Python version or virtualenv. :param Project project: Provide a :class:`.Project` to make sure finding references works well, because the right folder is searched. There are also ways to modify the sys path and other things. N)path environmentprojectcCs||_t|trt|}|r$|nd|_|durt|durBtdt|d}|}Wdn1sj0Y|durt |jdurdn|jj }t |||jd|_ t d|j j||j|o|jdkdtjtjd\|_}t dtj|d d |_||_tt dS) Nz)Must provide at least one of code or pathrb)r'Z script_pathinit.pyiF)coder&Zuse_latest_grammarrZ diff_cache cache_pathparsedT)keepends) _orig_path isinstancestrrabsoluter& ValueErroropenreadrparentr_inference_staterspeedZparse_and_get_codesuffixrZ fast_parserZcache_directory _module_nodeparso split_lines _code_lines_coderZclear_time_cachesZ reset_time)selfr,r&r'r(frBM/var/www/html/django/DPS/env/lib/python3.9/site-packages/jedi/api/__init__.py__init__ds8  &    zScript.__init__cCsd}d}|jdurZ module_cacheaddr)r@namesrJ import_namesZis_prGZ stub_modulemodulerBrBrC _get_modulesF    zScript._get_modulecCs |SN)rQ as_contextr@rBrBrC_get_module_contextszScript._get_module_contextcCsd|jjt|j|jjfS)Nz <%s: %s %r>) __class____name__reprr0r8r'rTrBrBrC__repr__s zScript.__repr__Ffuzzyc CsXtd:t|j||j||f|j|d}|WdS1sJ0YdS)a+ Completes objects under the cursor. Those objects contain information about the completions, more than just names. :param fuzzy: Default False. Will return fuzzy completions, which means that e.g. ``ooa`` will match ``foobar``. :return: Completion objects, sorted by name. Normal names appear before "private" names that start with ``_`` and those appear before magic methods and name mangled names that start with ``__``. :rtype: list of :class:`.Completion` completerZN)rZincrease_indent_cmr r8rUr>get_signaturesr\)r@linecolumnr[ completionrBrBrCr\s   zScript.complete only_stubs prefer_stubsc s||f}j|}|durxj|}|dus:|jdkr>gS|j||fkrx|jdkrx|}|j|jkrx|jdvrx|}|}t j ||} t | ||d} fdd| D} t t| S)a Return the definitions of under the cursor. It is basically a wrapper around Jedi's type inference. This method follows complicated paths and returns the end, not the first definition. The big difference between :meth:`goto` and :meth:`infer` is that :meth:`goto` doesn't follow imports and statements. Multiple objects may be returned, because depending on an option you can have two different versions of a function. :param only_stubs: Only return stubs for this method. :param prefer_stubs: Prefer stubs to Python objects for this method. :rtype: list of :class:`.Name` Nstringoperator)numberrdkeywordracsg|]}tj|jqSrB)r Namer8name).0crTrBrC z Script.infer..)r;get_name_of_positionget_leaf_for_positiontypeend_posZ get_next_leaf start_posrUcreate_contextr inferr8r"sorted_definitionsset) r@r^r_rbrcposleafZnext_contextvaluesdefsrBrTrCrts*   z Script.infer)follow_importsfollow_builtin_importsrbrccsj||f}|dur*j||||dS|}g} |jr|jr|jj }  | } | } t | | D]} | |j} | rzqqz| st| } |rt| |} t| ||d} fddt| D}ttt|S)a~ Goes to the name that defined the object under the cursor. Optionally you can follow imports. Multiple objects may be returned, depending on an if you can have two different versions of a function. :param follow_imports: The method will follow imports. :param follow_builtin_imports: If ``follow_imports`` is True will try to look up names in builtins (i.e. compiled or extension modules). :param only_stubs: Only return stubs for this method. :param prefer_stubs: Prefer stubs to Python objects for this method. :rtype: list of :class:`.Name` Nracsg|]}tj|qSrBr rhr8rjdrTrBrCrl3rmzScript.goto..)r;rnrtrU create_name tree_nameZ is_definitionparent_contextZis_classZ tree_node create_valueZ py__mro__nextgotovaluelistr Zfilter_follow_importsr!rvru)r@r^r_r|r}rbrcrrirNZ class_nodeZ class_valuemroclsr{rBrTrCrs2   z Script.goto all_scopescCs|j||dS)a Searches a name in the current file. For a description of how the search string should look like, please have a look at :meth:`.Project.search`. :param bool all_scopes: Default False; searches not only for definitions on the top level of a module level, but also in functions and classes. :yields: :class:`.Name` r _search_func)r@rdrrBrBrCsearch7s z Script.searchc Cs6|j|d}t|\}}t|j||||||dS)Nr)rN wanted_type wanted_namesr\r[)_namesr Zsplit_search_stringrr8rU)r@rdrr\r[rNrrrBrBrCrDs zScript._search_funccKs|j|fddi|S)a Like :meth:`.Script.search`, but completes that string. If you want to have all possible definitions in a file you can also provide an empty string. :param bool all_scopes: Default False; searches not only for definitions on the top level of a module level, but also in functions and classes. :param fuzzy: Default False. Will return fuzzy completions, which means that e.g. ``ooa`` will match ``foobar``. :yields: :class:`.Completion` r\Tr)r@rdkwargsrBrBrCcomplete_searchRs zScript.complete_searchcspj||dd}|r|Sj||fdurljdvrlfdd}|rltjj}tj|gSgS)a* Used to display a help window to users. Uses :meth:`.Script.goto` and returns additional definitions for keywords and operators. Typically you will want to display :meth:`.BaseName.docstring` to the user for all the returned definitions. The additional definitions are ``Name(...).type == 'keyword'``. These definitions do not have a lot of value apart from their docstring attribute, which contains the output of Python's :func:`help` function. :rtype: list of :class:`.Name` T)r|N)rgreZ error_leafcsHjdvr*jjdkrdSjjdkr*dSjj}|jj}j|vS)N)()[]trailerFZatom)rr7rpr8grammarZ _pgen_grammarZreserved_syntax_stringskeys)rreservedrxr@rBrC need_pydocus    zScript.help..need_pydoc) rr;rorprr8rr rh)r@r^r_ definitionsrrirBrrChelpas z Script.helpc s dfdd }|fi|S)a Lists all references of a variable in a project. Since this can be quite hard to do for Jedi, if it is too complicated, Jedi will stop searching. :param include_builtins: Default ``True``. If ``False``, checks if a definition is a builtin (e.g. ``sys``) and in that case does not return it. :param scope: Default ``'project'``. If ``'file'``, include references in the current module only. :rtype: list of :class:`.Name` Tr(csv|dvrtdjf}|dur,gSt||dk}fdd|D}|r^|dkrldd|D}t|S)N)r(filez0Only the scopes "file" and "project" are allowedrcsg|]}tj|qSrBr~rjnrTrBrCrlrmz>Script.get_references.._references..cSsg|]}|s|qSrB)Zin_builtin_modulerrBrBrCrlrm)r4r;rnrrUr ru)include_builtinsscoperrNrr_r^r@rBrC _referencess z*Script.get_references.._references)Tr(rB)r@r^r_rrrBrrCget_referencesszScript.get_referencescsl||f}tj|dur"gSj}tj|jj|}t dfdd| DS)aZ Return the function object of the call under the cursor. 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:`.Signature` Nzfunc_call followedcsg|]}tj|qSrB)r Signaturer8)rj signatureZ call_detailsr@rBrCrlsz)Script.get_signatures..) r Zget_signature_detailsr;rUrsZ bracket_leafZcache_signaturesr8r>rr9r])r@r^r_rwryrrBrrCr]s   zScript.get_signaturesc Cs||f}|jj|dd}|j|ks,|jdkr@|}|dur@|}|}t|dd}|dur|j|kr||jdjkrnn| | }n | |}|j dur|j }qt|j|j } | jdkr| j} | j} | dur| } | jd |krq| } q| S) z Returns the scope context under the cursor. This basically means the function, class or module where the cursor is at. :rtype: :class:`.Name` T)Zinclude_prefixesZ endmarkerNfuncdefclassdefrP)r;rorrrpZget_previous_leafrUrZsearch_ancestorchildrenrrSrsrirr rhr8_namerZget_definitionr7) r@r^r_rwrxZ previous_leafmodule_contextrryZ definitionrirrrBrBrC get_contexts.*    zScript.get_contextc s\dj_jgj_}z.tjD]}||}|jdvrXtj||j dnt |t j rt |}|r|t dd|DO}|D]}t||qnd|jdkr||}|j dddD]}t|||qn,|jd krj||}n t||}t|jq*fd d jjD} tt | d d dWdj_Sdj_0dS)NT)rrrcss|]}|dVqdS)rNrB)rjr&rBrBrC rmz#Script._analysis..Z expr_stmtrricsg|]}j|jkr|qSrB)r&)rjarTrBrCrlrmz$Script._analysis..cSs|jSrR)r^xrBrBrCrmz"Script._analysis..keyF)r8Z is_analysisr;Zanalysis_modulesrUrrsrprrr1rImportrvZget_defined_namesZ is_nested get_pathsrZ infer_importZ infer_noder rtrrZreset_recursion_limitationsZanalysissorted) r@rPnoderyrOrtypesZtestlistr{ZanarBrTrC _analysiss8          zScript._analysisc s"jfi|}fdd|DS)a Returns names defined in the current file. :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``. :rtype: list of :class:`.Name` csg|]}tj|qSrBr~rrTrBrCrl!rmz$Script.get_names..)r)r@rrNrBrTrC get_namess zScript.get_namescCst|jj|jS)zm Lists all syntax errors in the current file. :rtype: list of :class:`.SyntaxError` )rr8rr;rTrBrBrCget_syntax_errors#szScript.get_syntax_errorsTcs:|fddtj|j|||dD}t|dddS)Ncsg|]}|qSrB)r)rjrirrBrCrl.sz!Script._names..)rr referencescSs|jSrR)rrrrBrBrCr7rmzScript._names..r)rUr Zget_module_namesr;r)r@rrrr{rBrrCr+s  z Script._namescCs |j||dd}t|j||S)z Renames all references of the variable under the cursor. :param new_name: The variable under the cursor will be renamed to this string. :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` Fr)rrrenamer8)r@r^r_new_namerrBrBrCr9s z Script.rename) until_line until_columncCs`|dur|durd}n.|dur"|}|durrr8r&r;r@r^r_rrrZ until_posrBrBrCrEs  zScript.extract_variablecCsb|dur|durd}n.|dur"|}|durrr8r&rUrrBrBrCrls" zScript.extract_functioncCs(dd|j||ddD}t|j|S)a Inlines a variable under the cursor. This is basically the opposite of extracting a variable. For example with the cursor on bar:: foo = 3.1 bar = foo + 1 x = int(bar) the code above will become:: foo = 3.1 x = int(foo + 1) :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` cSsg|] }|jqSrB)rrrBrBrCrlrmz!Script.inline..Tr)rrinliner8)r@r^r_rNrBrBrCrsz Script.inline)N)NN)NN)NN)FFF)NN)NN)NN)NN)FTF)NN)NN)rW __module__ __qualname____doc__rDrmemoize_methodrQrUrYr r\rtrrr$rrrrr]rrrrrrrrrrBrBrBrCr%3sH0( ++2   $  $ ("  &.r%cs8eZdZdZdZddfdd ZejddZZ S) Interpretera  Jedi's API for Python REPLs. Implements all of the methods that are present in :class:`.Script` as well. In addition to completions that normal REPL completion does like ``str.upper``, Jedi also supports code completion based on static code analysis. For example Jedi will complete ``str().upper``. >>> from os.path import join >>> namespace = locals() >>> script = Interpreter('join("").up', [namespace]) >>> print(script.complete()[0].name) upper All keyword arguments are same as the arguments for :class:`.Script`. :param str code: Code to parse. :type namespaces: typing.List[dict] :param namespaces: A list of namespace dictionaries such as the one returned by :func:`globals` and :func:`locals`. TN)r(c szdd|D}Wnty,tdYn0|dd}|durJt}nt|ts\td|durptt}tj |f||d|||_ |j |j _ dS)NcSsg|] }t|qSrB)dictrrBrBrCrlrmz(Interpreter.__init__..z-namespaces must be a non-empty list of dicts.r'z?The environment needs to be an InterpreterEnvironment subclass.)r'r() Exception TypeErrorgetrr1rrcwdsuperrD namespaces!_allow_descriptor_getattr_defaultr8Zallow_descriptor_getattr)r@r,rr(kwdsr'rVrBrCrDs    zInterpreter.__init__cCsD|jdurd}nt|j|j}t|j|j|d|jd}t||j S)NrE)rGrHrI) r&rr?rr8r;r>r ZMixedModuleContextr)r@rGZtree_module_valuerBrBrCrUs zInterpreter._get_module_context) rWrrrrrDrrrU __classcell__rBrBrrCrs rcGs*|D] }d|}t|dt|qdS)z Preloading modules tells Jedi to load a module now, instead of lazy parsing of modules. This can be useful for IDEs, to control which modules to load on startup. :param modules: different module names, list of string. zimport %s as x; x.rN)r%r\r)modulesmsrBrBrCpreload_modulesrTcCs|t_|t_|t_|t_dS)z 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. N)rZdebug_functionZenable_warningZ enable_noticeZ enable_speed)Zfunc_cbwarningsZnoticesr9rBrBrCset_debug_functions r)Ersyspathlibrr<Z parso.pythonrZjedi.parser_utilsrZjedirrrZ jedi.file_iorZjedi.apir r r Zjedi.api.helpersr Zjedi.api.completionr rZjedi.api.keywordsrZjedi.api.environmentrZjedi.api.projectrrZjedi.api.errorsrrZjedi.api.refactoring.extractrrZjedi.inferencerrZjedi.inference.referencesrZjedi.inference.argumentsrZjedi.inference.helpersrZjedi.inference.sys_pathrZjedi.inference.syntax_treerZjedi.inference.valuerZjedi.inference.base_valuerZjedi.inference.value.iterabler Z!jedi.inference.gradual.conversionr!r"Zjedi.inference.gradual.utilsr#Zjedi.inference.utilsr$setrecursionlimitr%rrZprint_to_stdoutrrBrBrBrCsZ                             @