我们从Python开源项目中，提取了以下41个代码示例，用于说明如何使用ast.In()。
def load_module(self, name): # If there is an existing module object named 'fullname' in # sys.modules, the loader must use that existing module. (Otherwise, # the reload() builtin will not work correctly.) if name in sys.modules: return sys.modules[name] co, pyc = self.modules.pop(name) # I wish I could just call imp.load_compiled here, but __file__ has to # be set properly. In Python 3.2+, this all would be handled correctly # by load_compiled. mod = sys.modules[name] = imp.new_module(name) try: mod.__file__ = co.co_filename # Normally, this attribute is 3.2+. mod.__cached__ = pyc mod.__loader__ = self py.builtin.exec_(co, mod.__dict__) except: del sys.modules[name] raise return sys.modules[name]
def doCompare(op, left, right): """Perform the given AST comparison on the values""" top = type(op) if top == ast.Eq: return left == right elif top == ast.NotEq: return left != right elif top == ast.Lt: return left < right elif top == ast.LtE: return left <= right elif top == ast.Gt: return left > right elif top == ast.GtE: return left >= right elif top == ast.Is: return left is right elif top == ast.IsNot: return left is not right elif top == ast.In: return left in right elif top == ast.NotIn: return left not in right
def test_repr_global(self): # In func()/method(), repr() builtin cannot be copied to constant, # because the call to __fat__.replace_consts(func.__code__, {'...': repr}) would # load the local repr() function instead of the builtin repr() # function. self.config._copy_builtin_to_constant.add('repr') self.check_dont_optimize(""" def repr(obj): return 'local' def func(obj): return repr(obj) """) self.check_dont_optimize(""" class MyClass: @staticmethod def repr(obj): return 'local' def method(self, obj): return repr(obj) """)
def compare(self): left = Expr.parse_value_expr(self.expr.left, self.context) right = Expr.parse_value_expr(self.expr.comparators[0], self.context) if isinstance(self.expr.ops[0], ast.In) and \ isinstance(right.typ, ListType): if not are_units_compatible(left.typ, right.typ.subtype) and not are_units_compatible(right.typ.subtype, left.typ): raise TypeMismatchException("Can't use IN comparison with different types!", self.expr) return self.build_in_comparator() else: if not are_units_compatible(left.typ, right.typ) and not are_units_compatible(right.typ, left.typ): raise TypeMismatchException("Can't compare values with different units!", self.expr) if len(self.expr.ops) != 1: raise StructureException("Cannot have a comparison with more than two elements", self.expr) if isinstance(self.expr.ops[0], ast.Gt): op = 'sgt' elif isinstance(self.expr.ops[0], ast.GtE): op = 'sge' elif isinstance(self.expr.ops[0], ast.LtE): op = 'sle' elif isinstance(self.expr.ops[0], ast.Lt): op = 'slt' elif isinstance(self.expr.ops[0], ast.Eq): op = 'eq' elif isinstance(self.expr.ops[0], ast.NotEq): op = 'ne' else: raise Exception("Unsupported comparison operator") if not is_numeric_type(left.typ) or not is_numeric_type(right.typ): if op not in ('eq', 'ne'): raise TypeMismatchException("Invalid type for comparison op", self.expr) ltyp, rtyp = left.typ.typ, right.typ.typ if ltyp == rtyp: return LLLnode.from_list([op, left, right], typ='bool', pos=getpos(self.expr)) elif ltyp == 'decimal' and rtyp == 'num': return LLLnode.from_list([op, left, ['mul', right, DECIMAL_DIVISOR]], typ='bool', pos=getpos(self.expr)) elif ltyp == 'num' and rtyp == 'decimal': return LLLnode.from_list([op, ['mul', left, DECIMAL_DIVISOR], right], typ='bool', pos=getpos(self.expr)) else: raise TypeMismatchException("Unsupported types for comparison: %r %r" % (ltyp, rtyp), self.expr)
def push_format_context(self): """Create a new formatting context. The format context is used for when an explanation wants to have a variable value formatted in the assertion message. In this case the value required can be added using .explanation_param(). Finally .pop_format_context() is used to format a string of %-formatted values as added by .explanation_param(). """ self.explanation_specifiers = {} self.stack.append(self.explanation_specifiers)
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 allVariableNamesUsed(a): """Gathers all the variable names used in the ast""" if not isinstance(a, ast.AST): return [] elif type(a) == ast.Name: return [a.id] elif type(a) == ast.Assign: """In assignments, ignore all pure names used- they're being assigned to, not used""" variables = allVariableNamesUsed(a.value) for target in a.targets: if type(target) == ast.Name: pass elif type(target) in [ast.Tuple, ast.List]: for elt in target.elts: if type(elt) != ast.Name: variables += allVariableNamesUsed(elt) else: variables += allVariableNamesUsed(target) return variables elif type(a) == ast.AugAssign: variables = allVariableNamesUsed(a.value) variables += allVariableNamesUsed(a.target) return variables variables = [] for child in ast.iter_child_nodes(a): variables += allVariableNamesUsed(child) return variables
def visit_Compare(self, node): """ Compare(expr left, cmpop* ops, expr* comparators) """ assert len(node.ops) == len(node.comparators) def compare_pair(left, comp, op): if (left == '__name__') and (comp == '"__main__"') or \ (left == '"__main__"') and (comp == '__name__'): """ <Python> __name__ == '__main__': <Ruby> __FILE__ == $0 """ left = '__FILE__' comp = '$0' if isinstance(op, ast.In): return "%s.include?(%s)" % (comp, left) elif isinstance(op, ast.NotIn): return "!%s.include?(%s)" % (comp, left) elif isinstance(op, ast.Eq): return "%s == %s" % (left, comp) elif isinstance(op, ast.NotEq): return "%s != %s" % (left, comp) elif isinstance(op, ast.IsNot): return "!%s.equal?(%s)" % (left, comp) else: return "%s %s %s" % (left, self.get_comparison_op(op), comp) compare_list = [] for i in range(len(node.ops)): if i == 0: left = self.visit(node.left) else: left = comp comp = self.visit(node.comparators[i]) op = node.ops[i] pair = compare_pair(left, comp, op) if len(node.ops) == 1: return pair compare_list.append('(' + pair + ')') return ' and '.join(compare_list) # python 3
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 test_contains_to_const(self): # list => tuple self.check_optimize_func("x in [1, 2]", "x in (1, 2)") # set => frozenset const = ast.Constant(value=frozenset({1, 2})) node = ast.Compare(left=ast.Name(id='x', ctx=ast.Load()), ops=[ast.In()], comparators=[const]) self.check_optimize_func("x in {1, 2}", node) # [] is not a constant: don't optimize self.check_dont_optimize_func("x in [1, [], 2]") self.check_dont_optimize_func("x in {1, [], 2}")
def compare_cst(self, node): node_op = node.ops[0].__class__ eval_op = EVAL_COMPARE.get(node_op) if eval_op is None: return if node_op in (ast.In, ast.NotIn): left_hashable = True right_types = ITERABLE_TYPES else: left_hashable = False right_types = None if left_hashable: left = get_constant(node.left) else: left = get_literal(node.left) if left is UNSET: return right = get_literal(node.comparators[0], types=right_types) if right is UNSET: return if (node_op in (ast.Eq, ast.NotEq) and ((isinstance(left, str) and isinstance(right, bytes)) or (isinstance(left, bytes) and isinstance(right, str)))): # comparison between bytes and str can raise BytesWarning depending # on runtime option return try: result = eval_op(left, right) except TypeError: return return self.new_constant(node, result)
def visit_Compare(self, node): if not self.config.constant_folding: return if len(node.ops) != 1: # FIXME: implement 1 < 2 < 3 return if len(node.comparators) != 1: # FIXME: support this case? What's the syntax of this case? return new_node = self.compare_cst(node) if new_node is not None: return new_node # replace 'None is None' with True if (isinstance(node.ops[0], (ast.Is, ast.IsNot)) and isinstance(node.left, ast.Constant) and node.left.value is None and isinstance(node.comparators[0], ast.Constant) and node.comparators[0].value is None): result = isinstance(node.ops[0], ast.Is) return self.new_constant(node, result) # replace 'x in {1, 2}' with 'x in frozenset({1, 2})' # replace 'x in [1, 2]' with 'x in frozenset((1, 2))' if isinstance(node.ops[0], ast.In): new_node = self.compare_contains(node) if new_node is not None: return new_node
def translate_In(self, op): return ast.Eq() if isinstance(op, ast.In) else op
def In(): return _in
def whereeval(str_, get=None): """Evaluate a set operation string, where each Name is fetched""" if get is None: import redbiom config = redbiom.get_config() get = redbiom._requests.make_get(config) # Load is subject to indirection to simplify testing globals()['Load'] = make_Load(get) formed = ast.parse(str_, mode='eval') node_types = (ast.Compare, ast.In, ast.NotIn, ast.BoolOp, ast.And, ast.Name, ast.Or, ast.Eq, ast.Lt, ast.LtE, ast.Gt, ast.GtE, ast.NotEq, ast.Str, ast.Num, ast.Load, ast.Expression, ast.Tuple, ast.Is, ast.IsNot) for node in ast.walk(formed): if not isinstance(node, node_types): raise TypeError("Unsupported node type: %s" % ast.dump(node)) result = eval(ast.dump(formed)) # clean up global Load del Load return result
def In(self, key, *right): c = criteria_class.instance(Const.In, key, *right) self._push(c) return self
def __init__(self, key, *right): super(In, self).__init__(key, right)
def mutate_NotIn(self, node): return ast.In()
def _assertTrueorder(self, ast_node, parent_pos, reverse_check = False): def should_reverse_check(parent, child): # In some situations, the children of nodes occur before # their parents, for example in a.b.c, a occurs before b # but a is a child of b. if isinstance(parent, ast.Call): if parent.func == child: return True if isinstance(parent, (ast.Attribute, ast.Subscript)): return True return False if not isinstance(ast_node, ast.AST) or ast_node._fields is None: return if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)): node_pos = (ast_node.lineno, ast_node.col_offset) if reverse_check: self.assertTrue(node_pos <= parent_pos) else: self.assertTrue(node_pos >= parent_pos) parent_pos = (ast_node.lineno, ast_node.col_offset) for name in ast_node._fields: value = getattr(ast_node, name) if isinstance(value, list): for child in value: self._assertTrueorder(child, parent_pos, should_reverse_check(ast_node, child)) elif value is not None: self._assertTrueorder(value, parent_pos, should_reverse_check(ast_node, value))
def Compare_in(t, x): if not isinstance(x.ops[0], (ast.NotIn, ast.In)): return if t.enable_snippets: from ..snippets import _in, in_es6 if t.enable_es6: t.add_snippet(in_es6) sname = 'in_es6' else: t.add_snippet(_in) sname = '_in' result = JSCall(JSAttribute('_pj', sname), [x.left, x.comparators[0]]) if isinstance(x.ops[0], ast.NotIn): result = JSUnaryOp(JSOpNot(), result) return result
def syn_Compare(self, ctx, e): left, ops, comparators = e.left, e.ops, e.comparators for op in ops: if not isinstance(op, (ast.Eq, ast.NotEq, ast.Is, ast.IsNot, ast.In, ast.NotIn)): raise _errors.TyError("Invalid comparison operator on strings.", e) for e_ in _util.tpl_cons(left, comparators): if hasattr(e_, 'match'): continue # already synthesized ctx.ana(e_, self) return _boolean.boolean
def syn_Compare(self, ctx, e): left, ops, comparators = e.left, e.ops, e.comparators for op in ops: if isinstance(op, (ast.In, ast.NotIn)): raise _errors.TyError("Type num does not support this operator.", op) for e_ in _util.tpl_cons(left, comparators): if hasattr(e_, 'match'): continue # already synthesized ctx.ana(e_, self) return _boolean.boolean
def syn_Compare(self, ctx, e): left, ops, comparators = e.left, e.ops, e.comparators for op in ops: if isinstance(op, (ast.In, ast.NotIn)): raise _errors.TyError("Type ieee does not support this operator.", op) for e_ in _util.tpl_cons(left, comparators): if hasattr(e_, 'match'): continue # already synthesized ctx.ana(e_, self) return _boolean.boolean
def syn_Compare(self, ctx, e): left, ops, comparators = e.left, e.ops, e.comparators for op in ops: if isinstance(op, (ast.Lt, ast.LtE, ast.Gt, ast.GtE)): raise _errors.TyError("No ordering relation on complex numbers.", e) elif isinstance(op, (ast.In, ast.NotIn)): raise _errors.TyError("Type complex does not support this operator.", op) for e_ in _util.tpl_cons(left, comparators): if hasattr(e_, 'match'): continue # already synthesized ctx.ana(e_, self) return _boolean.boolean
def areDisjoint(a, b): """Are the sets of values that satisfy these two boolean constraints disjoint?""" # The easiest way to be disjoint is to have comparisons that cover different areas if type(a) == type(b) == ast.Compare: aop = a.ops[0] bop = b.ops[0] aLeft = a.left aRight = a.comparators[0] bLeft = b.left bRight = b.comparators[0] alblComp = compareASTs(aLeft, bLeft, checkEquality=True) albrComp = compareASTs(aLeft, bRight, checkEquality=True) arblComp = compareASTs(aRight, bLeft, checkEquality=True) arbrComp = compareASTs(aRight, bRight, checkEquality=True) altype = type(aLeft) in [ast.Num, ast.Str] artype = type(aRight) in [ast.Num, ast.Str] bltype = type(bLeft) in [ast.Num, ast.Str] brtype = type(bRight) in [ast.Num, ast.Str] if (type(aop) == ast.Eq and type(bop) == ast.NotEq) or \ (type(bop) == ast.Eq and type(aop) == ast.NotEq): # x == y, x != y if (alblComp == 0 and arbrComp == 0) or (albrComp == 0 and arblComp == 0): return True elif type(aop) == type(bop) == ast.Eq: if (alblComp == 0 and arbrComp == 0) or (albrComp == 0 and arblComp == 0): return False # x = num1, x = num2 elif alblComp == 0 and artype and brtype: return True elif albrComp == 0 and artype and bltype: return True elif arblComp == 0 and altype and brtype: return True elif arbrComp == 0 and altype and bltype: return True elif (type(aop) == ast.Lt and type(bop) == ast.GtE) or \ (type(aop) == ast.Gt and type(bop) == ast.LtE) or \ (type(aop) == ast.LtE and type(bop) == ast.Gt) or \ (type(aop) == ast.GtE and type(bop) == ast.Lt) or \ (type(aop) == ast.Is and type(bop) == ast.IsNot) or \ (type(aop) == ast.IsNot and type(bop) == ast.Is) or \ (type(aop) == ast.In and type(bop) == ast.NotIn) or \ (type(aop) == ast.NotIn and type(bop) == ast.In): if alblComp == 0 and arbrComp == 0: return True elif (type(aop) == ast.Lt and type(bop) == ast.LtE) or \ (type(aop) == ast.Gt and type(bop) == ast.GtE) or \ (type(aop) == ast.LtE and type(bop) == ast.Lt) or \ (type(aop) == ast.GtE and type(bop) == ast.Gt): if albrComp == 0 and arblComp == 0: return True elif type(a) == type(b) == ast.BoolOp: return False # for now- TODO: when is this not true? elif type(a) == ast.UnaryOp and type(a.op) == ast.Not: if compareASTs(a.operand, b, checkEquality=True) == 0: return True elif type(b) == ast.UnaryOp and type(b.op) == ast.Not: if compareASTs(b.operand, a, checkEquality=True) == 0: return True return False
def negate(op): """Return the negation of the provided operator""" if op == None: return None top = type(op) neg = not op.negated if hasattr(op, "negated") else True if top == ast.And: newOp = ast.Or() elif top == ast.Or: newOp = ast.And() elif top == ast.Eq: newOp = ast.NotEq() elif top == ast.NotEq: newOp = ast.Eq() elif top == ast.Lt: newOp = ast.GtE() elif top == ast.GtE: newOp = ast.Lt() elif top == ast.Gt: newOp = ast.LtE() elif top == ast.LtE: newOp = ast.Gt() elif top == ast.Is: newOp = ast.IsNot() elif top == ast.IsNot: newOp = ast.Is() elif top == ast.In: newOp = ast.NotIn() elif top == ast.NotIn: newOp = ast.In() elif top == ast.NameConstant and op.value in [True, False]: op.value = not op.value op.negated = neg return op elif top == ast.Compare: if len(op.ops) == 1: op.ops[0] = negate(op.ops[0]) op.negated = neg return op else: values = [] allOperands = [op.left] + op.comparators for i in range(len(op.ops)): values.append(ast.Compare(allOperands[i], [negate(op.ops[i])], [allOperands[i+1]], multiCompPart=True)) newOp = ast.BoolOp(ast.Or(multiCompOp=True), values, multiComp=True) elif top == ast.UnaryOp and type(op.op) == ast.Not and \ eventualType(op.operand) == bool: # this can mess things up type-wise return op.operand else: # this is a normal value, so put a not around it newOp = ast.UnaryOp(ast.Not(addedNot=True), op) transferMetaData(op, newOp) newOp.negated = neg return newOp
def _translate_compare(self, left, ops, comparators, location): if isinstance(ops[0], ast.In) or isinstance(ops[0], ast.NotIn): if len(comparators) != 1: raise translation_error('only <element> [not] in <sequence> supported', location, self.lines[location[0]], suggestion='2 in [2] in [[2]] is cute, but it\'s not supported') else: in_node = self._translate_in(left, comparators[0], location) if isinstance(ops[0], ast.In): return in_node else: return {'type': 'unary_op', 'op': 'not', 'value': in_node, 'pseudo_type': 'Boolean'} op = PSEUDO_OPS[type(ops[0])] right_node = self._translate_node(comparators[0]) left_node = self._translate_node(left) self._confirm_comparable(op, left_node['pseudo_type'], right_node['pseudo_type'], location) result = { 'type': 'comparison', 'op': op, 'left': left_node, 'right': right_node, 'pseudo_type': 'Boolean' } if len(comparators) == 1: return result else: for r in comparators[1:]: left_node, right_node = right_node, self._translate_node(r) self._confirm_comparable(op, left_node['pseudo_type'], right_node['pseudo_type'], location) result = { 'type': 'binary_op', 'op': 'and', 'left': result, 'right': { 'type': 'comparison', 'op': op, 'left': left_node, 'right': right_node, 'pseudo_type': 'Boolean' }, 'pseudo_type': 'Boolean' } return result
def _visit_compare(self, left, op, right): swap = False if not isinstance(left, ast.Attribute): left, right = right, left swap = True if not isinstance(left, ast.Attribute): return hardcoded_errno = ( left.attr == 'errno' and op in astaux.equality_ops and isinstance(right, ast.Num) and isinstance(right.n, int) and right.n in errno_constants ) if hardcoded_errno: yield self.tag(right, '*hardcoded-errno-value', right.n) sys_attr_comparison = ( isinstance(left.value, ast.Name) and left.value.id == 'sys' ) if sys_attr_comparison: if left.attr == 'version': tpl = None if isinstance(right, ast.Str): if op in astaux.inequality_ops: try: tpl = sysversion.version_to_tuple(right.s) except (TypeError, ValueError): pass elif swap and (op in astaux.in_ops): if right.s == 'PyPy': tpl = False op = ast.Eq if isinstance(op, ast.In) else ast.NotEq yield self.tag(left, 'sys.version-comparison', format_cmp('platform.python_implementation()', op, repr('PyPy')) ) if tpl is False: pass elif tpl is None: yield self.tag(left, 'sys.version-comparison') else: yield self.tag(left, 'sys.version-comparison', format_cmp('sys.version_info', op, tpl, swap=swap) ) elif left.attr == 'hexversion': tpl = None if isinstance(right, ast.Num) and (op in astaux.numeric_cmp_ops): try: tpl = sysversion.hexversion_to_tuple(right.n) except (TypeError, ValueError): pass if tpl is None: yield self.tag(left, 'sys.hexversion-comparison') else: yield self.tag(left, 'sys.hexversion-comparison', format_cmp('sys.version_info', op, tpl, swap=swap) )
