API Return Classes

The 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.

jedi.api.classes.defined_names(evaluator, context)

List sub-definitions (e.g., methods in class).

Return type:list of Definition

class jedi.api.classes.BaseDefinition(evaluator, name)

module_path = None

Shows the file path of a module. e.g. /usr/lib/python2.7/os.py

name

Name of variable/function/class/module.

For example, for x = None it returns 'x'.

Return type:str or None

type

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, jedi.Script.goto_definitions() 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.goto_definitions()

Before showing what is in defs, let’s sort it by line so 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 type:

>>> defs = [str(d.type) for d in defs]  # It's unicode and in Py2 has u before it.
>>> defs[0]
'module'
>>> defs[1]
'class'
>>> defs[2]
'instance'
>>> defs[3]
'function'

module_name

The module name.

>>> from jedi import Script
>>> source = 'import json'
>>> script = Script(source, path='example.py')
>>> d = script.goto_definitions()[0]
>>> print(d.module_name)                       
json

in_builtin_module()

Whether this is a builtin module.

line

The line where the definition occurs (starting with 1).

column

The column where the definition occurs (starting with 0).

docstring(raw=False, fast=True)

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, 1, len('def f'), 'example.py')
>>> doc = script.goto_definitions()[0].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 raw=True instead.

>>> print(script.goto_definitions()[0].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.

description

A textual description of the object.

full_name

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.

Example:

>>> from jedi import Script
>>> source = '''
... import os
... os.path.join'''
>>> script = Script(source, 3, len('os.path.join'), 'example.py')
>>> print(script.goto_definitions()[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 <module 'posixpath' ...>`. However most users find the latter more practical.

goto_assignments()

params

Raises an ``AttributeError``if the definition is not callable. Otherwise returns a list of Definition that represents the params.

parent()

get_line_code(before=0, after=0)

Returns the line of code where this object was defined.

Parameters:

• before – Add n lines before the current line to the output.
• 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.

class jedi.api.classes.Completion(evaluator, name, stack, like_name_length)

Completion objects are returned from api.Script.completions(). They provide additional information about a completion.

complete

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=

name_with_symbols

Similar to name, but like 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=”.

docstring(raw=False, fast=True)

description

Provide a description of the completion object.

follow_definition()

Return the original 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 PITA-slow.

class jedi.api.classes.Definition(evaluator, definition)

Definition objects are returned from api.Script.goto_assignments() or api.Script.goto_definitions().

description

A description of the Definition 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, 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[0].description)  # strip literals in python2
'def f'
>>> str(defs[1].description)
'class C'

desc_with_module

In addition to the definition, also return the module.

Warning

Don’t use this function yet, its behaviour may change. If you really need it, talk to me.

defined_names()

List sub-definitions (e.g., methods in class).

Return type:list of Definition

is_definition()

Returns True, if defined as a name in a statement, function or class. Returns False, if it’s a reference to such a definition.

class jedi.api.classes.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.

index

The Param index of the current call. Returns None if the index cannot be found in the curent call.

bracket_start

The indent of the bracket that is responsible for the last function call.