How to use the gast.Subscript function in gast
To help you get started, we’ve selected a few gast examples, based on popular ways it is used in public projects.
Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
serge-sans-paille / beniget / beniget / beniget.py View on Github 
def visit_Destructured(self, node):
dnode = self.chains.setdefault(node, Def(node))
tmp_store = ast.Store()
for elt in node.elts:
if isinstance(elt, ast.Name):
tmp_store, elt.ctx = elt.ctx, tmp_store
self.visit(elt)
tmp_store, elt.ctx = elt.ctx, tmp_store
elif isinstance(elt, ast.Subscript):
self.visit(elt)
elif isinstance(elt, (ast.List, ast.Tuple)):
self.visit_Destructured(elt)
return dnodedef visit_Assign(self, node):
self.src = quoting.unquote(node)
self.mark(node)
self.trivializing = True
self.namer.target = node.targets[0]
if isinstance(node.targets[0], (gast.Subscript, gast.Attribute)):
node.value = self.trivialize(node.value)
node.targets[0] = self.visit(node.targets[0])
elif isinstance(node.targets[0], gast.Tuple):
node.value = self.visit(node.value)
name = self.namer.name(node.targets[0])
target = gast.Name(id=name, ctx=gast.Store(), annotation=None)
for i, elt in enumerate(node.targets[0].elts):
stmt = gast.Assign(
targets=[elt],
value=gast.Subscript(
value=gast.Name(id=name, ctx=gast.Load(),
annotation=None),
slice=gast.Index(value=gast.Num(n=i)),
ctx=gast.Load()))
self.mark(stmt)
self.append(stmt)'''
if isinstance(node.slice, ast.Index):
aliases = set()
self.visit(node.slice)
value_aliases = self.visit(node.value)
for alias in value_aliases:
if isinstance(alias, ContainerOf):
if isinstance(node.slice.value, ast.Slice):
continue
if isnum(node.slice.value):
if node.slice.value.value != alias.index:
continue
# FIXME: what if the index is a slice variable...
aliases.add(alias.containee)
elif isinstance(getattr(alias, 'ctx', None), ast.Param):
aliases.add(ast.Subscript(alias, node.slice, node.ctx))
if not aliases:
aliases = None
else:
# could be enhanced through better handling of containers
aliases = None
self.generic_visit(node)
return self.add(node, aliases)
def _process_single_assignment(self, target, value):
if not isinstance(target, gast.Subscript):
return None
template = """
target = ag__.set_item(target, key, item)
"""
return templates.replace(
template, target=target.value, key=target.slice, item=value)# Compare(expr left, cmpop* ops, expr* comparators)
self.nodetype[node] = TyBool()
elif isinstance(node, gast.Call):
self.nodetype[node] = self.infer_Call(node)
elif isinstance(node, gast.Num):
# Num(object n)
self.nodetype[node] = type_of_value(node.n)
elif isinstance(node, gast.Str):
# Str(string s)
self.nodetype[node] = TyString(value=node.s)
elif isinstance(node, gast.NameConstant):
# NameConstant(singleton value)
self.nodetype[node] = type_of_value(node.value)
elif isinstance(node, gast.Attribute):
self.nodetype[node] = self.infer_Attribute(node)
elif isinstance(node, gast.Subscript):
self.nodetype[node] = self.infer_Subscript(node)
elif isinstance(node, gast.Name):
self.nodetype[node] = self.infer_Name(node)
elif isinstance(node, gast.List):
# List(expr* elts, expr_context ctx)
elts_ty = [self.infer_expr(e) for e in node.elts]
self.nodetype[node] = TyList(elts_ty)
elif isinstance(node, gast.Tuple):
# Tuple(expr* elts, expr_context ctx)
elts_ty = [self.infer_expr(e) for e in node.elts]
self.nodetype[node] = TyTuple(elts_ty)
assert node in self.nodetype.keys() and \
self.nodetype[node] is not None, type(node).__name__
self.stack.pop()
if self.is_debug: lambda x, y: ast.Subscript(
x,
ast.Index(ast.Constant(y, None)),
ast.Load()),
self.renamings[node.id],def argument_index(self, node):
while isinstance(node, ast.Subscript):
node = node.value
if node in self.aliases:
for n_alias in self.aliases[node]:
try:
return self.current_function.func.args.args.index(n_alias)
except ValueError:
pass
return -1# Compare(expr left, cmpop* ops, expr* comparators)
self.nodetype[node] = TyBool()
elif isinstance(node, gast.Call):
self.nodetype[node] = self.infer_Call(node)
elif isinstance(node, gast.Num):
# Num(object n)
self.nodetype[node] = type_of_value(node.n)
elif isinstance(node, gast.Str):
# Str(string s)
self.nodetype[node] = TyString(value=node.s)
elif isinstance(node, gast.NameConstant):
# NameConstant(singleton value)
self.nodetype[node] = type_of_value(node.value)
elif isinstance(node, gast.Attribute):
self.nodetype[node] = self.infer_Attribute(node)
elif isinstance(node, gast.Subscript):
self.nodetype[node] = self.infer_Subscript(node)
elif isinstance(node, gast.Name):
self.nodetype[node] = self.infer_Name(node)
elif isinstance(node, gast.List):
# List(expr* elts, expr_context ctx)
elts_ty = [self.infer_expr(e) for e in node.elts]
self.nodetype[node] = TyList(elts_ty)
elif isinstance(node, gast.Tuple):
# Tuple(expr* elts, expr_context ctx)
elts_ty = [self.infer_expr(e) for e in node.elts]
self.nodetype[node] = TyTuple(elts_ty)
assert node in self.nodetype.keys() and \
self.nodetype[node] is not None, type(node).__name__
self.stack.pop()
return self.nodetype[node]# A getattr !
else:
self.update = True
call = ast.Call(
ast.Attribute(
ast.Name('__builtin__', ast.Load(), None, None),
'getattr',
ast.Load()),
[node.value, ast.Constant(node.attr, None)],
[])
if isinstance(node.ctx, ast.Store):
# the only situation where this arises is for real/imag of
# a ndarray. As a call is not valid for a store, add a slice
# to ends up with a valid lhs
assert node.attr in ('real', 'imag'), "only store to imag/real"
return ast.Subscript(call,
ast.Slice(None, None, None),
node.ctx)
else:
return callgast
Python AST that abstracts the underlying Python version
