libstatic.State

Resove a name expression to it's qualified name. by using information only available in the current module.

Only the first name in the expression is resolved, does not recurse in attributes definitions, simply append the rest of the names at the end.

>>> p = Project()
>>> node = ast.parse('from twisted.web.template import Tag as T; T')
>>> p.add_module(node, 'test')
<Mod(name=test)>
>>> p.analyze_project()
>>> use = node.body[-1].value
>>> p.state.expand_expr(use)
'twisted.web.template.Tag'

Returns None if the name is unbound or the expression is not composed by names.

Resove a dottedname to it's qualified name. by using information only available in the current module.

Only the first name in the dottedname is resolved, does not recurse in attributes definitions, simply append the rest of the names at the end.

>>> p = Project()
>>> m = p.add_module(ast.parse('from twisted.web.template import Tag as T'), 'test')
>>> p.analyze_project()
>>> p.state.expand_name(m, 'T.something') # expand 'T' in the context of m
'twisted.web.template.Tag.something'

Returns None is the name is unbound.

Returns all scopes enclosing this definition.

Iterate over all modules in the project. This include dependency modules.

Returns all names bound when wildcard importing the given module.

Get attributes definitions matching the name in the scope node. It fisrt call get_local() (get_ivar() if include_ivars=True); if no locals matches the name or ignore_locals=True and the scope is a module, it calls get_sub_module().

>>> src = '''
... class A:
...    def f(self, x):
...        self.x = x
... class B(A): ...
... class C(B): ...
... '''
>>> p = Project()
>>> m = p.add_module(ast.parse(src), 't')
>>> p.analyze_project()
>>> C = m.node.body[-1]
>>> p.state.get_attribute(C, 'f')
[<Func(name=f)>]

Def-Use chains accessor: returns the Def instance of this node. All ast nodes categorized as a use or a definition have a coresponding Def instance. Use this method to access it.

Finds the definitions having the given qualname.

>>> p = Project()
>>> node = ast.parse('class Reactor:\n class System:\n  target = "win32"')
>>> p.add_module(node, 'test')
<Mod(name=test)>
>>> p.analyze_project()
>>> p.state.get_defs_from_qualname('test.Reactor.System.target')
[<Var(name=target)>]

Get the computed value for the __all__ variable of this module.

If __all__ variable is not defined or too complex returns None.

Get the first enclosing scope of this use or deinition. Returns None only of the definition is a Module.

Returns the filename of the given ast node. If the node does not exist in the system, it returns None.

Get the instance variable definitions of the given name in class node. Only assigments present in methods directly in the body of the class are considered here. If you want to lookup instance variables in super classes as well, pass``include_inherited=True``.

Get the mapping of instance variables of the given class.

>>> p = Project()
>>> m = p.add_module(ast.parse('class C:\n'
... ' def __init__(self, x):\n'
... '  self._x = x'), 'test')
>>> p.analyze_project()
>>> C, = p.state.get_local(m, 'C')
>>> ivars = [f'{v.name()!r} {p.state.get_location(v)}' for v in chain(*p.state.get_ivars(C).values())]
>>> print('\n'.join(ivars))
'_x' ast.Attribute at test:3:2

Get the local definitions of the given name in scope node.

Get the mapping of locals of the given node.

>>> src = '''
... class A:
...    def f(self, x):
...        self.x = x
... class B(A): ...
... class C(B): ...
... '''
>>> p = Project()
>>> m = p.add_module(ast.parse(src), 't')
>>> p.analyze_project()
>>> A = m.node.body[-3]
>>> B = m.node.body[-2]
>>> C = m.node.body[-1]
>>> dict(p.state.get_locals(A))
{'f': [<Func(name=f)>]}
>>> dict(p.state.get_locals(B))
{}
>>> dict(p.state.get_locals(B, include_inherited=True))
{'f': [<Func(name=f)>]}
>>> dict(p.state.get_locals(C, include_inherited=True))
{'f': [<Func(name=f)>]}

Undocumented

Returns the module with the given name if it's in the system, else None.

Get an iterator on the elements of the MRO of class node.

>>> src = '''
... from x import thing
... class A(thing, object):...
... class B(A): ...
... class C(B): ...
... '''
>>> p = Project()
>>> m = p.add_module(ast.parse(src), 't')
>>> p.analyze_project()
>>> C = m.node.body[-1]
>>> list(p.state.get_mro(C))
[<Cls(name=C)>, <Cls(name=B)>, <Cls(name=A)>]
>>> list(p.state.get_mro(C, include_self=False))
[<Cls(name=B)>, <Cls(name=A)>]
>>> list(p.state.get_mro(C, include_self=False, include_unknown=True))
[<Cls(name=B)>, <Cls(name=A)>, 'x.thing', 'object']
>>> list(p.state.get_mro(C, include_unknown=True))
[<Cls(name=C)>, <Cls(name=B)>, <Cls(name=A)>, 'x.thing', 'object']

Returns the direct parent of the given node in the syntax tree.

Returns the first parent of the node in the syntax tree matching the given type info.

Get the parent package of the given module.

Returns None if the given module is a root module or the parent package is not found in the system.

Returns all syntax tree parents of the node in the syntax tree up to the root module.

Returns the qualified name of this definition. If the definition is an imported name, returns the qualified name of the the imported symbol.

A qualified named a name by wich a definition can be found. The same object could have several qualified named depending on where it's imported.

If this node is a module, returns it's Mod instance, else find the parent Module and return it's Mod instance.

Should only be called for statements.

Get a sub-module of the given module.

Infer the type of the given node or definition.

While basic type inference is provided, libstatic does not carry the complexity to support full-featured type-checking.

It can infer the type of any literal expression, when a name is encountered all it's potential defintions are looked up and the inferred type is derived from a union of all the possible types. There is support for attribute annotations, functions, modules or attribute access, instance variables and methods, properties and other fundamentals.

Notably missing features includes:

• Type aliases detection
• TypedDict and a lot more of the typing features

Limited support for some of these items might be added in the future.

Use-Def chains accessor (wraps goto_defs) that returns only one Def, or raise StaticException. It returns the first reachable definition in the list. It does not ensure that the list is only composed by one element, unless raise_on_ambiguity=True.

Go to the genuine definition of this expression. This is not a simple use-def chains accessor, it's recursive. By default it follows imports but not aliases.

>>> p = Project()
>>> _ = p.add_module(ast.parse('def deprecated(f):...'), 'deprecated')
>>> src1 = p.add_module(ast.parse('''\
... from deprecated import deprecated
... @deprecated
... def f():...'''), 'src1')
>>> src2 = p.add_module(ast.parse('''\
... import src1
... @src1.deprecated
... class C:...'''), 'src2')
>>> p.analyze_project()
>>> func_dec = src1.node.body[-1].decorator_list[0]
>>> p.state.goto_definition(func_dec)
<Func(name=deprecated)>
>>> cls_dec = src1.node.body[-1].decorator_list[0]
>>> p.state.goto_definition(cls_dec)
<Func(name=deprecated)>

Use-Def chains accessor: returns the definition points of the use node.

Finds all Name and Attribute references pointing to the given definition.

>>> p = Project()
>>> dep = p.add_module(ast.parse('def deprecated(f):...'), 'deprecated')
>>> _ = p.add_module(ast.parse('''\
... from deprecated import deprecated
... @deprecated
... def f():...'''), 'src1')
>>> _ = p.add_module(ast.parse('''\
... import src1
... @src1.deprecated
... class C:...'''), 'src2')
>>> p.analyze_project()
>>> dep_func = dep.node.body[-1]
>>> list(p.state.goto_references(dep_func))
[<Def(node=<Name>)>, <Def(node=<Attribute>)>]

Simple, lazy identifier -> defs resolving.

"Lookup" a name in the context of the provided scope, it does not use the chains Note that nonlocal and global keywords are ignored by this function.

>>> p = Project()
>>> m = p.add_module(ast.parse('from twisted.web.template import Tag as T;'), 'test')
>>> p.analyze_project()
>>> p.state.goto_symbol_def(m, 'T')
[<Imp(name=T)>]

Whether the node is reachable.

Powerfull ast.literal_eval() function. Does not support dicts at the moment.

>>> p = Project()
>>> node = ast.parse('from x import x;e="bar";x+["1", 2+3, e]')
>>> node2 = ast.parse('from test import e;"best "+e')
>>> p.add_module(node, 'test')
<Mod(name=test)>
>>> p.add_module(node2, 'test2')
<Mod(name=test2)>
>>> p.analyze_project()
>>> expr = node.body[-1].value
>>> p.state.literal_eval(expr, known_values={'x':['foo']})
['foo', '1', 5, 'bar']
>>> expr2 = node2.body[-1].value
>>> p.state.literal_eval(expr2)
Traceback (most recent call last):
libstatic.exceptions.StaticUnknownValue: test2:1:17: Unkown value: test.e
>>> p.state.literal_eval(expr2, follow_imports=True)
'best bar'