def test_compare(self):
left = ast.Name("x", ast.Load())
comp = ast.Compare(left, [ast.In()], [])
self.expr(comp, "no comparators")
comp = ast.Compare(left, [ast.In()], [ast.Num(4), ast.Num(5)])
self.expr(comp, "different number of comparators and operands")
comp = ast.Compare(ast.Num("blah"), [ast.In()], [left])
self.expr(comp, "non-numeric", exc=TypeError)
comp = ast.Compare(left, [ast.In()], [ast.Num("blah")])
self.expr(comp, "non-numeric", exc=TypeError)
def visit_Compare(self, node):
# cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn
print(" in MyTransformer.visit_Compare()")
print(" node =", node)
print(" op =", node.ops[0])
curr_op = node.ops[0]
comp_negate = curr_op
rand_num = random.randint(1, 10)
if rand_num >= 7:
print(" negating...")
if isinstance(curr_op, ast.Eq): comp_negate = ast.NotEq()
elif isinstance(curr_op, ast.NotEq): comp_negate = ast.Eq()
elif isinstance(curr_op, ast.Lt): comp_negate = ast.GtE()
elif isinstance(curr_op, ast.LtE): comp_negate = ast.Gt()
elif isinstance(curr_op, ast.Gt): comp_negate = ast.LtE()
elif isinstance(curr_op, ast.GtE): comp_negate = ast.Lt()
elif isinstance(curr_op, ast.Is): comp_negate = ast.IsNot()
elif isinstance(curr_op, ast.IsNot): comp_negate = ast.Is()
elif isinstance(curr_op, ast.In): comp_negate = ast.NotIn()
elif isinstance(curr_op, ast.NotIn): comp_negate = ast.In()
else: comp_negate = ast.Eq()
else:
print(" mixing up...")
if isinstance(curr_op, ast.Lt): comp_negate = ast.LtE()
elif isinstance(curr_op, ast.LtE): comp_negate = ast.And()
elif isinstance(curr_op, ast.Gt): comp_negate = ast.Or()
elif isinstance(curr_op, ast.GtE): comp_negate = ast.Gt()
elif isinstance(curr_op, ast.Is): comp_negate = ast.Gt()
elif isinstance(curr_op, ast.IsNot): comp_negate = ast.Lt()
elif isinstance(curr_op, ast.In):
comp_negate = ast.In(
) #leave the same for for loops (for x in this)
elif isinstance(curr_op, ast.NotIn):
comp_negate = ast.Lt()
else:
comp_negate = ast.Eq()
print(" new comparator =", comp_negate)
# create negated node | Compare(expr left, cmpop* ops, expr* comparators)
new_node = node
new_node.ops = [comp_negate]
ast.copy_location(new_node, node)
ast.fix_missing_locations(new_node)
return new_node
def visit_BinOp(self, node):
if isinstance(node.op, ast.NotIn):
return ast.copy_location(
ast.UnaryOp(ast.Not(),
ast.BinOp(node.left, ast.In(), node.right)), node)
return node
def parse_rule_node(self, node):
tag = node.tag
if tag == 'Or':
return self.parse_bool_op(node, ast.Or())
elif tag == 'And':
return self.parse_bool_op(node, ast.And())
elif tag == 'Not':
expr = self.parse_bool_op(node, ast.Or())
return ast.UnaryOp(ast.Not(), expr) if expr else None
elif tag == 'All':
return _ast_const('True')
elif tag == 'Category':
category = node.text
return ast.Compare(left=ast.Str(category),
ops=[ast.In()],
comparators=[
ast.Attribute(value=ast.Name(
id='menuentry', ctx=ast.Load()),
attr='Categories',
ctx=ast.Load())
])
elif tag == 'Filename':
filename = node.text
return ast.Compare(left=ast.Str(filename),
ops=[ast.Eq()],
comparators=[
ast.Attribute(value=ast.Name(
id='menuentry', ctx=ast.Load()),
attr='DesktopFileID',
ctx=ast.Load())
])
def __parseRuleNode(node):
tag = node.tagName
if tag == 'Or':
return __parseBoolOp(node, ast.Or())
elif tag == 'And':
return __parseBoolOp(node, ast.And())
elif tag == 'Not':
expr = __parseBoolOp(node, ast.Or())
return ast.UnaryOp(ast.Not(), expr) if expr else None
elif tag == 'All':
return ast.Name('True', ast.Load())
elif tag == 'Category':
category = _get_node_text(node)
return ast.Compare(left=ast.Str(category),
ops=[ast.In()],
comparators=[
ast.Attribute(value=ast.Name(id='menuentry',
ctx=ast.Load()),
attr='Categories',
ctx=ast.Load())
])
elif tag == 'Filename':
filename = _get_node_text(node)
return ast.Compare(left=ast.Str(filename),
ops=[ast.Eq()],
comparators=[
ast.Attribute(value=ast.Name(id='menuentry',
ctx=ast.Load()),
attr='DesktopFileID',
ctx=ast.Load())
])
def to_node(self):
if len(self.operator) == 0:
return self.left.to_node()
else:
right_nodes = []
comp_operator = []
for i in range(len(self.right)):
right_nodes.append(self.right[i].to_node())
if self.operator[i] in ['<', 'is lower than']:
comp_operator.append(ast.Lt())
elif self.operator[i] in ['<=', 'is lower or equal to']:
comp_operator.append(ast.LtE())
elif self.operator[i] in ['>', 'is greater than']:
comp_operator.append(ast.Gt())
elif self.operator[i] in ['>=', 'is greater or equal to']:
comp_operator.append(ast.GtE())
elif self.operator[i] in ['==', 'is equal to']:
comp_operator.append(ast.Eq())
elif self.operator[i] in ['!=', 'is different from',
'is not equal to']:
comp_operator.append(ast.NotEq())
elif self.operator[i] == 'in':
comp_operator.append(ast.In())
elif self.operator[i] == 'not in':
comp_operator.append(ast.NotIn())
elif self.operator[i] == 'is':
comp_operator.append(ast.Is())
elif self.operator[i] == 'is not':
comp_operator.append(ast.IsNot())
else:
raise Exception("Unrecognized argument in Comparison")
return ast.Compare(left=self.left.to_node(), ops=comp_operator,
comparators=right_nodes)
def as_ast(self, ast_state):
attr = ast.Attribute(ast.Name('shape', ast.Load()), 'type', ast.Load())
geom_types = map_geom_type(self.geom_type)
geom_types_ast = map(ast.Str, geom_types)
result = ast.Compare(attr, [ast.In()],
[ast.Tuple(geom_types_ast, ast.Load())])
return result
def visit_Name(self, name):
# Check if the name is local or not.
locs = ast.Call(self.builtin("locals"), [], [], None, None)
globs = ast.Call(self.builtin("globals"), [], [], None, None)
ops = [ast.In(), ast.IsNot()]
test = ast.Compare(ast.Str(name.id), ops, [locs, globs])
expr = ast.IfExp(test, self.display(name), ast.Str(name.id))
return name, self.explanation_param(expr)
def visit_Name(self, name):
# Display the repr of the name if it's a local variable or
# _should_repr_global_name() thinks it's acceptable.
locs = ast_Call(self.builtin("locals"), [], [])
inlocs = ast.Compare(ast.Str(name.id), [ast.In()], [locs])
dorepr = self.helper("should_repr_global_name", name)
test = ast.BoolOp(ast.Or(), [inlocs, dorepr])
expr = ast.IfExp(test, self.display(name), ast.Str(name.id))
return name, self.explanation_param(expr)
def test_multi_in_array(self):
assert self.run([
ast.Compare(
ast.Num(1), [ast.In()],
[ast.List([
ast.Num(1),
ast.Num(2),
ast.Num(3),
], ast.Load())]),
], None, bool) is True
def ast(self):
if self.implicit_equality:
return ast.Compare(left=self._field.ast(),
ops=[ast.Eq()],
comparators=[e.ast() for e in self.compare_to])
else:
comparator = ast.List([e.ast() for e in self.compare_to],
ast.Load())
return ast.Compare(left=self._field.ast(),
ops=[ast.In()],
comparators=[comparator])
def CmpOp_NotIn(self, left, comparator):
self.visit(
ast.UnaryOp(
ast.Not(),
ast.Compare(
left,
[ast.In()],
[comparator]
)
)
)
def test_multi_in_dict(self):
assert self.run([
ast.Compare(ast.Str('a'), [ast.In()], [
ast.Dict([
ast.Str('a'),
ast.Str('b'),
ast.Str('c'),
], [
ast.Num(1),
ast.Num(2),
ast.Num(3),
])
]),
], None, bool) is True
def p_comp_op(p):
'''comp_op : ">"
| "<"
| OP_EQ
| OP_GE
| OP_LE
| OP_NE
| OP_NNE
| TAG_IN
| TAG_NOT TAG_IN
| TAG_IS
| TAG_IS TAG_NOT'''
if len(p) == 2:
if p.get_item(1).type == 'OP_EQ':
p[0] = ast.Eq()
elif p.get_item(1).type == '>':
p[0] = ast.Gt()
elif p.get_item(1).type == '<':
p[0] = ast.Lt()
elif p.get_item(1).type == 'OP_GE':
p[0] = ast.GtE()
elif p.get_item(1).type == 'OP_LE':
p[0] = ast.LtE()
elif p.get_item(1).type == 'OP_NE':
p[0] = ast.NotEq()
elif p.get_item(1).type == 'OP_NNE':
p[0] = ast.NotEq()
elif p[1] == 'is':
p[0] = ast.Is()
elif p[1] == 'in':
p[0] = ast.In()
elif len(p) == 3:
if p[1] == 'is':
p[0] = ast.IsNot()
elif p[1] == 'not':
p[0] = ast.NotIn()
return
def compute_loop_condition(self, loop_header_node):
assert (self.is_loop_header(loop_header_node))
loop_statement = loop_header_node.statements[0]
if isinstance(loop_statement, ast.For):
iterator = loop_statement.iter
var = loop_statement.target
return ast.Compare(left=var, ops=[ast.In()], comparators=[iterator])
if isinstance(loop_statement, ast.While):
return loop_statement.test
return None
def compute_loop_condition(self, loop_header_stmt):
assert (isinstance(loop_header_stmt, ast.For)
or isinstance(loop_header_stmt, ast.While))
if isinstance(loop_header_stmt, ast.While):
return loop_header_stmt.test
if isinstance(loop_header_stmt, ast.For):
iterator = loop_header_stmt.iter
var = loop_header_stmt.target
loop_condition = ast.Compare(left=var,
ops=[ast.In()],
comparators=[iterator])
loop_condition.lineno = loop_header_stmt.lineno
return loop_condition
class Infix(Symbol):
rightAssoc = False
_operator_map = {
"in": ast.In(),
">": ast.Gt(),
"<": ast.Lt(),
"=": ast.Eq()
}
_logical_map = {"and": ast.And(), "or": ast.Or()}
def led(self, left):
self.first = left
rbp = self.lbp - int(self.rightAssoc)
self.second = self.parser.expression(rbp)
return self
def __repr__(self):
return "<'%s'>(%s, %s)" % (self.value, self.first, self.second)
def ast(self, context=None):
lhs = self.first.ast(context)
if self.second:
rhs = self.second.ast(context)
if self.value in self._logical_map:
return ast.BoolOp(op=self._logical_map[self.value],
values=[lhs, rhs])
else:
path = list(context.stack)
path.append(self.first.value)
return ast.Call(
func=ast.Name(id="filter_field", ctx=ast.Load()),
args=[
ast.Name(id="obj", ctx=ast.Load()),
ast.List(elts=[ast.Str(s=i) for i in path],
ctx=ast.Load()),
ast.Str(s=self.value),
rhs,
],
keywords=[],
)
return ast.Name(id="not", ctx=ast.Load())
def __build_conditional_arg_check(self, argname, argtype):
target_value = ast.Subscript(value=ast.Name(id='kwargs',
ctx=ast.Load()),
slice=ast.Index(ast.Str(s=argname)),
ctx=ast.Load())
presence_check = ast.Call(func=ast.Name(id='isinstance',
ctx=ast.Load()),
args=[target_value, argtype],
keywords=[],
lineno=self.__get_line())
# Assumes that argtype is a ast.Tuple of ast.Name items
types = [t.id for t in argtype.elts]
check_message = ast.BinOp(left=ast.Str(
s='Optional argument \'{}\' must be of type \'{}\'. Received type: \'%s\''
.format(argname, types)),
op=ast.Mod(),
right=ast.Call(func=ast.Name(id='type',
ctx=ast.Load()),
args=[target_value],
keywords=[]),
lineno=self.__get_line())
assert_check = ast.Assert(test=presence_check,
msg=check_message,
lineno=self.__get_line())
check_body = [assert_check]
check = ast.Compare(
left=ast.Str(s=argname, ctx=ast.Load()),
ops=[ast.In()],
comparators=[ast.Name(id='kwargs', ctx=ast.Load())])
new_ret = ast.If(test=check,
body=check_body,
orelse=[],
lineno=self.__get_line())
return new_ret
def visit_Compare(self, node):
# TODO: Implement or/and.
if len(node.ops) > 1:
return node
if isinstance(node.ops[0], ast.In):
return ast.BinOp(left=node.left,
op=ast.LShift(),
right=node.comparators[0])
if isinstance(node.ops[0], ast.Eq):
return ast.BinOp(left=node.left,
op=ast.LShift(),
right=ast.Set(node.comparators))
if isinstance(node.ops[0], ast.NotIn):
node_copy = copy.deepcopy(node)
node_copy.ops[0] = ast.In()
return ast.UnaryOp(op=ast.Invert(),
operand=self.visit_Compare(node_copy))
if isinstance(node.ops[0], ast.NotEq):
node_copy = copy.deepcopy(node)
node_copy.ops[0] = ast.Eq()
return ast.UnaryOp(op=ast.Invert(),
operand=self.visit_Compare(node_copy))
return node
def visit_CmpOp(self, node: CmpOp, *args, **kwargs) -> C.cmpop:
if node == CmpOp.Eq:
return C.Eq()
elif node == CmpOp.NotEq:
return C.NotEq()
elif node == CmpOp.Lt:
return C.Lt()
elif node == CmpOp.Lte:
return C.Lte()
elif node == CmpOp.Gt:
return C.Gt()
elif node == CmpOp.Gte:
return C.Gte()
elif node == CmpOp.Is:
return C.Is()
elif node == CmpOp.IsNot:
return C.IsNot()
elif node == CmpOp.In:
return C.In()
elif node == CmpOp.NotIn:
return C.NotIn()
else:
raise Exception(f'unknown CmpOp {node!r}')
def __init__(self, str, lineno=0):
self.value = str
self.lineno = lineno
op_ast_map = {
'+': ast.Add(),
'-': ast.Sub(),
'*': ast.Mult(),
'/': ast.Div(),
'%': ast.Mod(),
'**': ast.Pow(),
'<<': ast.LShift(),
'>>': ast.RShift(),
'|': ast.BitOr(),
'^^': ast.BitXor(),
'&&': ast.BitAnd(),
'//': ast.FloorDiv(),
'==': ast.Eq(),
'!=': ast.NotEq(),
'<': ast.Lt(),
'<=': ast.LtE(),
'>': ast.Gt(),
'>=': ast.GtE(),
'is': ast.Is(),
'is_not': ast.IsNot(),
'in': ast.In(),
'not_in': ast.NotIn(),
'and': ast.And(),
'or': ast.Or()
}
def as_ast(dct):
"""See https://docs.python.org/2/library/ast.html"""
if dct['ast_type'] == "Module":
return ast.Module(dct["body"])
elif dct['ast_type'] == "Interactive":
return ast.Interactive(dct["body"])
elif dct['ast_type'] == "Expression":
return ast.Expression(dct["body"])
elif dct['ast_type'] == "Suite":
return ast.Suite(dct["body"])
elif dct['ast_type'] == "FunctionDef":
return ast.FunctionDef(dct["name"], dct["args"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "ClassDef":
return ast.ClassDef(dct["name"], dct["bases"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "Return":
return ast.Return(dct["value"])
elif dct['ast_type'] == "Delete":
return ast.Delete(dct["targets"])
elif dct['ast_type'] == "Assign":
return ast.Assign(dct["targets"], dct["value"])
elif dct['ast_type'] == "AugAssign":
return ast.AugAssign(dct["target"], dct["op"], dct["value"])
elif dct['ast_type'] == "Print":
return ast.Print(dct["dest"], dct["values"], dct["nl"])
elif dct['ast_type'] == "For":
return ast.For(dct["target"], dct["iter"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "While":
return ast.While(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "If":
return ast.If(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "With":
return ast.With(dct["context_expr"], dct["optional_vars"], dct["body"])
elif dct['ast_type'] == "Raise":
return ast.Raise(dct["type"], dct["inst"], dct["tback"])
elif dct['ast_type'] == "TryExcept":
return ast.TryExcept(dct["body"], dct["handlers"], dct["orelse"])
elif dct['ast_type'] == "TryFinally":
return ast.TryFinally(dct["body"], dct["finalbody"])
elif dct['ast_type'] == "Assert":
return ast.Assert(dct["test"], dct["msg"])
elif dct['ast_type'] == "Import":
return ast.Import(dct["names"])
elif dct['ast_type'] == "ImportFrom":
return ast.ImportFrom(dct["module"], dct["names"], dct["level"])
elif dct['ast_type'] == "Exec":
return ast.Exec(dct["body"], dct["globals"], dct["locals"])
elif dct['ast_type'] == "Global":
return ast.Global(dct["names"])
elif dct['ast_type'] == "Expr":
return ast.Expr(dct["value"])
elif dct['ast_type'] == "Pass":
return ast.Pass()
elif dct['ast_type'] == "Break":
return ast.Break()
elif dct['ast_type'] == "Continue":
return ast.Continue()
elif dct['ast_type'] == "BoolOp":
return ast.BoolOp(dct["op"], dct["values"])
elif dct['ast_type'] == "BinOp":
return ast.BinOp(dct["left"], dct["op"], dct["right"])
elif dct['ast_type'] == "UnaryOp":
return ast.UnaryOp(dct["op"], dct["operand"])
elif dct['ast_type'] == "Lambda":
return ast.Lambda(dct["args"], dct["body"])
elif dct['ast_type'] == "IfExp":
return ast.IfExp(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "Dict":
return ast.Dict(dct["keys"], dct["values"])
elif dct['ast_type'] == "Set":
return ast.Set(dct["elts"])
elif dct['ast_type'] == "ListComp":
return ast.ListComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "SetComp":
return ast.SetComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "DictComp":
return ast.DictComp(dct["key"], dct["value"], dct["generators"])
elif dct['ast_type'] == "GeneratorExp":
return ast.GeneratorExp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "Yield":
return ast.Yield(dct["value"])
elif dct['ast_type'] == "Compare":
return ast.Compare(dct["left"], dct["ops"], dct["comparators"])
elif dct['ast_type'] == "Call":
return ast.Call(dct["func"], dct["args"], dct["keywords"],
dct["starargs"], dct["kwargs"])
elif dct['ast_type'] == "Repr":
return ast.Repr(dct["value"])
elif dct['ast_type'] == "Num":
return ast.Num(dct["n"])
elif dct['ast_type'] == "Str":
# Converting to ASCII
return ast.Str(dct["s"].encode('ascii', 'ignore'))
elif dct['ast_type'] == "Attribute":
return ast.Attribute(dct["value"], dct["attr"], dct["ctx"])
elif dct['ast_type'] == "Subscript":
return ast.Subscript(dct["value"], dct["slice"], dct["ctx"])
elif dct['ast_type'] == "Name":
return ast.Name(dct["id"], dct["ctx"])
elif dct['ast_type'] == "List":
return ast.List(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Tuple":
return ast.Tuple(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Load":
return ast.Load()
elif dct['ast_type'] == "Store":
return ast.Store()
elif dct['ast_type'] == "Del":
return ast.Del()
elif dct['ast_type'] == "AugLoad":
return ast.AugLoad()
elif dct['ast_type'] == "AugStore":
return ast.AugStore()
elif dct['ast_type'] == "Param":
return ast.Param()
elif dct['ast_type'] == "Ellipsis":
return ast.Ellipsis()
elif dct['ast_type'] == "Slice":
return ast.Slice(dct["lower"], dct["upper"], dct["step"])
elif dct['ast_type'] == "ExtSlice":
return ast.ExtSlice(dct["dims"])
elif dct['ast_type'] == "Index":
return ast.Index(dct["value"])
elif dct['ast_type'] == "And":
return ast.And()
elif dct['ast_type'] == "Or":
return ast.Or()
elif dct['ast_type'] == "Add":
return ast.Add()
elif dct['ast_type'] == "Sub":
return ast.Sub()
elif dct['ast_type'] == "Mult":
return ast.Mult()
elif dct['ast_type'] == "Div":
return ast.Div()
elif dct['ast_type'] == "Mod":
return ast.Mod()
elif dct['ast_type'] == "Pow":
return ast.Pow()
elif dct['ast_type'] == "LShift":
return ast.LShift()
elif dct['ast_type'] == "RShift":
return ast.RShift()
elif dct['ast_type'] == "BitOr":
return ast.BitOr()
elif dct['ast_type'] == "BitXor":
return ast.BitXor()
elif dct['ast_type'] == "BitAnd":
return ast.BitAnd()
elif dct['ast_type'] == "FloorDiv":
return ast.FloorDiv()
elif dct['ast_type'] == "Invert":
return ast.Invert()
elif dct['ast_type'] == "Not":
return ast.Not()
elif dct['ast_type'] == "UAdd":
return ast.UAdd()
elif dct['ast_type'] == "USub":
return ast.USub()
elif dct['ast_type'] == "Eq":
return ast.Eq()
elif dct['ast_type'] == "NotEq":
return ast.NotEq()
elif dct['ast_type'] == "Lt":
return ast.Lt()
elif dct['ast_type'] == "LtE":
return ast.LtE()
elif dct['ast_type'] == "Gt":
return ast.Gt()
elif dct['ast_type'] == "GtE":
return ast.GtE()
elif dct['ast_type'] == "Is":
return ast.Is()
elif dct['ast_type'] == "IsNot":
return ast.IsNot()
elif dct['ast_type'] == "In":
return ast.In()
elif dct['ast_type'] == "NotIn":
return ast.NotIn()
elif dct['ast_type'] == "comprehension":
return ast.comprehension(dct["target"], dct["iter"], dct["ifs"])
elif dct['ast_type'] == "ExceptHandler":
return ast.ExceptHandler(dct["type"], dct["name"], dct["body"])
elif dct['ast_type'] == "arguments":
return ast.arguments(dct["args"], dct["vararg"], dct["kwarg"],
dct["defaults"])
elif dct['ast_type'] == "keyword":
return ast.keyword(dct["arg"], dct["value"])
elif dct['ast_type'] == "alias":
return ast.alias(dct["name"], dct["asname"])
else:
return dct
def _compile_directive_call_assets(self, el, options):
""" This special 't-call' tag can be used in order to aggregate/minify javascript and css assets"""
if len(el):
raise SyntaxError("t-call-assets cannot contain children nodes")
# nodes = self._get_asset(xmlid, options, css=css, js=js, debug=values.get('debug'), async=async, values=values)
#
# for index, (tagName, t_attrs, content) in enumerate(nodes):
# if index:
# append('\n ')
# append('<')
# append(tagName)
#
# self._post_processing_att(tagName, t_attrs, options)
# for name, value in t_attrs.items():
# if value or isinstance(value, string_types)):
# append(u' ')
# append(name)
# append(u'="')
# append(escape(pycompat.to_text((value)))
# append(u'"')
#
# if not content and tagName in self._void_elements:
# append('/>')
# else:
# append('>')
# if content:
# append(content)
# append('</')
# append(tagName)
# append('>')
#
space = el.getprevious() is not None and el.getprevious(
).tail or el.getparent().text
sep = u'\n' + space.rsplit('\n').pop()
return [
ast.Assign(
targets=[ast.Name(id='nodes', ctx=ast.Store())],
value=ast.Call(
func=ast.Attribute(value=ast.Name(id='self',
ctx=ast.Load()),
attr='_get_asset_nodes',
ctx=ast.Load()),
args=[
ast.Str(el.get('t-call-assets')),
ast.Name(id='options', ctx=ast.Load()),
],
keywords=[
ast.keyword('css',
self._get_attr_bool(el.get('t-css',
True))),
ast.keyword('js',
self._get_attr_bool(el.get('t-js', True))),
ast.keyword(
'debug',
ast.Call(func=ast.Attribute(value=ast.Name(
id='values', ctx=ast.Load()),
attr='get',
ctx=ast.Load()),
args=[ast.Str('debug')],
keywords=[],
starargs=None,
kwargs=None)),
ast.keyword(
'_async',
self._get_attr_bool(el.get('async', False))),
ast.keyword('values',
ast.Name(id='values', ctx=ast.Load())),
],
starargs=None,
kwargs=None)),
ast.For(
target=ast.Tuple(elts=[
ast.Name(id='index', ctx=ast.Store()),
ast.Tuple(elts=[
ast.Name(id='tagName', ctx=ast.Store()),
ast.Name(id='t_attrs', ctx=ast.Store()),
ast.Name(id='content', ctx=ast.Store())
],
ctx=ast.Store())
],
ctx=ast.Store()),
iter=ast.Call(func=ast.Name(id='enumerate', ctx=ast.Load()),
args=[ast.Name(id='nodes', ctx=ast.Load())],
keywords=[],
starargs=None,
kwargs=None),
body=[
ast.If(test=ast.Name(id='index', ctx=ast.Load()),
body=[self._append(ast.Str(sep))],
orelse=[]),
self._append(ast.Str(u'<')),
self._append(ast.Name(id='tagName', ctx=ast.Load())),
] + self._append_attributes() + [
ast.If(test=ast.BoolOp(
op=ast.And(),
values=[
ast.UnaryOp(ast.Not(),
ast.Name(id='content', ctx=ast.Load()),
lineno=0,
col_offset=0),
ast.Compare(
left=ast.Name(id='tagName', ctx=ast.Load()),
ops=[ast.In()],
comparators=[
ast.Attribute(value=ast.Name(
id='self', ctx=ast.Load()),
attr='_void_elements',
ctx=ast.Load())
]),
]),
body=[self._append(ast.Str(u'/>'))],
orelse=[
self._append(ast.Str(u'>')),
ast.If(test=ast.Name(id='content',
ctx=ast.Load()),
body=[
self._append(
ast.Name(id='content',
ctx=ast.Load()))
],
orelse=[]),
self._append(ast.Str(u'</')),
self._append(
ast.Name(id='tagName', ctx=ast.Load())),
self._append(ast.Str(u'>')),
])
],
orelse=[])
]
def visit_Delete(self, node):
"""
This converter replaces bare deletes with conditional global pops.
It is roughly equivalent to transforming:
.. code:: python
del foobar
into:
.. code:: python
if 'foobar' in globals():
globals().pop('foobar')
else:
del foobar
This thus makes deletions in retain mode work more-or-less as intended.
"""
return ast.If(
test=ast.NameConstant(
value=True, # if True; aka unconditional, will be optimized out
lineno=node.lineno,
col_offset=node.col_offset
),
body=[
ast.If(
# if 'x' in globals():
test=ast.Compare(
# 'x'
left=ast.Str(
s=target.id,
lineno=node.lineno,
col_offset=node.col_offset
),
ops=[
# in
ast.In(
lineno=node.lineno,
col_offset=node.col_offset
)
],
comparators=[
# globals()
self.globals_call(node)
],
lineno=node.lineno,
col_offset=node.col_offset
),
body=[
ast.Expr(
# globals().pop('x')
value=ast.Call(
# globals().pop
func=ast.Attribute(
value=self.globals_call(node),
attr='pop',
ctx=ast.Load(),
lineno=node.lineno,
col_offset=node.col_offset
),
args=[
# 'x'
ast.Str(
s=target.id,
lineno=node.lineno,
col_offset=node.col_offset
)
],
keywords=[],
lineno=node.lineno,
col_offset=node.col_offset
),
lineno=node.lineno,
col_offset=node.col_offset
)
],
# else:
orelse=[
# del x
ast.Delete(
targets=[target],
lineno=node.lineno,
col_offset=node.col_offset
)
],
lineno=node.lineno,
col_offset=node.col_offset
)
if isinstance(target, ast.Name) else
ast.Delete(
targets=[target],
lineno=node.lineno,
col_offset=node.col_offset
)
# for each target to be deleted, e.g. `del {x}, {y}, {z}`
for target in node.targets
],
orelse=[],
lineno=node.lineno,
col_offset=node.col_offset
)
def __build_function(self, dom_name, full_name, func_params):
assert 'name' in func_params
func_name = func_params['name']
docstr = self.__build_desc_string(dom_name, func_name, func_params)
args = [ast.arg('self', None)]
message_params = []
func_body = []
if docstr:
func_body.append(ast.Expr(ast.Str("\n"+docstr+"\n\t\t")))
for param in func_params.get("parameters", []):
argname = param['name']
param_optional = param.get("optional", False)
if param_optional is False:
message_params.append(ast.keyword(argname, ast.Name(id=argname, ctx=ast.Load())))
args.append(ast.arg(argname, None))
if self.do_debug_prints:
func_body.append(self.__build_debug_print(argname, argname))
param_type = param.get("type", None)
if param_type in CHECKS:
if param_optional:
check = self.__build_conditional_arg_check(argname, CHECKS[param_type])
else:
check = self.__build_unconditional_arg_check(argname, CHECKS[param_type])
if check:
func_body.append(check)
optional_params = [param.get("name") for param in func_params.get("parameters", []) if param.get("optional", False)]
func_kwargs = None
if len(optional_params):
value = ast.List(elts=[ast.Str(s=param, ctx=ast.Store()) for param in optional_params], ctx=ast.Load())
create_list = ast.Assign(targets=[ast.Name(id='expected', ctx=ast.Store())], value=value)
func_body.append(create_list)
passed_arg_list = ast.Assign(targets=[ast.Name(id='passed_keys', ctx=ast.Store())],
value=ast.Call(func=ast.Name(id='list', ctx=ast.Load()),
args=[ast.Call(func=ast.Attribute(value=ast.Name(id='kwargs', ctx=ast.Load()), attr='keys', ctx=ast.Load()), args=[], keywords=[])],
keywords=[]))
func_body.append(passed_arg_list)
comprehension = ast.comprehension(target=ast.Name(id='key', ctx=ast.Store()), iter=ast.Name(id='passed_keys', ctx=ast.Load()), ifs=[], is_async=False)
comparator = ast.Name(id='expected', ctx=ast.Load())
listcomp = ast.ListComp(elt=ast.Compare(left=ast.Name(id='key', ctx=ast.Load()), ops=[ast.In()], comparators=[comparator]), generators=[comprehension])
check_message = ast.BinOp(
left = ast.Str(s="Allowed kwargs are {}. Passed kwargs: %s".format(optional_params)),
op = ast.Mod(),
right = ast.Name(id='passed_keys', ctx=ast.Load()),
lineno = self.__get_line())
kwarg_check = ast.Assert(test=ast.Call(func=ast.Name(id='all', ctx=ast.Load()), args=[listcomp], keywords=[]), msg=check_message)
func_body.append(kwarg_check)
func_kwargs = ast.Name(id='kwargs', ctx=ast.Load())
fname = "{}.{}".format(dom_name, func_name)
fname = ast.Str(s=fname, ctx=ast.Load())
if (sys.version_info[0], sys.version_info[1]) == (3, 5) or \
(sys.version_info[0], sys.version_info[1]) == (3, 6):
# More irritating minor semantic differences in the AST between 3.4 and 3.5
if func_kwargs:
message_params.append(ast.keyword(arg=None, value=ast.Name(id='kwargs', ctx=ast.Load())))
communicate_call = ast.Call(
func=ast.Attribute(value=ast.Name(id='self', ctx=ast.Load()), ctx=ast.Load(), attr='synchronous_command'),
args=[fname],
keywords=message_params)
elif (sys.version_info[0], sys.version_info[1]) == (3,4):
communicate_call = ast.Call(
func=ast.Attribute(value=ast.Name(id='self', ctx=ast.Load()), ctx=ast.Load(), attr='synchronous_command'),
args=[fname],
kwargs=func_kwargs,
keywords=message_params)
else:
print("Version:", sys.version_info)
raise RuntimeError("This script only functions on python 3.4, 3.5 or 3.6. Active python version {}.{}".format(*sys.version_info))
do_communicate = ast.Assign(targets=[ast.Name(id='subdom_funcs', ctx=ast.Store())], value=communicate_call)
func_ret = ast.Return(value=ast.Name(id='subdom_funcs', ctx=ast.Load()))
if len(optional_params) and self.do_debug_prints:
func_body.append(self.__build_debug_print('kwargs', 'kwargs'))
func_body.append(do_communicate)
func_body.append(func_ret)
if len(optional_params):
kwarg = ast.arg(arg='kwargs', annotation=None)
else:
kwarg = None
sig = ast.arguments(
args=args,
vararg=None,
varargannotation=None,
kwonlyargs=[],
kwarg=kwarg,
kwargannotation=None,
defaults=[],
kw_defaults=[])
func = ast.FunctionDef(
name = "{}_{}".format(full_name, func_name),
args = sig,
body = func_body,
decorator_list = [],
lineno = self.__get_line(),
col_offset = 0,
)
return func
def from_phpast(node):
if node is None:
return py.Pass(**pos(node))
if isinstance(node, str):
return py.Str(node, **pos(node))
if isinstance(node, (int, float)):
return py.Num(node, **pos(node))
if isinstance(node, php.Array):
if node.nodes:
if node.nodes[0].key is not None:
keys = []
values = []
for elem in node.nodes:
keys.append(from_phpast(elem.key))
values.append(from_phpast(elem.value))
return py.Dict(keys, values, **pos(node))
else:
return py.List([from_phpast(x.value) for x in node.nodes],
py.Load(**pos(node)), **pos(node))
else:
return py.List([], py.Load(**pos(node)), **pos(node))
if isinstance(node, php.InlineHTML):
args = [py.Str(node.data, **pos(node))]
return py.Call(
py.Name('inline_html', py.Load(**pos(node)), **pos(node)), args,
[], None, None, **pos(node))
if isinstance(node, php.Echo):
return py.Call(py.Name('echo', py.Load(**pos(node)), **pos(node)),
list(map(from_phpast, node.nodes)), [], None, None,
**pos(node))
if isinstance(node, php.Print):
return py.Print(None, [from_phpast(node.node)], True, **pos(node))
if isinstance(node, php.Exit):
args = []
if node.expr is not None:
args.append(from_phpast(node.expr))
return py.Raise(
py.Call(py.Name('Exit', py.Load(**pos(node)), **pos(node)), args,
[], None, None, **pos(node)), None, None, **pos(node))
if isinstance(node, php.Return):
if node.node is None:
return py.Return(None, **pos(node))
else:
return py.Return(from_phpast(node.node), **pos(node))
if isinstance(node, php.Break):
assert node.node is None, 'level on break not supported'
return py.Break(**pos(node))
if isinstance(node, php.Continue):
assert node.node is None, 'level on continue not supported'
return py.Continue(**pos(node))
if isinstance(node, php.Silence):
return from_phpast(node.expr)
if isinstance(node, php.Block):
return from_phpast(php.If(1, node, [], None, lineno=node.lineno))
if isinstance(node, php.Unset):
return py.Delete(list(map(from_phpast, node.nodes)), **pos(node))
if isinstance(node, php.IsSet) and len(node.nodes) == 1:
if isinstance(node.nodes[0], php.ArrayOffset):
return py.Compare(from_phpast(node.nodes[0].expr),
[py.In(**pos(node))],
[from_phpast(node.nodes[0].node)], **pos(node))
if isinstance(node.nodes[0], php.ObjectProperty):
return py.Call(
py.Name('hasattr', py.Load(**pos(node)), **pos(node)), [
from_phpast(node.nodes[0].node),
from_phpast(node.nodes[0].name)
], [], None, None, **pos(node))
if isinstance(node.nodes[0], php.Variable):
return py.Compare(py.Str(
node.nodes[0].name[1:], **pos(node)), [py.In(**pos(node))], [
py.Call(py.Name('vars', py.Load(**pos(node)), **pos(node)),
[], [], None, None, **pos(node))
], **pos(node))
return py.Compare(from_phpast(node.nodes[0]), [py.IsNot(**pos(node))],
[py.Name('None', py.Load(**pos(node)), **pos(node))],
**pos(node))
if isinstance(node, php.Empty):
return from_phpast(
php.UnaryOp('!',
php.BinaryOp('&&',
php.IsSet([node.expr],
lineno=node.lineno),
node.expr,
lineno=node.lineno),
lineno=node.lineno))
if isinstance(node, php.Assignment):
if (isinstance(node.node, php.ArrayOffset) and node.node.expr is None):
return py.Call(
py.Attribute(from_phpast(node.node.node), 'append',
py.Load(**pos(node)), **pos(node)),
[from_phpast(node.expr)], [], None, None, **pos(node))
if (isinstance(node.node, php.ObjectProperty)
and isinstance(node.node.name, php.BinaryOp)):
return to_stmt(
py.Call(py.Name('setattr', py.Load(**pos(node)), **pos(node)),
[
from_phpast(node.node.node),
from_phpast(node.node.name),
from_phpast(node.expr)
], [], None, None, **pos(node)))
return py.Assign([store(from_phpast(node.node))],
from_phpast(node.expr), **pos(node))
if isinstance(node, php.ListAssignment):
return py.Assign([
py.Tuple(list(map(store, list(map(from_phpast, node.nodes)))),
py.Store(**pos(node)), **pos(node))
], from_phpast(node.expr), **pos(node))
if isinstance(node, php.AssignOp):
return from_phpast(
php.Assignment(node.left,
php.BinaryOp(node.op[:-1],
node.left,
node.right,
lineno=node.lineno),
False,
lineno=node.lineno))
if isinstance(node, (php.PreIncDecOp, php.PostIncDecOp)):
return from_phpast(
php.Assignment(node.expr,
php.BinaryOp(node.op[0],
node.expr,
1,
lineno=node.lineno),
False,
lineno=node.lineno))
if isinstance(node, php.ArrayOffset):
return py.Subscript(from_phpast(node.node),
py.Index(from_phpast(node.expr), **pos(node)),
py.Load(**pos(node)), **pos(node))
if isinstance(node, php.ObjectProperty):
if isinstance(node.name, (php.Variable, php.BinaryOp)):
return py.Call(
py.Name('getattr', py.Load(**pos(node)), **pos(node)),
[from_phpast(node.node),
from_phpast(node.name)], [], None, None, **pos(node))
return py.Attribute(from_phpast(node.node), node.name,
py.Load(**pos(node)), **pos(node))
if isinstance(node, php.Constant):
name = node.name
if name.lower() == 'true': name = 'True'
if name.lower() == 'false': name = 'False'
if name.lower() == 'null': name = 'None'
return py.Name(name, py.Load(**pos(node)), **pos(node))
if isinstance(node, php.Variable):
name = node.name[1:]
if name == 'this': name = 'self'
return py.Name(name, py.Load(**pos(node)), **pos(node))
if isinstance(node, php.Global):
return py.Global([var.name[1:] for var in node.nodes], **pos(node))
if isinstance(node, php.Include):
once = py.Name('True' if node.once else 'False', py.Load(**pos(node)),
**pos(node))
return py.Call(py.Name('include', py.Load(**pos(node)), **pos(node)),
[from_phpast(node.expr), once], [], None, None,
**pos(node))
if isinstance(node, php.Require):
once = py.Name('True' if node.once else 'False', py.Load(**pos(node)),
**pos(node))
return py.Call(py.Name('require', py.Load(**pos(node)), **pos(node)),
[from_phpast(node.expr), once], [], None, None,
**pos(node))
if isinstance(node, php.UnaryOp):
op = unary_ops.get(node.op)
assert op is not None, "unknown unary operator: '%s'" % node.op
op = op(**pos(node))
return py.UnaryOp(op, from_phpast(node.expr), **pos(node))
if isinstance(node, php.BinaryOp):
if node.op == '.':
pattern, pieces = build_format(node.left, node.right)
if pieces:
return py.BinOp(
py.Str(pattern, **pos(node)), py.Mod(**pos(node)),
py.Tuple(list(map(from_phpast, pieces)),
py.Load(**pos(node)), **pos(node)), **pos(node))
else:
return py.Str(pattern % (), **pos(node))
if node.op in bool_ops:
op = bool_ops[node.op](**pos(node))
return py.BoolOp(op,
[from_phpast(node.left),
from_phpast(node.right)], **pos(node))
if node.op in cmp_ops:
op = cmp_ops[node.op](**pos(node))
return py.Compare(from_phpast(node.left), [op],
[from_phpast(node.right)], **pos(node))
op = binary_ops.get(node.op)
if node.op == 'instanceof':
return py.Call(
func=py.Name(id='isinstance', ctx=py.Load(**pos(node))),
args=[from_phpast(node.left),
from_phpast(node.right)],
keywords=[],
starargs=None,
kwargs=None)
assert op is not None, "unknown binary operator: '%s'" % node.op
op = op(**pos(node))
return py.BinOp(from_phpast(node.left), op, from_phpast(node.right),
**pos(node))
if isinstance(node, php.TernaryOp):
return py.IfExp(from_phpast(node.expr), from_phpast(node.iftrue),
from_phpast(node.iffalse), **pos(node))
if isinstance(node, php.Cast):
return py.Call(
py.Name(casts.get(node.type, node.type), py.Load(**pos(node)),
**pos(node)), [from_phpast(node.expr)], [], None, None,
**pos(node))
if isinstance(node, php.If):
orelse = []
if node.else_:
for else_ in map(from_phpast, deblock(node.else_.node)):
orelse.append(to_stmt(else_))
for elseif in reversed(node.elseifs):
orelse = [
py.If(
from_phpast(elseif.expr),
list(
map(to_stmt,
list(map(from_phpast, deblock(elseif.node))))),
orelse, **pos(node))
]
return py.If(
from_phpast(node.expr),
list(map(to_stmt, list(map(from_phpast, deblock(node.node))))),
orelse, **pos(node))
if isinstance(node, php.For):
assert node.test is None or len(node.test) == 1, \
'only a single test is supported in for-loops'
return from_phpast(
php.Block((node.start or []) + [
php.While(node.test[0] if node.test else 1,
php.Block(deblock(node.node) + (node.count or []),
lineno=node.lineno),
lineno=node.lineno)
],
lineno=node.lineno))
if isinstance(node, php.Foreach):
if node.keyvar is None:
target = py.Name(node.valvar.name[1:], py.Store(**pos(node)),
**pos(node))
else:
target = py.Tuple([
py.Name(node.keyvar.name[1:], py.Store(**pos(node))),
py.Name(node.valvar.name[1:], py.Store(**pos(node)))
], py.Store(**pos(node)), **pos(node))
return py.For(
target, from_phpast(node.expr),
list(map(to_stmt, list(map(from_phpast, deblock(node.node))))), [],
**pos(node))
if isinstance(node, php.While):
return py.While(
from_phpast(node.expr),
list(map(to_stmt, list(map(from_phpast, deblock(node.node))))), [],
**pos(node))
if isinstance(node, php.DoWhile):
condition = php.If(php.UnaryOp('!', node.expr, lineno=node.lineno),
php.Break(None, lineno=node.lineno), [],
None,
lineno=node.lineno)
return from_phpast(
php.While(1,
php.Block(deblock(node.node) + [condition],
lineno=node.lineno),
lineno=node.lineno))
if isinstance(node, php.Try):
return py.TryExcept(
list(map(to_stmt, list(map(from_phpast, node.nodes)))), [
py.ExceptHandler(
py.Name(catch.class_, py.Load(**pos(node)), **pos(node)),
store(from_phpast(catch.var)),
list(map(to_stmt, list(map(from_phpast, catch.nodes)))),
**pos(node)) for catch in node.catches
], [], **pos(node))
if isinstance(node, php.Throw):
return py.Raise(from_phpast(node.node), None, None, **pos(node))
if isinstance(node, php.Function):
args = []
defaults = []
for param in node.params:
args.append(
py.Name(param.name[1:], py.Param(**pos(node)), **pos(node)))
if param.default is not None:
defaults.append(from_phpast(param.default))
body = list(map(to_stmt, list(map(from_phpast, node.nodes))))
if not body: body = [py.Pass(**pos(node))]
return py.FunctionDef(node.name,
py.arguments(args, None, None, defaults), body,
[], **pos(node))
if isinstance(node, php.Method):
args = []
defaults = []
decorator_list = []
if 'static' in node.modifiers:
decorator_list.append(
py.Name('classmethod', py.Load(**pos(node)), **pos(node)))
args.append(py.Name('cls', py.Param(**pos(node)), **pos(node)))
else:
args.append(py.Name('self', py.Param(**pos(node)), **pos(node)))
for param in node.params:
args.append(
py.Name(param.name[1:], py.Param(**pos(node)), **pos(node)))
if param.default is not None:
defaults.append(from_phpast(param.default))
body = list(map(to_stmt, list(map(from_phpast, node.nodes))))
if not body: body = [py.Pass(**pos(node))]
return py.FunctionDef(node.name,
py.arguments(args, None, None, defaults), body,
decorator_list, **pos(node))
if isinstance(node, php.Class):
name = node.name
bases = []
extends = node.extends or 'object'
bases.append(py.Name(extends, py.Load(**pos(node)), **pos(node)))
body = list(map(to_stmt, list(map(from_phpast, node.nodes))))
for stmt in body:
if (isinstance(stmt, py.FunctionDef)
and stmt.name in (name, '__construct')):
stmt.name = '__init__'
if not body: body = [py.Pass(**pos(node))]
return py.ClassDef(name, bases, body, [], **pos(node))
if isinstance(node, (php.ClassConstants, php.ClassVariables)):
assert len(node.nodes) == 1, \
'only one class-level assignment supported per line'
if isinstance(node.nodes[0], php.ClassConstant):
name = php.Constant(node.nodes[0].name, lineno=node.lineno)
else:
name = php.Variable(node.nodes[0].name, lineno=node.lineno)
initial = node.nodes[0].initial
if initial is None:
initial = php.Constant('None', lineno=node.lineno)
return py.Assign([store(from_phpast(name))], from_phpast(initial),
**pos(node))
if isinstance(node, (php.FunctionCall, php.New)):
if isinstance(node.name, str):
name = py.Name(node.name, py.Load(**pos(node)), **pos(node))
else:
name = py.Subscript(
py.Call(py.Name('vars', py.Load(**pos(node)), **pos(node)), [],
[], None, None, **pos(node)),
py.Index(from_phpast(node.name), **pos(node)),
py.Load(**pos(node)), **pos(node))
args, kwargs = build_args(node.params)
return py.Call(name, args, kwargs, None, None, **pos(node))
if isinstance(node, php.MethodCall):
args, kwargs = build_args(node.params)
return py.Call(
py.Attribute(from_phpast(node.node), node.name,
py.Load(**pos(node)), **pos(node)), args, kwargs,
None, None, **pos(node))
if isinstance(node, php.StaticMethodCall):
class_ = node.class_
if class_ == 'self': class_ = 'cls'
args, kwargs = build_args(node.params)
return py.Call(
py.Attribute(py.Name(class_, py.Load(**pos(node)),
**pos(node)), node.name, py.Load(**pos(node)),
**pos(node)), args, kwargs, None, None, **pos(node))
if isinstance(node, php.StaticProperty):
class_ = node.node
name = node.name
if isinstance(name, php.Variable):
name = name.name[1:]
return py.Attribute(py.Name(class_, py.Load(**pos(node)), **pos(node)),
name, py.Load(**pos(node)), **pos(node))
return py.Call(py.Name('XXX', py.Load(**pos(node)),
**pos(node)), [py.Str(str(node), **pos(node))], [],
None, None, **pos(node))
def as_ast(self, ast_state):
values = ast.Tuple([ast_value(ast_state, v) for v in self.values],
ast.Load())
return ast.Compare(ast_column(ast_state, self.column), [ast.In()],
[values])
def as_ast(self, ast_state):
return ast.Compare(ast.Str(untag_col(self.column)), [ast.In()],
[ast.Name('props', ast.Load())])
def make_base_class_dict_test_stmts(
self, bases: List[TAst], instance_fields: Set[str]
) -> stmt:
slots_stmt = self.make_slots_stmt(instance_fields)
# if there are non-names in the bases of the class, give up and just create slots
if not all(isinstance(b, ast.Name) for b in bases):
return slots_stmt
# if __dict__ is not added to instance fields (no loose slots), just slotify
if "__dict__" not in instance_fields:
return slots_stmt
# generate code that decide whether __dict__ should be included
# if any('__dict__' in getattr(_t, '__dict__', ()) for b in <bases> for _t in b.mro()):
# __slots__ = <slots without __dict__>
# else:
# __slots__ = <slots with __dict__>
names = [lineinfo(ast.Name(cast(ast.Name, n).id, ast.Load())) for n in bases]
condition = lineinfo(
ast.Call(
lineinfo(ast.Name("any", ast.Load())),
[
lineinfo(
ast.GeneratorExp(
lineinfo(
ast.Compare(
lineinfo(Constant("__dict__")),
[lineinfo(ast.In())],
[
lineinfo(
ast.Call(
lineinfo(
ast.Name("getattr", ast.Load())
),
[
lineinfo(
ast.Name("_t", ast.Load())
),
lineinfo(Constant("__dict__")),
lineinfo(ast.Tuple([], ast.Load())),
],
[],
)
)
],
)
),
[
lineinfo(
ast.comprehension(
lineinfo(ast.Name("b", ast.Store())),
lineinfo(ast.List(names, ast.Load())),
[],
0,
)
),
lineinfo(
ast.comprehension(
lineinfo(ast.Name("_t", ast.Store())),
lineinfo(
ast.Call(
lineinfo(
ast.Attribute(
lineinfo(
ast.Name("b", ast.Load())
),
"mro",
ast.Load(),
)
),
[],
[],
)
),
[],
0,
)
),
],
)
)
],
[],
)
)
slots_stmt_without_dict = self.make_slots_stmt(instance_fields - {"__dict__"})
return lineinfo(ast.If(condition, [slots_stmt_without_dict], [slots_stmt]))
def mutate_NotIn(self, node):
return ast.In()