a lcs@sFdZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z dd l mZdd lmZdd lmZmZdd lmZdd lmZmZddlmZmZddlmZddlmZddl m!Z!ddZ"ddZ#ddZ$GdddZ%Gddde%Z&Gddde%Z'Gddde'Z(Gd d!d!e(Z)Gd"d#d#e'Z*dS)$a` There are a couple of classes documented in here: - :class:`.BaseName` as an abstact base class for almost everything. - :class:`.Name` used in a lot of places - :class:`.Completion` for completions - :class:`.BaseSignature` as a base class for signatures - :class:`.Signature` for :meth:`.Script.get_signatures` only - :class:`.ParamName` used for parameters of signatures - :class:`.Refactoring` for refactorings - :class:`.SyntaxError` for :meth:`.Script.get_syntax_errors` only These classes are the much biggest part of the API, because they contain the interesting information about all operations. N)Path)Optional)search_ancestor)settings)debug)unite)memoize_method) MixedName) ImportName SubModuleName)StubModuleValue) convert_namesconvert_values)ValueSet HasNoContext) KeywordName)completion_cache)filter_follow_importscCst|dddS)NcSs |jpdSN)rr) start_possrL/var/www/html/django/DPS/env/lib/python3.9/site-packages/jedi/api/classes.py%z*_sort_names_by_start_pos..key)sorted)namesrrr_sort_names_by_start_pos$sr csXz |}Wnty"gYS0t|}dd|D}fddt|DS)zi List sub-definitions (e.g., methods in class). :type scope: Scope :rtype: list of Name cSsg|]}|qSrr).0namerrr 4rz!defined_names..csg|]}t|qSr)Namer!ninference_staterrr#5r) as_contextrnextZ get_filtersvaluesr )r(valuecontextfilterrrr'r defined_names(s    r/cCsdd|DS)NcSsg|]}t|j|jqSr)r$r(r"r!crrrr#9rz*_values_to_definitions..r)r+rrr_values_to_definitions8sr2c @s|eZdZdZddddddddddddd Zed d d d iDZddZe ddZ e e e dddZe ddZe ddZe ddZddZe ddZe dd Zd!d"Zd#d$ZdMd'd(Zd)d*Zd+d,Ze d-d.Ze d/d0Zd1d2Zd3d4Zed5d%d%d%d%d6d7d8Z ed9d%d%d:d;d<Z!d=d>Z"d?d@Z#dNdBdCZ$dOdDdEZ%dFdGZ&dHdIZ'dJdKZ(dLS)PBaseNamezI The base class for all definitions, completions and signatures. zos.pathosio functools collectionssocketsqlite3) posixpathZ riscospathntpathZ os2emxpathZmacpath genericpathposix_io _functools _collections_socketZ_sqlite3ccs$|]\}}t|d|fVqdS).N)tuplesplit)r!kvrrr OrzBaseName.zargparse._ActionsContainerzargparse.ArgumentParsercCs||_||_t|jt|_dSN)_inference_state_name isinstancerZ is_keyword)selfr(r"rrr__init__SszBaseName.__init__cCs |jSrH)rJget_root_contextrLrrr_get_module_context[szBaseName._get_module_context)returncCs4|}|s|s0|}|dur0|SdS)zT Shows the file path of a module. e.g. ``/usr/lib/python3.9/os.py`` N)rPis_stub is_compiledZ py__file__)rLmodulepathrrr module_pathbs  zBaseName.module_pathcCs |jS)z Name of variable/function/class/module. For example, for ``x = None`` it returns ``'x'``. :rtype: str or None )rJget_public_namerOrrrr"qs z BaseName.namecCsj|jj}d}|dur:|}|dur:|jdkr:|r:d}t|jtsJ|rb|jD] }|jS|jjS)a The type of the definition. Here is an example of the value of this attribute. Let's consider the following source. As what is in ``variable`` is unambiguous to Jedi, :meth:`jedi.Script.infer` should return a list of definition for ``sys``, ``f``, ``C`` and ``x``. >>> from jedi import Script >>> source = ''' ... import keyword ... ... class C: ... pass ... ... class D: ... pass ... ... x = D() ... ... def f(): ... pass ... ... for variable in [keyword, f, C, x]: ... variable''' >>> script = Script(source) >>> defs = script.infer() Before showing what is in ``defs``, let's sort it by :attr:`line` so that it is easy to relate the result to the source code. >>> defs = sorted(defs, key=lambda d: d.line) >>> print(defs) # doctest: +NORMALIZE_WHITESPACE [, , , ] Finally, here is what you can get from :attr:`type`: >>> defs = [d.type for d in defs] >>> defs[0] 'module' >>> defs[1] 'class' >>> defs[2] 'instance' >>> defs[3] 'function' Valid values for type are ``module``, ``class``, ``instance``, ``function``, ``param``, ``path``, ``keyword``, ``property`` and ``statement``. FNZ import_fromT) rJ tree_nameget_definitiontype is_definitionrKr inferapi_type)rLrXresolve definitionr,rrrrZ|s9 z BaseName.typecCs |S)aP The module name, a bit similar to what ``__name__`` is in a random Python module. >>> from jedi import Script >>> source = 'import json' >>> script = Script(source, path='example.py') >>> d = script.infer()[0] >>> print(d.module_name) # doctest: +ELLIPSIS json )rPZ py__name__rOrrr module_names zBaseName.module_namecCs2|}t|tr*tdd|jDS|S)z< Returns True, if this is a builtin module. css|]}|VqdSrH)rS)r!rFrrrrGrz-BaseName.in_builtin_module..)rP get_valuerKr anyZnon_stub_value_setrS)rLr,rrrin_builtin_modules  zBaseName.in_builtin_modulecCs|jj}|durdS|dS)z7The line where the definition occurs (starting with 1).NrrJrrLrrrrlinesz BaseName.linecCs|jj}|durdS|dS)z9The column where the definition occurs (starting with 0).NrdrerrrcolumnszBaseName.columncCs2|jjdurdS|jj}|dur,|jjS|jS)z The (row, column) of the start of the definition range. Rows start with 1, columns start with 0. :rtype: Optional[Tuple[int, int]] N)rJrXrYr)rLr_rrrget_definition_start_positions   z&BaseName.get_definition_start_positioncCs`|jjdurdS|jj}|dur.|jjjS|jdvrZ|}|jdkrT|jS|jS|jS)z The (row, column) of the end of the definition range. Rows start with 1, columns start with 0. :rtype: Optional[Tuple[int, int]] N)functionclassnewline)rJrXrYend_posrZZ get_last_leafZget_previous_leaf)rLr_Z last_leafrrrget_definition_end_positions      z$BaseName.get_definition_end_positionFTcCsLt|jtr|rdS|}|r$|S|}|r@|r@|d|S||SdS)ai Return a document string for this completion object. Example: >>> from jedi import Script >>> source = '''\ ... def f(a, b=1): ... "Document for function f." ... ''' >>> script = Script(source, path='example.py') >>> doc = script.infer(1, len('def f'))[0].docstring() >>> print(doc) f(a, b=1) Document for function f. Notice that useful extra information is added to the actual docstring, e.g. function signatures are prepended to their docstrings. If you need the actual docstring, use ``raw=True`` instead. >>> print(script.infer(1, len('def f'))[0].docstring(raw=True)) Document for function f. :param fast: Don't follow imports that are only one level deep like ``import foo``, but follow ``from foo import bar``. This makes sense for speed reasons. Completing `import a` is slow if you use the ``foo.docstring(fast=False)`` on every object, because it parses all libraries starting with ``a``. z N)rKrJr _get_docstring_get_docstring_signature)rLrawfastdocZsignature_textrrr docstring s zBaseName.docstringcCs |jSrH)rJZ py__doc__rOrrrrp7szBaseName._get_docstringcCsddd|jddDS)N css|]}|VqdSrH) to_string)r! signaturerrrrG;sz4BaseName._get_docstring_signature..T) for_docstring)join_get_signaturesrOrrrrq:s  z!BaseName._get_docstring_signaturecCs|j}|jj}|dkr(|d|jS|dvs8|durV|dkrDd}|d|jS|jddpd|}|jd d }td d|}td d| }|S) aZ A description of the :class:`.Name` object, which is heavily used in testing. e.g. for ``isinstance`` it returns ``def isinstance``. Example: >>> from jedi import Script >>> source = ''' ... def f(): ... pass ... ... class C: ... pass ... ... variable = f if random.choice([0,1]) else C''' >>> script = Script(source) # line is maximum by default >>> defs = script.infer(column=3) >>> defs = sorted(defs, key=lambda d: d.line) >>> print(defs) # doctest: +NORMALIZE_WHITESPACE [, ] >>> str(defs[0].description) 'def f' >>> str(defs[1].description) 'class C' param )rjrkrTinstanceNrjdefT)Zinclude_setitemF)Zinclude_prefixz #[^\n]+\nz\s+) rZrJrXrwrWrYget_coderesubstrip)rLtyprXr_txtrrr description@s zBaseName.descriptioncCsb|jjs dS|jjdd}|dur&dSt|}z|j|d|d<WntyVYn0d|S)a Dot-separated path of this object. It is in the form of ``[.[...]][.]``. It is useful when you want to look up Python manual of the object at hand. Example: >>> from jedi import Script >>> source = ''' ... import os ... os.path.join''' >>> script = Script(source, path='example.py') >>> print(script.infer(3, len('os.path.join'))[0].full_name) os.path.join Notice that it returns ``'os.path.join'`` instead of (for example) ``'posixpath.join'``. This is not correct, since the modules name would be `````. However most users find the latter more practical. NT)Zinclude_module_namesrrB)rJ is_value_nameZget_qualified_nameslist_mappingKeyErrorrz)rLrrrr full_nameqs zBaseName.full_namecCs|jjs dS|jS)zM Returns True if the current name is defined in a stub file. F)rJrrNrRrOrrrrRszBaseName.is_stubcCs(|jj}|durdS|o&|jjdkS)z Checks if a name is defined as ``self.foo = 3``. In case of self, this function would return False, for foo it would return True. NFtrailer)rJrXr[parentrZ)rLrXrrris_side_effectszBaseName.is_side_effectz goto on name)follow_importsfollow_builtin_imports only_stubs prefer_stubscsDjjs gSj}|r$t||}t|||d}fdd|DS)ag Like :meth:`.Script.goto` (also supports the same params), but does it for the current name. This is typically useful if you are using something like :meth:`.Script.get_names()`. :param follow_imports: The goto call 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 goto call. :param prefer_stubs: Prefer stubs to Python objects for this goto call. :rtype: list of :class:`Name` rrcs&g|]}|jkrn tj|qSrrJr$rIr%rOrrr#sz!BaseName.goto..)rJrgotorr )rLrrrrrrrOrrs   z BaseName.gotoz infer on namercsf|r |r JjjsgStjgdd}ttdd|D||d}dd|D}fdd|DS) a Like :meth:`.Script.infer`, it can be useful to understand which type the current name has. Return the actual definitions. I strongly recommend not using it for your completions, because it might slow down |jedi|. If you want to read only a few objects (<=20), it might be useful, especially to get the original docstrings. The basic problem of this function is that it follows all results. This means with 1000 completions (e.g. numpy), it's just very, very slow. :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:`Name` Trcss|]}|VqdSrH)r\r%rrrrGrz!BaseName.infer..rcSsg|] }|jqSr)r"r0rrrr#rz"BaseName.infer..cs&g|]}|jkrn tj|qSrrr%rOrrr#s)rJrr rrZ from_sets)rLrrrr+Zresulting_namesrrOrr\s  zBaseName.infercCs|jjs dS|jdvrP|jjdurP|jj}t|ddd}||}n|jj }|durddS|j durv|j }qdt |j |j S)zT Returns the parent scope of this identifier. :rtype: Name N)rjrkr|ZfuncdefZclassdefZ file_input) rJrrZrXrYrrPZ create_valuer)Zparent_contextr"r$rI)rLZcls_or_func_noderr-rrrrs  zBaseName.parentcCs(d|jj|jrdnd|jp|j|jfS)Nz<%s %sname=%r, description=%r>Zfull_ro) __class____name__rr"rrOrrr__repr__s   zBaseName.__repr__rcCs\|jjs dS|jj}|dur$dS|jjdd}t||d}d||||dS)aI Returns the line of code where this object was defined. :param before: Add n lines before the current line to the output. :param after: Add n lines after the current line to the output. :return str: Returns the line(s) of code or an empty string if it's a builtin. roNrrg)rJrrNZ code_linesrmaxrz)rLbeforeafterlinesindex start_indexrrr get_line_codes  zBaseName.get_line_codecCsd|jjdkrgS|r,|jjdkr,|s,gSt|jtrF|jSt|jgdd}dd|DS)NpropertyZ statementTrcSs"g|]}|D]}|qqSr)r\get_signatures)r!r"sigrrrr#;rz,BaseName._get_signatures..)rJr]rRrKr Zinfer_compiled_valuerr )rLryrrrrr{,s  zBaseName._get_signaturescsfddDS)z Returns all potential signatures for a function or a class. Multiple signatures are typical if you use Python stubs with ``@overload``. :rtype: list of :class:`BaseSignature` csg|]}tj|qSr) BaseSignaturerI)r!rrOrrr#Dsz+BaseName.get_signatures..)r{rOrrOrr=s zBaseName.get_signaturescCst|jS)z Uses type inference to "execute" this identifier and returns the executed objects. :rtype: list of :class:`Name` )r2rJr\Zexecute_with_valuesrOrrrexecuteIszBaseName.executecCs|jS)a* Returns type hints like ``Iterable[int]`` or ``Union[int, str]``. This method might be quite slow, especially for functions. The problem is finding executions for those functions to return something like ``Callable[[int, str], str]``. :rtype: str )rJr\ get_type_hintrOrrrrRs zBaseName.get_type_hintN)FT)rr)F))r __module__ __qualname____doc__rdictitemsZ_tuple_mappingrMrrPrrrrVr"rZr`rcrfrhrirnrurprqrrrRrrZincrease_indent_cmrr\rrrr{rrrrrrrr3<sr   F     + 0 &  #!    r3cseZdZdZdfdd ZddZeddZed d Zdfd d Z fddZ fddZ fddZ efddZ ddZddZZS) Completionz ``Completion`` objects are returned from :meth:`.Script.complete`. They provide additional information about a completion. Ncs0t||||_||_||_||_g|_dSrH)superrM_like_name_length_stack _is_fuzzy _cached_nameZ_same_name_completions)rLr(r"stackZlike_name_lengthZis_fuzzyZ cached_namerrrrMds zCompletion.__init__cCs<d}tjr|jdkrd}|j}|r4||jd}||S)Nrorj()rZadd_bracket_after_functionrZrJrWr)rLZ like_nameappendr"rrr _completeqs zCompletion._completecCs|jr dS|dS)a! Only works with non-fuzzy completions. Returns None if fuzzy completions are used. Return the rest of the word, e.g. completing ``isinstance``:: isinstan# <-- Cursor is here would return the string 'ce'. It also adds additional stuff, depending on your ``settings.py``. Assuming the following function definition:: def foo(param=0): pass completing ``foo(par`` would give a ``Completion`` which ``complete`` would be ``am=``. NT)rrrOrrrcomplete|szCompletion.completecCs |dS)aB Similar to :attr:`.name`, but like :attr:`.name` returns also the symbols, for example assuming the following function definition:: def foo(param=0): pass completing ``foo(`` would give a ``Completion`` which ``name_with_symbols`` would be "param=". F)rrOrrrname_with_symbolss zCompletion.name_with_symbolsFTcs|jdkrd}tj||dS)z> Documented under :meth:`BaseName.docstring`. F)rrrs)rrru)rLrrrsrrrrus zCompletion.docstringcs2jdur(tjjfddStS)NcsSrH _get_cacherrOrrrrz+Completion._get_docstring..)rr get_docstringrJrWrrprOrrOrrps  zCompletion._get_docstringcs2jdur(tjjfddStS)NcsSrHrrrOrrrrz5Completion._get_docstring_signature..)rrZget_docstring_signaturerJrWrrqrOrrOrrqs  z#Completion._get_docstring_signaturecstjttfSrH)rrZrqrprOrrrrszCompletion._get_cachecs0jdur(tjjfddStjS)z9 Documented under :meth:`BaseName.type`. NcsSrHrrrOrrrrz!Completion.type..)rrget_typerJrWrrZrOrrOrrZs  zCompletion.typecCs|jS)ao Returns the length of the prefix being completed. For example, completing ``isinstance``:: isinstan# <-- Cursor is here would return 8, because len('isinstan') == 8. Assuming the following function definition:: def foo(param=0): pass completing ``foo(par`` would return 3. )rrOrrrget_completion_prefix_lengthsz'Completion.get_completion_prefix_lengthcCsdt|j|jfS)Nz<%s: %s>)rZrrJrWrOrrrrszCompletion.__repr__)N)FT)rrrrrMrrrrrurprqrrZrr __classcell__rrrrr_s      rcsLeZdZdZfddZeddZddZdd Zd d Z d d Z Z S)r$z{ *Name* objects are returned from many different APIs including :meth:`.Script.goto` or :meth:`.Script.infer`. cst||dSrH)rrM)rLr(r_rrrrMsz Name.__init__cs,j}ttfdd|DdddS)zg List sub-definitions (e.g., methods in class). :rtype: list of :class:`Name` c3s|]}tj|VqdSrH)r/rI)r!drOrrrGrz%Name.defined_names..cSs |jjp dSrrdrrrrrrz$Name.defined_names..r)rJr\rr)rLZdefsrrOrr/s  zName.defined_namescCs |jjdurdS|jjSdS)z Returns True, if defined as a name in a statement, function or class. Returns False, if it's a reference to such a definition. NT)rJrXr[rOrrrr[s zName.is_definitioncCs4|jj|jjko2|j|jko2|j|jko2|j|jkSrH)rJrrVr"rIrLotherrrr__eq__ s   z Name.__eq__cCs || SrH)rrrrr__ne__sz Name.__ne__cCst|jj|j|j|jfSrH)hashrJrrVr"rIrOrrr__hash__sz Name.__hash__) rrrrrMrr/r[rrrrrrrrr$s   r$cs4eZdZdZfddZeddZddZZS)rzU These signatures are returned by :meth:`BaseName.get_signatures` calls. cst||j||_dSrH)rrMr" _signature)rLr(rxrrrrMszBaseSignature.__init__csfddjjddDS)z Returns definitions for all parameters that a signature defines. This includes stuff like ``*args`` and ``**kwargs``. :rtype: list of :class:`.ParamName` csg|]}tj|qSr) ParamNamerIr%rOrrr#*sz(BaseSignature.params..TZ resolve_stars)rget_param_namesrOrrOrparams"s  zBaseSignature.paramscCs |jS)z Returns a text representation of the signature. This could for example look like ``foo(bar, baz: int, **kwargs)``. :rtype: str )rrwrOrrrrw-szBaseSignature.to_string) rrrrrMrrrwrrrrrrs   rcs@eZdZdZfddZeddZeddZdd ZZ S) Signaturez\ A full signature object is the return value of :meth:`.Script.get_signatures`. cst||||_||_dSrH)rrM _call_detailsr)rLr(rxZ call_detailsrrrrM<szSignature.__init__cCs|j|jjddS)z Returns the param index of the current cursor position. Returns None if the index cannot be found in the curent call. :rtype: int Tr)rZcalculate_indexrrrOrrrrAs zSignature.indexcCs |jjjS)z Returns a line/column tuple of the bracket that is responsible for the last function call. The first line is 1 and the first column 0. :rtype: int, int )rZ bracket_leafrrOrrr bracket_startMszSignature.bracket_startcCsdt|j|j|jfS)Nz<%s: index=%r %s>)rZrrrrwrOrrrrWs zSignature.__repr__) rrrrrMrrrrrrrrrr7s   rc@s0eZdZddZddZddZeddZd S) rcCst|jS)zu Returns default values like the ``1`` of ``def foo(x=1):``. :rtype: list of :class:`.Name` )r2rJ infer_defaultrOrrrr`szParamName.infer_defaultcKst|jjfddi|S)z :param execute_annotation: Default True; If False, values are not executed and classes are returned instead of instances. :rtype: list of :class:`.Name` Z ignore_starsT)r2rJinfer_annotation)rLkwargsrrrrhszParamName.infer_annotationcCs |jS)zz Returns a simple representation of a param, like ``f: Callable[..., Any]``. :rtype: str )rJrwrOrrrrwpszParamName.to_stringcCs |jS)z Returns an enum instance of :mod:`inspect`'s ``Parameter`` enum. :rtype: :py:attr:`inspect.Parameter.kind` )rJZget_kindrOrrrkindyszParamName.kindN)rrrrrrwrrrrrrr_s  r)+rrpathlibrtypingrZ parso.treerZjedirrZjedi.inference.utilsrZ jedi.cacherZjedi.inference.compiled.mixedr Zjedi.inference.namesr r Z!jedi.inference.gradual.stub_valuer Z!jedi.inference.gradual.conversionr rZjedi.inference.base_valuerrZjedi.api.keywordsrZjedi.apirZjedi.api.helpersrr r/r2r3rr$rrrrrrrs<            ',(