def visit_BinOp(self, node):
left_term = self.visit(node.left)
right_term = self.visit(node.right)
if self.__is_bool(left_term) and self.__is_bool(right_term):
if isinstance(node.op, ast.BitAnd):
return And(left_term, right_term)
elif isinstance(node.op, ast.BitOr):
return Or(left_term, right_term)
elif isinstance(node.op, ast.BitXor):
return Xor(left_term, right_term)
else:
raise Exception("Unsupported bool binary operation %s" % unparse(node))
if DATA_TYPE == "int":
if isinstance(node.op, ast.Mod):
return left_term % right_term
elif isinstance(node.op, ast.Add):
return left_term + right_term
elif isinstance(node.op, ast.Sub):
return left_term - right_term
elif isinstance(node.op, ast.Mult):
return left_term * right_term
elif isinstance(node.op, ast.BitXor):
# Special-case for bool circuit-examples:
if is_is_int(left_term):
left_term = left_term == IntVal(1)
if is_is_int(right_term):
right_term = right_term == IntVal(1)
return left_term != right_term
else:
raise Exception("Unsupported integer binary operation %s" % unparse(node))
elif DATA_TYPE.startswith("bit_"):
if isinstance(node.op, ast.BitAnd):
return left_term & right_term
elif isinstance(node.op, ast.BitOr):
return left_term | right_term
elif isinstance(node.op, ast.BitXor):
return left_term ^ right_term
else:
raise Exception("Unsupported bitvector operation %s" % unparse(node))
else:
raise Exception("Unsupported data type %s" % DATA_TYPE)
python类Sub()的实例源码
def _update(self):
"""update tkk
"""
# we don't need to update the base TKK value when it is still valid
now = math.floor(int(time.time() * 1000) / 3600000.0)
if self.tkk and int(self.tkk.split('.')[0]) == now:
return
r = self.session.get(self.host)
# this will be the same as python code after stripping out a reserved word 'var'
code = str(self.RE_TKK.search(r.text).group(1)).replace('var ', '')
# unescape special ascii characters such like a \x3d(=)
code = code.encode().decode('unicode-escape')
if code:
tree = ast.parse(code)
visit_return = False
operator = '+'
n, keys = 0, dict(a=0, b=0)
for node in ast.walk(tree):
if isinstance(node, ast.Assign):
name = node.targets[0].id
if name in keys:
if isinstance(node.value, ast.Num):
keys[name] = node.value.n
# the value can sometimes be negative
elif isinstance(node.value, ast.UnaryOp) and \
isinstance(node.value.op, ast.USub): # pragma: nocover
keys[name] = -node.value.operand.n
elif isinstance(node, ast.Return):
# parameters should be set after this point
visit_return = True
elif visit_return and isinstance(node, ast.Num):
n = node.n
elif visit_return and n > 0:
# the default operator is '+' but implement some more for
# all possible scenarios
if isinstance(node, ast.Add): # pragma: nocover
pass
elif isinstance(node, ast.Sub): # pragma: nocover
operator = '-'
elif isinstance(node, ast.Mult): # pragma: nocover
operator = '*'
elif isinstance(node, ast.Pow): # pragma: nocover
operator = '**'
elif isinstance(node, ast.BitXor): # pragma: nocover
operator = '^'
# a safety way to avoid Exceptions
clause = compile('{1}{0}{2}'.format(
operator, keys['a'], keys['b']), '', 'eval')
value = eval(clause, dict(__builtin__={}))
result = '{}.{}'.format(n, value)
self.tkk = result
def seteval(str_, get=None, stemmer=None, target=None):
"""Evaluate a set operation string, where each Name is fetched
Parameters
----------
str_ : str
The query to evaluate
get : function, optional
A getting method, defaults to instatiating one from _requests
stemmer : function, optional
A method to stem a query Name. If None, defaults to passthrough.
target : str, optional
A subcontext to query against. If None, defaults to text-search.
"""
if get is None:
import redbiom
config = redbiom.get_config()
get = redbiom._requests.make_get(config)
if stemmer is None:
stemmer = passthrough
if target is None:
target = 'text-search'
# Load is subject to indirection to simplify testing
globals()['Load'] = make_Load(get)
# this seems right now to be the easiest way to inject parameters
# into Name
globals()['stemmer'] = stemmer
globals()['target'] = target
formed = ast.parse(str_, mode='eval')
node_types = (ast.BitAnd, ast.BitOr, ast.BitXor, ast.Name, ast.Sub,
ast.Expression, ast.BinOp, ast.Load)
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
del stemmer
del target
return result
def visit_BinOp(self, node):
if node.op.__class__ in self.operators:
sympy_class = self.operators[node.op.__class__]
right = self.visit(node.right)
left = self.visit(node.left)
if isinstance(node.left, ast.UnaryOp) and (isinstance(node.right, ast.UnaryOp) == 0) and sympy_class in ('Mul',):
left, right = right, left
if isinstance(node.op, ast.Sub):
right = ast.UnaryOp(op=ast.USub(), operand=right)
if isinstance(node.op, ast.Div):
if isinstance(node.left, ast.UnaryOp):
if isinstance(node.right,ast.UnaryOp):
left, right = right, left
left = ast.Call(
func=ast.Name(id='Pow', ctx=ast.Load()),
args=[left, ast.UnaryOp(op=ast.USub(), operand=ast.Num(1))],
keywords=[ast.keyword(arg='evaluate', value=ast.Name(id='False', ctx=ast.Load()))],
starargs=None,
kwargs=None
)
else:
right = ast.Call(
func=ast.Name(id='Pow', ctx=ast.Load()),
args=[right, ast.UnaryOp(op=ast.USub(), operand=ast.Num(1))],
keywords=[ast.keyword(arg='evaluate', value=ast.Name(id='False', ctx=ast.Load()))],
starargs=None,
kwargs=None
)
new_node = ast.Call(
func=ast.Name(id=sympy_class, ctx=ast.Load()),
args=[left, right],
keywords=[ast.keyword(arg='evaluate', value=ast.Name(id='False', ctx=ast.Load()))],
starargs=None,
kwargs=None
)
if sympy_class in ('Add', 'Mul'):
# Denest Add or Mul as appropriate
new_node.args = self.flatten(new_node.args, sympy_class)
return new_node
return node
def _aslimit(value, lc):
if isinstance(value, string_types):
module = ast.parse(value)
if isinstance(module, ast.Module) and len(module.body) == 1 and isinstance(module.body[0], ast.Expr):
def restrictedeval(expr):
if isinstance(expr, ast.Num):
return expr.n
elif isinstance(expr, ast.Name) and expr.id == "inf":
return femtocode.typesystem.inf
elif isinstance(expr, ast.Name) and expr.id == "pi":
return math.pi
elif isinstance(expr, ast.UnaryOp) and isinstance(expr.op, ast.USub):
return -restrictedeval(expr.operand)
elif isinstance(expr, ast.BinOp) and isinstance(expr.op, ast.Add):
return restrictedeval(expr.left) + restrictedeval(expr.right)
elif isinstance(expr, ast.BinOp) and isinstance(expr.op, ast.Sub):
return restrictedeval(expr.left) - restrictedeval(expr.right)
elif isinstance(expr, ast.BinOp) and isinstance(expr.op, ast.Mult):
return restrictedeval(expr.left) * restrictedeval(expr.right)
elif isinstance(expr, ast.BinOp) and isinstance(expr.op, ast.Div):
return restrictedeval(expr.left) / restrictedeval(expr.right)
elif isinstance(expr, ast.BinOp) and isinstance(expr.op, ast.Pow):
return restrictedeval(expr.left) ** restrictedeval(expr.right)
elif isinstance(expr, ast.Call) and isinstance(expr.func, ast.Name) and expr.func.id == "almost" and len(expr.args) == 1 and len(expr.keywords) == 0 and expr.kwargs is None and expr.starargs is None:
return femtocode.typesystem.almost(restrictedeval(expr.args[0]))
else:
raise DatasetDeclaration.Error(lc, "couldn't parse as a min/max/least/most limit: {0}".format(value))
return restrictedeval(module.body[0].value)
elif isinstance(value, (int, long, float)):
return value
elif isinstance(value, femtocode.typesystem.almost) and isinstance(value.real, (int, long, float)):
return value
else:
raise DatasetDeclaration.Error(lc, "unrecognized type for min/max/least/most limit: {0}".format(value))
