]j~SrSSKrSSKJr SSKrSSKJr SSKJr SSK J r SSK J r SSK J r SS K Jr SS KJr SS KJr SS KJr SS KJr SSKJrJr SSKJr SSKJr SSKJrJr SSKJ r SSKJ!r! SSK"J#r#J$r$ SSK%J&r& SSK%J'r' SSK(J)r) SSK*J+r+ SSK,J-r- SSK.J/r/ SSK0J1r1 SSK2J3r3 SSK4J5r5 SSK6J7r7 SSK8J9r9J:r: SS K;Jr> \R~"S"5 "S#S$5r@"S%S&\@5rAS'rB\ RS(S(S(4S)jrDg)*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\rSrSrSrS"SSSS.Sjjr\RS5rSr Sr \ S#S S .S jj5r \ S#S S S .S jj5r \ S#S S S S S.Sjj5rS S.Sjr\S$Sj5rSr\ S#Sj5r\ S#Sj5r\ S#Sj5r\ S#Sj5rSrSrSrS%SjrS#Sjr\ SSS.Sj5r\ SSS.Sj5rS#S jrS!rg)&Script3a 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 environmentprojectc `X l[U[5(a [U5nU(aUR 5OSUlUc3Uc [ S5e[US5nUR5nSSS5 Uc.[UR cSOUR R5n[XCUR S9Ul [R"S5 URRUUR U=(a UR S:HS["R$["R&S9uUln[R"S5 [*R,"US S 9UlXl[2R4"5 [R6"5 g!,(df  GN2=f) Nz)Must provide at least one of code or pathrb)r* script_pathinit.pyiF)coder)use_latest_grammarr diff_cache cache_pathparsedT)keepends) _orig_path isinstancestrrabsoluter) ValueErroropenreadrparentr_inference_staterspeedparse_and_get_codesuffixr fast_parsercache_directory _module_nodeparso split_lines _code_lines_coderclear_time_caches reset_time)selfr1r)r*r+fs N/home/mande/repo/quber/.venv/lib/python3.13/site-packages/jedi/api/__init__.py__init__Script.__init__dsI dC :D'+DMMO <| !LMMdD!Qvvx" ?)$))2C$IYIYZG . $))!   F"&"7"7"J"J#= v(=++// #K# 4  H ,,TDA  ! 1"!s "F F-c SnSnURb6[URRSS9UR5up4UbUnUnURcSnO [ URUR 5nURbVURR S:Xa<[URURRUUUR5nUbU$UcSn[URURUUURUS9nUSS;a0URRRU[U/55 U$)NF)add_parent_pathsr0__main__)file_io string_names code_lines is_packager)builtinstyping)r)rr? get_sys_pathr rIrBr$latest_grammarrErrH module_cacheaddr )rLnamesrX import_namesis_prU stub_modulemodules rN _get_moduleScript._get_modules> 99 !9%%22E2J " L'$! 99 G(DJJ?G 99 TYY%5%5%?1%%%%44!! K&"" =!E  ! !4#4#4''!   81 1  ! ! . . 2 25(F8:L M c>UR5R5$N)rd as_contextrLs rN_get_module_contextScript._get_module_contexts!,,..rfcSURR<S[UR5<SURR <S3$)N) __class____name__reprr7r?r*rjs rN__repr__Script.__repr__s4 NN # #  !  ! ! - -  rfFfuzzyc .URR5 [R"S5 [ URUR 5UR X4URUS9nUR5sSSS5 $!,(df  g=f)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` completervN) r?reset_recursion_limitationsrincrease_indent_cmrrkrHget_signaturesry)rLlinecolumnrw completions rNryScript.completess 99;  % %j 1#%%t'?'?'A4CSCS 3 35J&&( 2 1 1s A B B only_stubs prefer_stubscURR5 X4nURRU5nUcURR U5nUbUR S:Xa/$UR X4:XaLUR S:Xa<UR5nURUR :XaUR S;aUnUR5RU5n[R"URX5n [U UUS9n U V s/sH.n [R"URU R 5PM0 n n [R""[%U 55$s sn f)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` stringoperator)numberrkeywordr)r?rzrEget_name_of_positionget_leaf_for_positiontypeend_pos get_next_leaf start_posrkcreate_contextr inferr#r Namenamesorted_definitionsset) rLr}r~rrposleafnext_contextvaluescdefss rNr Script.infers8" 99;l  55c: <$$::3?D|tyyH4 ||~-$))z2I**,??dll2!JJ*II D**,;;DAt44gD !%  FLLV T22AFF;VL))#d)44 Ms5E.)follow_importsfollow_builtin_importsrrcURR5 URRX45nUcUR XXVS9$UR 5R U5n/n URR5(aURR5(a}URRn UR 5RU 5n U R5n [U 5 U H'n U RUR 5n U (dM' O U (d[#UR55n U(a[$R&"X5n [)U UUS9n [+U 5Vs/sH$n[,R."URU5PM& nn[#[+[$R0"U555$s snf)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` r)r?rzrErrrk create_name tree_name is_definitionparent_contextis_class tree_node create_value py__mro__nextgotovaluelistr filter_follow_importsr"rr rr)rLr}r~rrrrrrr_ class_node class_valuemroclsdrs rNr Script.gotos| 99;%%::D>J  ::dz:] ]'')55i@ >> ' ' ) )d.A.A.J.J.L.L,,66J224AA*MK'')C I15 %E 11%PE !%  ADE K 1 T22A6 KC22489::Ls;+G all_scopesc URXS9$)aC 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)rLrrs rNsearch Script.search:s   ??rfc URUS9n[R"U5upg[URUR 5UUUUUS9$)Nr)r_ wanted_type wanted_namesryrw)_namesr split_search_stringrr?rk)rLrrryrwr_rrs rNrScript._search_funcGsV z 2$+$?$?$G!   ! !  $ $ &#%  rfc ,UR"U4SS0UD6$)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` ryTr)rLrkwargss rNcomplete_searchScript.complete_searchUs  A$A&AArfc^^TRR5 TRXSS9nU(aU$TRR X45mTbPTR X4:Xa?TR S:Xa/TR5nUbURTR :XaUmTbeTR S;aUUU4SjnU"5(aB[TRTR5n[R"TRU5/$/$)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)rnewline)rr error_leafc">TRS;a6TRRS:XagTRRS:XagTRRnUR R R5nTRU;$)N)()[]trailerFatom)rr>rr?grammar _pgen_grammarreserved_syntax_stringskeys)rreservedrrLs rN need_pydocScript.help..need_pydocsv::!55{{''94${{''61$//77#00HHMMOzzX--rf) r?rzrrErrrrrrrr r)rLr}r~ definitionsrrrrs` @rNhelp Script.helpds 99;iiTiB    66~F    >499PYCY&&(E U__ %D   -R R .||"4#8#8$**E T%:%:DABB rfc `^^^TRR5 SUUU4SjjnU"S0UD6$)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` c>US;a [S5eT RRTT45nUc/$[T R 5X!S:H5nUVs/sH$n[ R "T RU5PM& nnU(aUS:Xa(UVs/sHofR5(aMUPM nn[R"U5$s snfs snf)N)r+filez0Only the scopes "file" and "project" are allowedr) r;rErrrkr rr?in_builtin_moduler r) include_builtinsscoperr_nrrr~r}rLs rN _references*Script.get_references.._referencess// !STT))>>f~NI  #D$<$<$> TZ?[EKPQ5a7<<(=(=qA5KQ#u*5S+Q=P=P=Rq+ S--k: :RSs+CC0C)Tr+)r?rz)rLr}r~rrs``` rNget_referencesScript.get_referencess1 99; ; ;$V$$rfcURR5 X4n[R"URU5nUc/$UR 5R UR5n[R"URUURURU5n[R"S5 UR5Vs/sH$n[R"URXt5PM& sn$s snf)a 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` zfunc_call followed)r?rzr get_signature_detailsrErkr bracket_leafcache_signaturesrHrr@r|r Signature)rLr}r~r call_detailsrr signatures rNr|Script.get_signaturess" 99;l44T5F5FL  I**,;;L) rLr}r~rr previous_leafmodule_contextrr definitionrrrs rN get_contextScript.get_contextsun  66sT6R >>C 499 #; 224M($113  J 7 =Q[[3J!**R.2J2JJ %11!4??AG$33D9Gll",,Gll"\\$"7"7F oo)##DI$!002??1%.$**,Joo)rfcSURlUR/URlUR 5n[ UR5GH}nUR U5nURS;a%[URX2RS5 GO[U[R5(aq[UR55nUR5(a#U[SUR!555-nUHn["R$"X55 M OURS:Xa7UR'U5nURSSS2Hn[)X6U5 M OBURS:XaURR+X25nO [-X25n[/U5 URR15 GM URR2V s/sH oR4U R4:XdMU PM" n n [7[U 5S S 9S URl$s sn f!S URlf=f) NT)rrrc3*# UH oSv M g7f)rNr).0r)s rN #Script._analysis.. s+RAQHAQs expr_stmtrrcUR$rh)r}xs rN"Script._analysis..s!&&rfkeyF)r? is_analysisrEanalysis_modulesrkrrrrrr8rImportrget_defined_names is_nested get_pathsr infer_import infer_noder!rrrrzanalysisr)sorted) rLrcnoderr`rtypestestlistraanas rN _analysisScript._analysiss,0)262C2C1D.))+ 6,T->->? //599 77'(=(=w VWHXYdkk22#&t'='='?#@L~~''$+RAQ+R(RR ),,W8*YY+-#..t4E$(MM%2a%$8,WXF%9yyF*#44::7I1'@$T*%%AAC-@0#33<<T< QVV@S1 %f%@EF1 T22A6FFFs+AcV[URRUR5$)zU Lists all syntax errors in the current file. :rtype: list of :class:`.SyntaxError` )rr?rrErjs rNget_syntax_errorsScript.get_syntax_errors/s# $D$9$9$A$A4CTCTUUrfcURR5 UR5n[R"UR UUUS9Vs/sHnUR U5PM nn[USS9$s snf)N)rr referencescUR$rh)rrs rNrScript._names..Ds!++rfr )r?rzrkr get_module_namesrErr)rLrrr#rrrs rNr Script._names7s 99;113 00!!%'%    & &t ,  d 566 sA6cdURXSS9n[R"URXC5$)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)rrrenamer?)rLr}r~new_namers rNr* Script.renameFs2))$)O !!$"7"7OOrf) until_line until_columncUcUcSnO&UcUnUc[URUS- 5nXE4n[URURUR X1U4U5$)a Moves an expression to a new statement. For example if you have the cursor on ``foo`` and provide a ``new_name`` called ``bar``:: foo = 3.1 x = int(foo + 1) the code above will become:: foo = 3.1 bar = foo + 1 x = int(bar) :param new_name: The expression under the cursor will be renamed to this string. :param int until_line: The the selection range ends at this line, when omitted, Jedi will be clever and try to define the range itself. :param int until_column: The the selection range ends at this column, when omitted, Jedi will be clever and try to define the range itself. :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` Nr)lenrHrr?r)rErLr}r~r+r-r. until_poss rNrScript.extract_variableRss4  ,"6I!! #"4#3#3JN#CD "0I  ! !499d.?.? Vni  rfcUcUcSnO&UcUnUc[URUS- 5nXE4n[URURUR 5X1U4U5$)aC Moves an expression to a new function. For example if you have the cursor on ``foo`` and provide a ``new_name`` called ``bar``:: global_var = 3 def x(): foo = 3.1 x = int(foo + 1 + global_var) the code above will become:: global_var = 3 def bar(foo): return int(foo + 1 + global_var) def x(): foo = 3.1 x = bar(foo) :param new_name: The expression under the cursor will be replaced with a function with this name. :param int until_line: The the selection range ends at this line, when omitted, Jedi will be clever and try to define the range itself. :param int until_column: The the selection range ends at this column, when omitted, Jedi will be clever and try to define the range itself. :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` Nr)r0rHrr?r)rkr1s rNrScript.extract_functionyswD  ,"6I!! #"4#3#3JN#CD "0I  ! !499d.F.F.H Vni  rfcURXSS9Vs/sHo3RPM nn[R"URU5$s snf)a9 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` Tr))rrrinliner?)rLr}r~rr_s rNr7 Script.inlinesL"#'"5"5dUY"5"Z["ZQ"Z[!!$"7"7??\sA )rIrHr?rEr7r)rh)NN)FFF)FTF) rr __module__ __qualname____firstlineno____doc__rOrmemoize_methodrdrkrtr ryrrrr%rrrrr|rrrr rr*rrr7__static_attributes__rrfrNr'r'3sl/`$$D$$P ))V/ ))),*5%e*5*5X1;U[`E1;1;f,1 @       B))V%%<#?#?J&&P 6D GV 7 PEIX\$ $ LEIX\, , \@rfr'cX^\rSrSrSrSS.U4Sjjr\RS5rSr U=r $) Interpreteria 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`. N)r+c >UVs/sHn[U5PM nnURSS5nUc [ 5nO [ U[5(d [S5eUc[ [R"55n[TU]("U4XcS.UD6 X l [RURlSURlgs snf![a [S5ef=f)Nz-namespaces must be a non-empty list of dicts.r*z?The environment needs to be an InterpreterEnvironment subclass.)r*r+F)dict Exception TypeErrorgetrr8rrcwdsuperrO namespacesr#allow_unsafe_interpreter_executionsr?allow_unsafe_executionsdo_dynamic_params_search)rLr1rHr+kwdsrr*rqs rNrOInterpreter.__init__s M+56:a$q':J6hh}d3  02Kk+ABB abb ?dhhj)G P;P4P$  8 8 5:?657 MKL L MsCC C CC$cURcSnO [URUR5n[URUR USUR S9n[R"UUR5$)NrS)rUrVrW) r)r rIrr?rErHr MixedModuleContextrH)rLrUtree_module_values rNrkInterpreter._get_module_contextso 99 G(DJJ?G'  ! !4#4#4&''   --  OO  rf)rH) rrr9r:r;r<rOrr=rkr> __classcell__)rqs@rNr@r@s1.59??<   rfr@cNUHn[SU35R5 M! g)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 N)r'r)modulesms rNpreload_modulerVs%}##%rfTc\U[lU[lU[lU[lg)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)rdebug_functionenable_warning enable_notice enable_speed)func_cbwarningsnoticesr@s rNset_debug_functionr_s$#E#E!EErf)Er<syspathlibrrF parso.pythonrjedi.parser_utilsrjedirrr jedi.file_ior jedi.apir r r jedi.api.helpersr jedi.api.completionrrjedi.api.keywordsrjedi.api.environmentrjedi.api.projectrrjedi.api.errorsrrjedi.api.refactoring.extractrrjedi.inferencerrjedi.inference.referencesrjedi.inference.argumentsrjedi.inference.helpersrjedi.inference.sys_pathrjedi.inference.syntax_treerjedi.inference.valuerjedi.inference.base_valuer jedi.inference.value.iterabler!!jedi.inference.gradual.conversionr"r#jedi.inference.gradual.utilsr$jedi.inference.utilsr%setrecursionlimitr'r@rVprint_to_stdoutr_rrfrNr|s  2+ 1<)790 K)"555<:,.>K@(dG @G @TE &E P & %44t#4 rf