API Return Classes¶
jedi.api.classes module contains the return classes of the API.
These classes are the much bigger part of the whole API, because they contain
the interesting information about completion and goto operations.
List sub-definitions (e.g., methods in class).
Return type: list of Definition
Shows the file path of a module. e.g.
Name of variable/function/class/module.
For example, for
x = Noneit returns
Return type: str or None
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
variableis unambiguous to Jedi,
jedi.Script.goto_definitions()should return a list of definition for
>>> 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.goto_definitions()
Before showing what is in
defs, let’s sort it by
lineso that it is easy to relate the result to the source code.
>>> defs = sorted(defs, key=lambda d: d.line) >>> defs [<Definition module keyword>, <Definition class C>, <Definition instance D>, <Definition def f>]
Finally, here is what you can get from
>>> defs.type 'module' >>> defs.type 'class' >>> defs.type 'instance' >>> defs.type 'function'
The module name.
>>> from jedi import Script >>> source = 'import json' >>> script = Script(source, path='example.py') >>> d = script.goto_definitions() >>> print(d.module_name) json
Whether this is a builtin module.
The line where the definition occurs (starting with 1).
The column where the definition occurs (starting with 0).
Return a document string for this completion object.
>>> from jedi import Script >>> source = '''\ ... def f(a, b=1): ... "Document for function f." ... ''' >>> script = Script(source, 1, len('def f'), 'example.py') >>> doc = script.goto_definitions().docstring() >>> print(doc) f(a, b=1) Document for function f.
Notice that useful extra information is added to the actual docstring. For function, it is call signature. If you need actual docstring, use
>>> print(script.goto_definitions().docstring(raw=True)) Document for function f.
Parameters: 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 textual description of the object.
Dot-separated path of this object.
It is in the form of
<module>[.<submodule>[...]][.<object>]. It is useful when you want to look up Python manual of the object at hand.
>>> from jedi import Script >>> source = ''' ... import os ... os.path.join''' >>> script = Script(source, 3, len('os.path.join'), 'example.py') >>> print(script.goto_definitions().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
<module 'posixpath' ...>`. However most users find the latter more practical.
Returns the line of code where this object was defined.
- before – Add n lines before the current line to the output.
- after – Add n lines after the current line to the output.
Returns the line(s) of code or an empty string if it’s a builtin.
Completion(evaluator, name, stack, like_name_length)¶
Completion objects are returned from
api.Script.completions(). They provide additional information about a completion.
Return the rest of the word, e.g. completing
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
foo(parwould give a
Completionwhich complete would be am=
name, but like
namereturns also the symbols, for example assuming the following function definition:
def foo(param=0): pass
foo(would give a
name_with_symbolswould be “param=”.
Provide a description of the completion object.
Definition objects are returned from
A description of the
Definitionobject, which is heavily used in testing. e.g. for
>>> from jedi import Script >>> source = ''' ... def f(): ... pass ... ... class C: ... pass ... ... variable = f if random.choice([0,1]) else C''' >>> script = Script(source, column=3) # line is maximum by default >>> defs = script.goto_definitions() >>> defs = sorted(defs, key=lambda d: d.line) >>> defs [<Definition def f>, <Definition class C>] >>> str(defs.description) # strip literals in python2 'def f' >>> str(defs.description) 'class C'
In addition to the definition, also return the module.
Don’t use this function yet, its behaviour may change. If you really need it, talk to me.
Returns True, if defined as a name in a statement, function or class. Returns False, if it’s a reference to such a definition.
CallSignature(evaluator, executable_name, bracket_start_pos, index, key_name_str)¶
CallSignature objects is the return value of Script.function_definition. It knows what functions you are currently in. e.g. isinstance( would return the isinstance function. without ( it would return nothing.
The Param index of the current call. Returns None if the index cannot be found in the curent call.
The indent of the bracket that is responsible for the last function call.