]jxsXSrSSKrSSKJr SSKJr SSKJr SSKJr SSK J r SSK J r SS K Jr SS KJrJr SS KJr SS KJrJr SS KJrJr SSKJr SSKJr SSKJr Sr Sr!Sr""SS5r#"SS\#5r$"SS\#5r%"SS\%5r&"SS\&5r'"SS\%5r(g) 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)settings)debug)unite)memoize_method) MixedName) ImportName SubModuleName)StubModuleValue) convert_namesconvert_values)ValueSet HasNoContext) KeywordName)completion_cache)filter_follow_importsc[USS9$)Nc,UR=(d S$Nrr) start_posss M/home/mande/repo/quber/.venv/lib/python3.13/site-packages/jedi/api/classes.py*_sort_names_by_start_pos..#sq{{'=A>cnUVs/sH#n[URUR5PM% sn$s snfN)r)r*r.)r(cs r_values_to_definitionsr46s+5; BaseName.Ms.Bv5.2Bs+-zargparse._ActionsContainerzargparse.ArgumentParserc\XlX l[UR[5Ulgr2)_inference_state_name isinstancer is_keyword)selfr*r.s r__init__BaseName.__init__Qs& /  %TZZ=rc6URR5$r2)rUget_root_contextrXs r_get_module_contextBaseName._get_module_contextYs zz**,,rreturncUR5nUR5(dUR5(d UR5R5nU$g)zE Shows the file path of a module. e.g. ``/usr/lib/python3.14/os.py`` N)r^is_stub is_compiled py__file__)rXmodulepaths r module_pathBaseName.module_path`sN ))+ >>  6#5#5#7#7$(#;#;#=#H#H#JDKrc6URR5$)zq Name of variable/function/class/module. For example, for ``x = None`` it returns ``'x'``. :rtype: str or None )rUget_public_namer]s rr. BaseName.namenszz))++rc~URRnSnUb:UR5nUb'URS:XaUR 5(aSn[ UR[ 5(dU(a-URR5HnURs $ URR$)a1 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``. F import_fromT) rU tree_nameget_definitiontype is_definitionrVr inferapi_type)rXrnresolve definitionr+s rrp BaseName.typeysrJJ((   "113J%*//]*J++-- djj- 0 0G))+~~%,zz"""rc>UR5R5$)a 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 )r^ py__name__r]s r module_nameBaseName.module_names'')4466rcUR5R5n[U[5(a[ SUR 55$UR 5$)z, Returns True, if this is a builtin module. c3@# UHoR5v M g7fr2)rc)rNrPs rrQ-BaseName.in_builtin_module..sI0H1}}0H)r^ get_valuerVr anynon_stub_value_setrc)rXr+s rin_builtin_moduleBaseName.in_builtin_modulesN((*446 e_ - -I0H0HII I  ""rc@URRnUcgUS$)z7The line where the definition occurs (starting with 1).NrrUrrXrs rline BaseName.line&JJ((  |rc@URRnUcgUS$)z9The column where the definition occurs (starting with 0).Nrrs rcolumnBaseName.columnrrcURRcgURRR5nUcURR$UR$)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)rUrnror)rXrus rget_definition_start_position&BaseName.get_definition_start_positionsQ ::   'ZZ))88:  ::'' '###rcURRcgURRR5nUc URRR$URS;aFUR 5nURS:XaUR 5R$UR$UR$)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)rUrnroend_posrp get_last_leafget_previous_leaf)rXru last_leafs rget_definition_end_position$BaseName.get_definition_end_positions ::   'ZZ))88:  ::''// / 99- -"002I~~* 224<<<$$ $!!!rFc[UR[5(aU(agUR5nU(aU$UR 5nU(aU(aUS-U-$XC-$)a 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 )rVrUr _get_docstring_get_docstring_signature)rXrawfastdocsignature_texts r docstringBaseName.docstring s\> djj* - -$!!# J668 c!F*S0 0!' 'rc6URR5$r2)rU py__doc__r]s rrBaseName._get_docstring4szz##%%rcLSRSURSS955$)N c3B# UHnUR5v M g7fr2) to_string)rN signatures rrQ4BaseName._get_docstring_signature..8s# E     ! !EsT) for_docstring)join_get_signaturesr]s rr!BaseName._get_docstring_signature7s.yy !111E   rcURnURRnUS:Xa US-URR5-$US;dUc(US:XaSnUS-URR 5-$UR SS9=(d UnUR SS 9n[R"S SU5n[R"S SU5R5nU$) a 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 )rrreinstancerdefT)include_setitemF)include_prefixz #[^\n]+\nz\s+) rprUrnrrjroget_coderesubstrip)rXtyprnrutxts r descriptionBaseName.description=s:iiJJ(( '>9tzz3355 5 = =ARj 9tzz99;; ;--d-CPy !!!7ff\3,ffVS#&,,. rcURR(dgURRSS9nUcg[U5nURUSUS'SR U5$![ a Nf=f)ae 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)include_module_namesrrK)rU is_value_nameget_qualified_nameslist_mappingKeyErrorr)rXr"s r full_nameBaseName.full_namens{0zz'' ..D.I =U  }}U1X.E!Hxx   sA,, A98A9cURR(dgURR5R5$)z= Returns True if the current name is defined in a stub file. F)rUrr\rbr]s rrbBaseName.is_stubs0zz''zz**,4466rcURRnUcgUR5=(a URRS:H$)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. Ftrailer)rUrnrqparentrp)rXrns ris_side_effectBaseName.is_side_effectsA JJ((  &&(OY-=-=-B-Bi-OOrz goto on name)follow_importsfollow_builtin_imports only_stubs prefer_stubsc$URR(d/$URR5nU(a [XR5n[ UUUS9nUVs/sH*nX`R:XaUO[ UR U5PM, sn$s snf)a 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` rr)rUrgotorr r)rT)rXrrrrr"r/s rr BaseName.gotos zz''I ! )%HE !%   AZZT$2G2G-KK   s1B z infer on namercU(a U(aeURR(d/$[UR/SS9n[[R "SU55UUS9nUVs/sHoUR PM nnUVs/sH*nXpR:XaUO[URU5PM, sn$s snfs snf)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` Trc3@# UHoR5v M g7fr2)rr)rNr/s rrQ!BaseName.infer..s8%Qwwyy%r~r) rUrr rr from_setsr.r)rT)rXrrr"r(r3resulting_namesr/s rrrBaseName.infers$<00zz''I tzzl>   8%8 8!%  ,226a6662(*(AZZT$2G2G-KK(* *3*s -B<1CcURR(dgURS;a|URRbeURRR 5nUR SSS5nUR 5RU5R5nOURRnUcgURcURnURcM[URUR5$)z< Returns the parent scope of this identifier. :rtype: Name N)rrrfuncdefclassdef file_input) rUrrprnrosearch_ancestorr^ create_valuer%parent_contextr.r)rT)rXcls_or_func_noderr,s rrBaseName.parents zz'' 996 64::;O;O;[ $zz33BBD %55i\ZF..0==fEPPRGjj//G ?ll",,Gll"D))7<<88rc SURR<SUR(aSOS<SUR=(d UR<SUR<S3 $)N) __class____name__rr.rr]s r__repr__BaseName.__repr__ sC NN # #~~G2 - NN 'dii '      rcURR(dgURR5RnUcgURRSS- n[ XA- S5nSR X5XB-S-5$)a 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. rrr)rUrr\ code_linesrmaxr)rXbeforeafterlinesindex start_indexs r get_line_codeBaseName.get_line_codesvzz'' ++-88 = $$Q'!+%.!, wwu):;< %O1L1L1N#1NOOOs60C*cvUR5Vs/sHn[URU5PM sn$s snf)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` )r BaseSignaturerT)rXrs rrBaseName.get_signatures:s?))+ + $// 3+   s 6cd[URR5R55$)zs Uses type inference to "execute" this identifier and returns the executed objects. :rtype: list of :class:`Name` )r4rUrrexecute_with_valuesr]s rexecuteBaseName.executeFs%&djj&6&6&8&L&L&NOOrcRURR5R5$)z 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 )rUrr get_type_hintr]s rr BaseName.get_type_hintOs zz!//11r)rTrUrWNFTr)F)+r __module__ __qualname____firstlineno____doc__rdictitems_tuple_mappingrYrr^rrrrgr.rpryrrrrrrrrrrrbrrincrease_indent_cmrrrrrrrrrr __static_attributes__rrr6r6:s !% H$&?B egBN>--  Xd^  ,,D#D#L 7 7# $"&)(V& ..`$$L7P n-%*5E . : o."'e!*/!*F9B =,P"  P 2rr6c^\rSrSrSrSU4SjjrSr\S5r\S5r SU4Sjjr U4Sjr U4S jr U4S jr \U4S j5rS rS rSrU=r$) Completioni\z| ``Completion`` objects are returned from :meth:`.Script.complete`. They provide additional information about a completion. cb>[TU]X5 X@lX0lXPlX`l/Ulgr2)superrY_like_name_length_stack _is_fuzzy _cached_name_same_name_completions)rXr*r.stacklike_name_lengthis_fuzzy cached_namers rrYCompletion.__init__as0 /!1 !'')#rcSn[R(aURS:XaSnURR 5nU(aX0R SnX2-$)Nrr()radd_bracket_after_functionrprUrjr)rX like_nameappendr.s r _completeCompletion._completensO  . .II+Fzz))+ ../0D}rcHUR(agURS5$)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)rr*r]s rcompleteCompletion.completeys* >>~~d##rc$URS5$)a  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)r*r]s rname_with_symbolsCompletion.name_with_symbolss~~e$$rcB>URS:aSn[TU] XS9$)z. Documented under :meth:`BaseName.docstring`. F)rr)rrr)rXrrrs rrCompletion.docstrings-  ! !Q &Dw S 44rc>^TRb>[R"TRTRR 5U4Sj5$[ TT]5$)Nc$>TR5$r2 _get_cacher]srr+Completion._get_docstring.. )r)rr get_docstringrUrjrrrXrs`rrCompletion._get_docstringsN    (#11!! **,)  w%''rc>^TRb>[R"TRTRR 5U4Sj5$[ TT]5$)Nc$>TR5$r2r7r]srr5Completion._get_docstring_signature..r:r)rrget_docstring_signaturerUrjrrr<s`rr#Completion._get_docstring_signaturesN    (#;;!! **,)  w/11rcN>[TU][TU] 5[TU] 54$r2)rrprrr<s rr8Completion._get_caches* GL G , . G " $  rc>^TRb>[R"TRTRR 5U4Sj5$[ TT]$)z) Documented under :meth:`BaseName.type`. c$>TR5$r2r7r]srr!Completion.type..r:r)rrget_typerUrjrrpr<s`rrpCompletion.typesL    (#,,!! **,)  w|rcUR$)a' 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. )rr]s rget_completion_prefix_length'Completion.get_completion_prefix_lengths %%%rcnS[U5R<SURR5<S3$)Nrz: r)rprrUrjr]s rrCompletion.__repr__s$!$Z00$**2L2L2NOOr)rrrrrr2r )rr rrrrYr*rr-r0rrrr8rprKrr __classcell__rs@rrr\sx (, ) $$0 % % 5(2   &$PPrrcT^\rSrSrSrU4Sjr\S5rSrSr Sr Sr S r U=r $) r)izo *Name* objects are returned from many different APIs including :meth:`.Script.goto` or :meth:`.Script.infer`. c$>[TU]X5 gr2)rrY)rXr*rurs rrY Name.__init__s 5rct^TRR5n[[U4SjU55SS9$)zO List sub-definitions (e.g., methods in class). :rtype: list of :class:`Name` c3P># UHn[TRU5v M g7fr2)r0rT)rNdrXs rrQ%Name.defined_names..s!H4a- 5 5q994s#&c@URR=(d S$rrrs rr$Name.defined_names..s!''++5v5rr)rUrrr!r)rXdefss` rr0Name.defined_namess5zz! H4H H5  rczURRcgURRR5$)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. T)rUrnrqr]s rrqName.is_definitions0 ::   '::''557 7rcURRURR:H=(aY URUR:H=(a9 URUR:H=(a URUR:H$r2)rUrrgr.rTrXothers r__eq__ Name.__eq__ spzz##u{{'<'<<@  E$5$55@ UZZ'@%%)?)?? @rc.URU5(+$r2)rar_s r__ne__ Name.__ne__s;;u%%%rc[URRURURUR 45$r2)hashrUrrgr.rTr]s r__hash__ Name.__hash__s0TZZ))4+;+;TYYH]H]^__rr)rr rrrrYrr0rqrardrhrrOrPs@rr)r)s=6    8@ &``rr)cB^\rSrSrSrU4Sjr\S5rSrSr U=r $)rizI These signatures are returned by :meth:`BaseName.get_signatures` calls. cD>[TU]XR5 X lgr2)rrYr. _signature)rXr*rrs rrYBaseSignature.__init__s ..9#rcURRSS9Vs/sHn[URU5PM sn$s snf)z Returns definitions for all parameters that a signature defines. This includes stuff like ``*args`` and ``**kwargs``. :rtype: list of :class:`.ParamName` T resolve_stars)rlget_param_names ParamNamerT)rXr/s rparamsBaseSignature.paramssL88t8LNLA$//3LN NNs ?c6URR5$)z Returns a text representation of the signature. This could for example look like ``foo(bar, baz: int, **kwargs)``. :rtype: str )rlrr]s rrBaseSignature.to_string*s((**r)rl) rr rrrrYrrsrrrOrPs@rrrs-$NN++rrcR^\rSrSrSrU4Sjr\S5r\S5rSr Sr U=r $) Signaturei4zP A full signature object is the return value of :meth:`.Script.get_signatures`. c<>[TU]X5 X0lX lgr2)rrY _call_detailsrl)rXr*r call_detailsrs rrYSignature.__init__9s 4)#rcfURRURRSS95$)z Returns the param index of the current cursor position. Returns None if the index cannot be found in the curent call. :rtype: int Tro)rzcalculate_indexrlrqr]s rrSignature.index>s2!!11 OO + +$ + ?  rcBURRR$)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_leafrr]s r bracket_startSignature.bracket_startJs!!..888rcS[U5R<SUR<SURR 5<S3$)Nrz: index=rr)rprrrlrr]s rrSignature.__repr__Ts0 J   JJ OO % % '  r)rzrl) rr rrrrYrrrrrrOrPs@rrxrx4s?$     99  rrxc6\rSrSrSrSrSr\S5rSr g)rri\cH[URR55$)z] Returns default values like the ``1`` of ``def foo(x=1):``. :rtype: list of :class:`.Name` )r4rU infer_defaultr]s rrParamName.infer_default]s &djj&>&>&@AArc P[URR"SSS0UD65$)z :param execute_annotation: Default True; If False, values are not executed and classes are returned instead of instances. :rtype: list of :class:`.Name` ignore_starsTr)r4rUinfer_annotation)rXkwargss rrParamName.infer_annotationes' &djj&A&A&^t&^W]&^__rc6URR5$)zZ Returns a simple representation of a param, like ``f: Callable[..., Any]``. :rtype: str )rUrr]s rrParamName.to_stringmszz##%%rc6URR5$)zm Returns an enum instance of :mod:`inspect`'s ``Parameter`` enum. :rtype: :py:attr:`inspect.Parameter.kind` )rUget_kindr]s rkindParamName.kindvszz""$$rrN) rr rrrrrrrrrrrrrrr\s'B`&%%rrr))rrpathlibrtypingrjedirrjedi.inference.utilsr jedi.cacherjedi.inference.compiled.mixedr jedi.inference.namesr r !jedi.inference.gradual.stub_valuer !jedi.inference.gradual.conversionr rjedi.inference.base_valuerrjedi.api.keywordsrjedi.apirjedi.api.helpersrr#r0r4r6rr)rrxrrrrrrs &%3:=K<)%2> O =_2_2DKPKP\)`8)`X+D+<% % P!%!%r