def do_date(datenode) :
(day,month,year) = extractdate(datenode)
if le(month,0) or gt(month,12) :
daysinmonth = 0
elif eq(month,9) or eq(month,4) or eq(month,6) or eq(month,11) :
daysinmonth = 30
elif eq(month,2) :
if eq(mod(year,4),0) and (julian or (ne(mod(year,100),0) or eq(mod(year,400),0))) :
daysinmonth = 29
else :
daysinmonth = 28
else :
daysinmonth=31
future = 0
if gt(year,toyear) :
future = 1
elif eq(year,toyear) :
if gt(month,tomonth) :
future=1
elif eq(month,tomonth) and gt(day,today) :
future=1
if gt(day,daysinmonth) or future : out("*")
if lt(year,0) :
cols(d(year),6)
else :
if lt(year,10) : out("0")
if lt(year,100) : out("0")
if lt(year,1000) : out("0")
out(d(year))
if lt(month,10) : out("0")
out(d(month))
if lt(day,10) : out ("0")
out(d(day)+" ")
def cmp_precode(precode1, precode2):
"""前缀编码比较函数"""
pre1 = precode1.split('*')[0]
pre2 = precode2.split('*')[0]
if pre1 == '':
pre1 = DictBuild.LineDecompress(precode1)[0][0]
if pre2 == '':
pre2 = DictBuild.LineDecompress(precode2)[0][0]
mlen = min(len(pre1), len(pre2))
pre1 = pre1[0:mlen]
pre2 = pre2[0:mlen]
if operator.lt(pre1, pre2):
return -1
elif operator.gt(pre1, pre2):
return 1
elif operator.eq(pre1, pre2):
word1 = DictBuild.LineDecompress(precode1)[0][0]
word2 = DictBuild.LineDecompress(precode2)[0][0]
if operator.lt(word1, word2):
return -1
elif operator.gt(word1, word2):
return 1
elif operator.eq(word1, word2):
return 0
def cmp_key(key, precode):
"""key与前缀编码的比较函数"""
pre = precode.split('*')[0]
decode, offset = DictBuild.LineDecompress(precode)
if pre == '':
pre = decode[0]
mlen = min(len(key), len(pre))
prekey = key[0:mlen]
pre = pre[0:mlen]
if operator.lt(prekey, pre):
if operator.ge(key, decode[0]):
juge = find(decode, key)
if juge is not -1:
return offset[juge]
return -1
# key的前缀小于编码的前缀，key小于前缀
elif operator.gt(prekey, pre):
if operator.le(key, decode[len(decode) - 1]):
juge = find(decode, key)
if juge is not -1:
return offset[juge]
return -2
elif operator.eq(pre, prekey):
juge = find(decode, key)
if juge is not -1:
return offset[juge]
elif operator.gt(key, decode[len(decode) - 1]):
return -2
elif operator.lt(key, decode[0]):
return -1
def compare_layer_order(la, lb):
"""
Return -1 if la < lb, 1 if la > lb it follows the rules as:
layer4.0.downsample.0 > layer4.0.conv1
fc > layer4.0.downsample.0
"""
flag = True
# return la <= lb
# la = la[0]
# lb = lb[0]
if 'classifier' in la and 'classifier' in lb:
if sys.version_info[0] == 2:
flag = cmp(la, lb)
else:
flag = operator.gt(la, lb)
elif 'classifier' in la:
flag = 1
elif 'classifier' in lb:
flag = -1
elif 'fc' in la and 'fc' in lb:
flag = 0
elif 'fc' in la:
flag = 1
elif 'fc' in lb:
flag = -1
else:
if sys.version_info[0] == 2:
flag = cmp(la, lb)
else:
flag = operator.gt(la, lb)
return flag
def testGreaterThan(self):
"""Test >operator"""
_dt = self.eDatetime - datetime.timedelta(1)
_other = eventCalBase.event(2, 'event', _dt)
self.failUnless(operator.gt(self.e, _other),
'a1 > a2 failed. a1=%s, a2=%s' % (self.e, _other))
self.failIf(operator.gt(_other, _other),
'a1 > a2 failed. a1=%s, a2=%s' % (_other, _other))
def testGreaterThan(self):
"""Test >operator"""
_dt = self.eDatetime - datetime.timedelta(1)
_other = eventCalBase.event(2, 'event', _dt)
self.failUnless(operator.gt(self.e, _other),
'a1 > a2 failed. a1=%s, a2=%s' % (self.e, _other))
self.failIf(operator.gt(_other, _other),
'a1 > a2 failed. a1=%s, a2=%s' % (_other, _other))
def test_crosslevel_cmp(self, x, y):
with pytest.raises(TypeError):
operator.lt(x, y)
with pytest.raises(TypeError):
operator.le(x, y)
with pytest.raises(TypeError):
operator.gt(x, y)
with pytest.raises(TypeError):
operator.ge(x, y)
def reverse(self, x):
"""
:type x: int
:rtype: int
"""
if x == 0:
return 0
s = 1 if gt(x, 0) else -1
r = int(str(x)[::-1]) if gt(x, 0) else int(str(x)[::-1][:-1])
# r = s * int(str(x)[::-1])
return r * s if r < 2**31 else 0
def test_arbitrary_orderable_weakref(self):
import operator
with mock_db_trans() as conn:
user_1 = self._create_user('*****@*****.**', conn)
user_2 = self._create_user('*****@*****.**', conn)
ref_1 = wref.ArbitraryOrderableWeakRef(user_1)
ref_2 = wref.ArbitraryOrderableWeakRef(user_2)
operator.lt(ref_1, ref_2)
operator.gt(ref_1, ref_2)
def test3() -> None:
""" build-in function python3 不存在 cmp 方法，使用的是 operator 模块的中方法"""
print("operator.gt(-6 ,2) =", operator.gt(-6, 2))
print("operator.gt(-6 ,2) =", operator.gt(0xFF, 255))
print("str(0xFF) = ", str(0xFF))
print("type(0xFF) = ", type(0xFF))
print("type(1 + 1j) = ", type(1 + 1j))
print("-" * 20)
print("int(1.1) = ", int(1.1))
print("complex(2, 4) = ", complex(2, 4))
print("float(4) = ", float(4))
def gt(A, B):
"""
A > B
"""
if isinstance(A, int) and isinstance(B, int):
return int(operator.gt(A, B))
if fuzzyEquals(A, B):
return 0
return int(operator.gt(A, B))
def main():
input()
# vai ficar assim pois o python não necessita da primeira entrada.
n = list(map(int, input().split()))
n = [(n[a], n[a + 1]) for a in range(len(n) - 1)]
if gt(*n[0]):
n = [gt(*n[a]) if a % 2 == 0 else lt(*n[a]) for a in range(len(n))]
elif lt(*n[0]):
n = [lt(*n[a]) if a % 2 == 0 else gt(*n[a]) for a in range(len(n))]
else:
return print(0)
print(1 if all(n) else 0)
def localScore(i, j, tmpCheckList, sequenceA, sequenceB, maxIndexSet):
a = i
b = j
while op.ne(np.size(stringSet), 0):
if (np.size(stringSet) > 0):
if op.gt(np.size(tmpCheckList), 1):
maxIndexSet[0:0] = [(i, j)]
temporary_List[0:0] = [tmpCheckList[1:]]
stringSet[0:0] = [(sequenceA, sequenceB)]
if op.gt(np.size(tmpCheckList), 0):
# we call this conditional to check if there are more than 1 possibility of having an optimal sequen
if op.eq(tmpCheckList[0 * 1], 1):
sequenceA = op.add(self.sequence_1[a - 1],
sequenceA)
sequenceB = op.add(self.sequence_2[b - 1],
sequenceB)
a = op.sub(a, 1)
b = op.sub(b, 1)
tmpCheckList.pop(0)
elif op.eq(tmpCheckList[0 * 1], 2):
sequenceA = self.sequence_1[a - 1] + sequenceA
sequenceB = "_" + sequenceB
a = op.sub(a, 1)
tmpCheckList.pop(0)
elif op.eq(tmpCheckList[0 * 1], 3):
sequenceA = "_" + sequenceA
sequenceB = self.sequence_2[b - 1] + sequenceB
b = op.sub(b, 1)
tmpCheckList.pop(0)
localScore(a, b, tempList(a, b, 0), sequenceA,
sequenceB, maxIndexSet)
# here we call recursively call the localScore method again keeping in mind, there could have been more than 1 possibility
else:
if self.DP_Matrix[a][b] == 0:
final_1st.append(
sequenceA
) # we finally add the given sequences to the final list for output later on
final_2nd.append(sequenceB)
if op.ne(np.size(stringSet), 0):
tempstringa = stringSet[0][0]
tempstringb = stringSet[0][1]
tempi = maxIndexSet[0][0]
tempj = maxIndexSet[0][1]
tempcheckarr = temporary_List[0]
deleteOperations(stringSet, maxIndexSet,
temporary_List)
localScore(tempi, tempj, tempcheckarr, tempstringa,
tempstringb, maxIndexSet)
else:
break
def parse_operator(target, query):
import operator as op
split = query.split(',')
'''one tail query '''
if len(split) == 1:
part = split[0].partition('=')
if part[-1].isdigit():
if part[0] == '>':
resp = op.ge(target,int(part[-1]))
else:
resp = op.le(target,int(part[-1]))
else:
if part[0][0] == '>':
resp = op.gt(target,int(part[0][1:]))
else:
resp = op.lt(target,int(part[0][1:]))
elif len(split) == 2:
top = split[0][0]
va1 = int(split[0][1:])
bot = split[1][-1]
va2 = int(split[1][:-1])
if top == '[' and bot == ']':
resp = op.ge(target,va1) & op.le(target,va2)
elif top == '[' and bot == '[':
resp = op.ge(target,va1) & op.lt(target,va2)
elif top == ']' and bot == ']':
resp = op.gt(target,va1) & op.le(target,va2)
elif top == ']' and bot == '[':
resp = op.gt(target,va1) & op.lt(target,va2)
return resp
def __gt__(
self, other: i_probability_distribution.IProbabilityDistribution
) -> "ProbabilityDistribution":
new_result_map = self._combine_distributions(
lambda a, b: 1 if operator.gt(a, b) else 0, other
)
return ProbabilityDistribution(new_result_map)
def eval_formula(op, a, b, negative=False):
"""计算简单的加减乘除, 同时抛出不符合题目要求的异常
像计算x + y这样简单的算术，最好使用Python内置的operator。
因为operator使用的是C写的，所以执行速度相对Python代码的快
"""
answer = 0
if op == "+":
answer = operator.add(a, b)
elif op == "-":
if operator.lt(a, b) and negative is False: # a是否小于b
raise NegativeError() # 抛出结果为负数的异常对象
else:
answer = operator.sub(a, b)
elif op == "*":
answer = operator.mul(a, b)
elif op == "/":
if operator.gt(b, 99): # b是否大于99
raise DifficultError() # 抛出题目较难的异常对象(分母大于99)
else:
answer = operator.truediv(a, b)
# 如果答案为浮点数，则转换为分数形式
if isinstance(answer, float):
answer = operator.truediv(Fraction(a), Fraction(b))
return answer
def _get_latest_version(self):
super(IrModule, self)._get_latest_version()
for rec in self:
rec.local_updatable = False
if rec.installed_version and rec.latest_version and operator.gt(
rec.installed_version, rec.latest_version):
rec.local_updatable = True
def parse(instruction):
global bigmax
raw = instruction.split()
compare = raw[4]
value = int(raw[6])
if compare not in registers:
registers[compare] = 0
ops = { '>': operator.gt(registers[compare], value),
'<': operator.lt(registers[compare], value),
'>=': operator.ge(registers[compare], value),
'<=': operator.le(registers[compare], value),
'==': operator.eq(registers[compare], value),
'!=': operator.ne(registers[compare], value),
}
if ops[raw[5]]:
target = raw[0]
if target not in registers:
registers[target] = 0
if raw[1] == "inc":
bigsum = registers[target] + int(raw[2])
registers[target] = bigsum
if bigsum > bigmax:
bigmax = bigsum
else:
bigsum = registers[target] - int(raw[2])
registers[target] = bigsum
if bigsum > bigmax:
bigmax = bigsum
def cmp_fun():
a, b = 5, 3
print (operator.lt(a,b))
#True Same as a<b.
print (operator.le(a, b))
# False
print (operator.eq(a,b))
# False
print (operator.ne(a,b))
#TRUE
print(operator.ge(a,b))
#False Same as a>=b
print (operator.gt(a, b))
# True
print (operator.__lt__(a, b))
#TRUE
print (operator.__le__(a, b))
#TRUE
print (operator.__ne__(a, b))
#TRUE Same as a<b.
print (operator.__ge__(a, b))
#FALSE
print (operator.__gt__(a, b))
#FALSE
print (operator.__eq__(a, b))
def delete(self, root, node):
if root is None:
return None
root.size -= 1
if lt(node, root):
# Delete from left subtree
root.left = self.delete(root.left, node)
root.increment_rank_on_right_subtree(-1)
elif gt(node, root):
# Delete from right subtreee
root.right = self.delete(root.right, node)
else:
# Delete the node currently at 'root'
if root.left is None:
root = root.right
elif root.right is None:
root = root.left
else:
successor = root.right.min_value()
root.key = successor.key
root.right = self.delete(root.right, successor)
return root
def checkForBeta(start, end):
rightIndexing = op.truediv(
sum([
betaValues[aminoAcid[x]]
for x in inputProteinSequence[op.sub(end, 3):op.add(end, 1)]
]), 4)
while op.and_(op.lt(end, len(inputProteinSequence)),
op.ge(rightIndexing, 1)):
end = op.add(end, 1)
rightIndexing = op.truediv(
sum([
betaValues[aminoAcid[x]]
for x in inputProteinSequence[op.sub(end, 3):op.add(end, 1)]
]), 4)
leftIndexing = op.truediv(
sum([
betaValues[aminoAcid[x]]
for x in inputProteinSequence[op.sub(start, 1):op.add(start, 3)]
]), 4)
while op.and_(op.gt(start, 0), op.ge(leftIndexing, 1)):
start = op.sub(start, 1)
leftIndexing = op.truediv(
sum([
betaValues[aminoAcid[x]] for x in
inputProteinSequence[op.sub(start, 1):op.add(start, 3)]
]), 4)
for i in range(start, end):
Strand[i] = True
def __init__(self):
# xl to py formulas conversion for eval()
self.__author__ = __author__
self.__version__ = __version__
# xl to py formula conversion
self.fun_database = {
'IF' : lambda args : [args[0]*args[1]+(abs(args[0]-1)*args[2])][0],\
'AVERAGE' : lambda args : np.average(args[0]),\
'STDEV.P' : lambda args : np.std(args[0]),\
'TRANSPOSE' : lambda args : np.transpose(args[0]),\
'ABS' : lambda args : np.abs(args[0]),\
'MMULT' : lambda args : np.dot(*args),\
'IFERROR' : lambda args : self.pyxl_error(*args),\
'SUM' : lambda args : np.sum(args[0]),\
'COUNT' : lambda args : np.size(args[0]),\
'SQRT' : lambda args : np.sqrt(args[0]),\
'^' : lambda args : np.power(*args),\
'<' : lambda args : np.float64(op.lt(*args)),\
'>' : lambda args : np.float64(op.gt(*args)),\
'<=' : lambda args : np.float64(op.le(*args)),\
'>=' : lambda args : np.float64(op.ge(*args)),\
'<>' : lambda args : np.float64(op.ne(*args)),\
'=' : lambda args : np.float64(op.eq(*args)),\
'+' : lambda args : np.add(*args),\
'-' : lambda args : np.subtract(*args),\
'/' : lambda args : np.divide(*args),\
'*' : lambda args : np.multiply(*args)
}
def crosstalk(records):
x = filter(lambda x: (operator.gt(int(x[3]), 1)), records)
crosstalk_count = 0
for i, r in enumerate(records[1:]): # Starts with the 2nd element.
if not r[2] == records[i][2]: # Compares second to first initially.
crosstalk_count += 1 # Comparison is only ever speaker to speaker.
return crosstalk_count / float(len(records) - 1)
def dynamic_filters_communications(filters):
"""Build a filter dynamically for communications table from query paramaters
:param dict filters: Dictionary of arg-value pairs
:returns: a list of filters which can be passed into SQL alchemy filter queries.
:rtype: list
"""
filter_ops = []
for arg, value in filters.items():
if arg == 'last_id':
filter_ops.append(operator.gt(Communications.id, value))
elif arg == 'receiver':
filter_ops.append(operator.eq(Communications.receiver, value))
elif arg == 'sender':
filter_ops.append(operator.eq(Communications.sender, value))
elif arg == 'ignore_sender':
filter_ops.append(operator.ne(Communications.sender, value))
elif arg == 'max':
max_comm = Communications.query.order_by(
Communications.id.desc()).limit(1).first()
max_id = -1 if max_comm is None else max_comm.id
filter_ops.append(operator.eq(Communications.id, max_id))
else:
pass
return filter_ops
def _draw_surfaces(self, surface, offset, surfaces):
""" Draw surfaces onto buffer, then redraw tiles that cover them
:param surface: destination
:param offset: offset to compensate for buffer alignment
:param surfaces: sequence of surfaces to blit
"""
surface_blit = surface.blit
ox, oy = offset
left, top = self._tile_view.topleft
hit = self._layer_quadtree.hit
get_tile = self.data.get_tile_image
tile_layers = tuple(self.data.visible_tile_layers)
dirty = list()
dirty_append = dirty.append
for i in surfaces:
try:
flags = i[3]
except IndexError:
dirty_append((surface_blit(i[0], i[1]), i[2]))
else:
dirty_append((surface_blit(i[0], i[1], None, flags), i[2]))
for dirty_rect, layer in dirty:
for r in hit(dirty_rect.move(ox, oy)):
x, y, tw, th = r
for l in [i for i in tile_layers if gt(i, layer)]:
tile = get_tile((x // tw + left, y // th + top, l))
if tile:
surface_blit(tile, (x - ox, y - oy))
def __init__(self):
# xl to py formulas conversion for eval()
self.__author__ = __author__
self.__version__ = __version__
# xl to py formula conversion
self.fun_database = {
'IF' : lambda args : [args[0]*args[1]+(abs(args[0]-1)*args[2])][0],\
'AVERAGE' : lambda args : np.average(args[0]),\
'STDEV.P' : lambda args : np.std(args[0]),\
'TRANSPOSE' : lambda args : np.transpose(args[0]),\
'ABS' : lambda args : np.abs(args[0]),\
'MMULT' : lambda args : np.dot(*args),\
'IFERROR' : lambda args : self.pyxl_error(*args),\
'SUM' : lambda args : np.sum(args[0]),\
'COUNT' : lambda args : np.size(args[0]),\
'SQRT' : lambda args : np.sqrt(args[0]),\
'^' : lambda args : np.power(*args),\
'<' : lambda args : np.float64(op.lt(*args)),\
'>' : lambda args : np.float64(op.gt(*args)),\
'<=' : lambda args : np.float64(op.le(*args)),\
'>=' : lambda args : np.float64(op.ge(*args)),\
'<>' : lambda args : np.float64(op.ne(*args)),\
'=' : lambda args : np.float64(op.eq(*args)),\
'+' : lambda args : np.add(*args),\
'-' : lambda args : np.subtract(*args),\
'/' : lambda args : np.divide(*args),\
'*' : lambda args : np.multiply(*args)
}
def cmp(a, b):
if op.lt(a,b):
return -1
elif op.gt(a,b):
return 1
else:
return 0
def _draw_surfaces(self, surface, offset, surfaces):
""" Draw surfaces onto buffer, then redraw tiles that cover them
:param surface: destination
:param offset: offset to compensate for buffer alignment
:param surfaces: sequence of surfaces to blit
"""
surface_blit = surface.blit
ox, oy = offset
left, top = self._tile_view.topleft
hit = self._layer_quadtree.hit
get_tile = self.data.get_tile_image
tile_layers = tuple(self.data.visible_tile_layers)
dirty = list()
dirty_append = dirty.append
for i in surfaces:
try:
flags = i[3]
except IndexError:
dirty_append((surface_blit(i[0], i[1]), i[2]))
else:
dirty_append((surface_blit(i[0], i[1], None, flags), i[2]))
for dirty_rect, layer in dirty:
for r in hit(dirty_rect.move(ox, oy)):
x, y, tw, th = r
for l in [i for i in tile_layers if gt(i, layer)]:
tile = get_tile((x // tw + left, y // th + top, l))
if tile:
surface_blit(tile, (x - ox, y - oy))
def evaluate(cond): # Method to evaluate the conditions
if isinstance(cond, bool):
return cond
left, oper, right = cond
if not model or not left in model.mgroup.fields: #check that the field exist
return False
oper = self.OPERAND_MAPPER.get(oper.lower(), oper)
if oper == '=':
res = operator.eq(model[left].get(model), right)
elif oper == '!=':
res = operator.ne(model[left].get(model), right)
elif oper == '<':
res = operator.lt(model[left].get(model), right)
elif oper == '>':
res = operator.gt(model[left].get(model), right)
elif oper == '<=':
res = operator.le(model[left].get(model), right)
elif oper == '>=':
res = operator.ge(model[left].get(model), right)
elif oper == 'in':
res = operator.contains(right, model[left].get(model))
elif oper == 'not in':
res = operator.contains(right, model[left].get(model))
res = operator.not_(res)
return res
def _get_constraint_maps(cls):
"""
All constraints expect two parameters:
- the DataFrame to be constrained
- the constraint
"""
from functools import reduce
from operator import eq, gt, ge, lt, le, and_, or_
return {
CONSTRAINTS.AND:
lambda df, c: reduce(and_, (cls._get_constraint_for_df(df, op)
for op in c.operands)),
CONSTRAINTS.OR:
lambda df, c: reduce(or_, (cls._get_constraint_for_df(df, op)
for op in c.operands)),
CONSTRAINTS.EQUALITY:
lambda df, c: eq(df[c.field], c.value),
CONSTRAINTS.INEQUALITY_GT:
lambda df, c: gt(df[c.field], c.value),
CONSTRAINTS.INEQUALITY_GTE:
lambda df, c: ge(df[c.field], c.value),
CONSTRAINTS.INEQUALITY_LT:
lambda df, c: lt(df[c.field], c.value),
CONSTRAINTS.INEQUALITY_LTE:
lambda df, c: le(df[c.field], c.value),
CONSTRAINTS.IN:
lambda df, c: df[c.field].isin(c.value),
}
def evaluate(self):
result = None
left = self.left.evaluate()
right = self.right.evaluate()
if self.operation == '+':
result = operator.add(left, right)
elif self.operation == '-':
result = operator.sub(left, right)
elif self.operation == '*':
result = operator.mul(left, right)
elif self.operation == '/':
result = operator.div(left, right)
elif self.operation == '^':
result = operator.pow(left, right)
elif self.operation == 'and':
result = left and right
elif self.operation == 'or':
result = left or right
elif self.operation == '<':
result = operator.lt(left, right)
elif self.operation == '<=':
result = operator.le(left, right)
elif self.operation == '==':
result = operator.eq(left, right)
elif self.operation == '!=':
result = operator.ne(left, right)
elif self.operation == '>':
result = operator.gt(left, right)
elif self.operation == '>=':
result = operator.ge(left, right)
elif self.operation == 'in':
result = (left in right)
return result
def link_with_co_author(resolved, unresolved, company_list):
'''
return
resolved: set((inventor, company))
unresolved: list(inventor)
'''
co_inventor = set()
for pair in resolved:
for inventor in unresolved:
for company in company_list:
t1 = pair
t2 = (inventor, company)
if op.gt(t1, t2):
t1, t2 = t2, t1
co_inventor.add((t1, t2))
co_author = fetch_co_author(resolved, unresolved, company_list)
inventor2company = {}
for pair in co_inventor & co_author:
t = pair[0]
if t not in resolved:
t = pair[1]
inventor2company.setdefault(t[0], [])
inventor2company[t[0]].append(t[1])
new_resolved = set()
new_unresolved = []
for inventor in unresolved:
if inventor in inventor2company and len(
inventor2company[inventor]) == 1:
new_resolved.add((inventor, inventor2company[inventor][0]))
else:
new_unresolved.append(inventor)
return new_resolved, new_unresolved
def PriorityInsertGroup(groups, group):
length = len(groups)
for i in range(0, length):
if operator.gt(groups[i]['name'].lower(), group['name'].lower()):
groups.insert(i, group)
return
groups.append(group)
def checkForAlpha(start, end):
rightIndexing = op.truediv(
sum([
alphaValues[aminoAcid[x]]
for x in inputProteinSequence[op.sub(start, 3):op.add(start, 7)]
]), 4)
line = start + 7
while op.and_(op.lt(line, len(inputProteinSequence)),
op.ge(rightIndexing, 1)):
line = op.add(line, 1)
rightIndexing = op.truediv(
sum([
alphaValues[aminoAcid[x]] for x in
inputProteinSequence[op.sub(start, 3):op.add(start, 7)]
]), 4)
leftIndexing = op.truediv(
sum([
alphaValues[aminoAcid[x]]
for x in inputProteinSequence[op.sub(start, 1):op.add(start, 3)]
]), 4)
booline = start - 1
while op.and_(op.gt(booline, 0), op.ge(leftIndexing, 1)):
booline = op.sub(booline, 1)
leftIndexing = op.truediv(
sum([
alphaValues[aminoAcid[x]] for x in
inputProteinSequence[op.sub(start, 1):op.add(start, 3)]
]), 4)
for i in range(start, end):
Helix[i] = True
def testGUIDRichCmp(self):
s = "{00020400-0000-0000-C000-000000000046}"
iid = pywintypes.IID(s)
assert not (s is None)
assert not (None == s)
assert s is not None
assert None != s
if sys.version_info > (3, 0):
with pytest.raises(TypeError):
operator.gt(None, s)
with pytest.raises(TypeError):
operator.gt(s, None)
with pytest.raises(TypeError):
operator.lt(None, s)
with pytest.raises(TypeError):
operator.lt(s, None)
def evaluate(cond): # Method to evaluate the conditions
if isinstance(cond,bool):
return cond
left, oper, right = cond
if not model or not left in model.mgroup.fields: #check that the field exist
return False
oper = self.OPERAND_MAPPER.get(oper.lower(), oper)
if oper == '=':
res = operator.eq(model[left].get(model),right)
elif oper == '!=':
res = operator.ne(model[left].get(model),right)
elif oper == '<':
res = operator.lt(model[left].get(model),right)
elif oper == '>':
res = operator.gt(model[left].get(model),right)
elif oper == '<=':
res = operator.le(model[left].get(model),right)
elif oper == '>=':
res = operator.ge(model[left].get(model),right)
elif oper == 'in':
res = operator.contains(right, model[left].get(model))
elif oper == 'not in':
res = operator.contains(right, model[left].get(model))
res = operator.not_(res)
return res
def post(self):
user_id = self.get_argument('user_id', None)
bank_id = self.get_argument('bank_id', None)
amount = self.get_argument('amount', None)
if not user_id or not bank_id or not amount:
data = {'result': 'error', 'msg': '参数缺失!'}
self.write(json.JSONEncoder().encode(data))
return
maxValue = UserHandler.get_can_withdraw_money(user_id)
if operator.gt(float(amount), float(maxValue)):
data = {'result': 'error', 'msg': '提现金额不得大于:{}'.format(maxValue)}
self.write(json.JSONEncoder().encode(data))
return
uw = UserWithdraw()
uw.user_id = user_id
uw.bank_id = bank_id
uw.amount = amount
uw.status = UserWithdraw.StatusPending
self.session.add(uw)
try:
self.session.commit()
except DBAPIError as e:
print(e.args[0])
data = {'result': 'error', 'msg': '提现申请失败，请稍后尝试!'}
else:
data = {'result': 'success', 'msg': 'successfully!'}
finally:
self.session.close()
self.write(json.JSONEncoder().encode(data))
def specialcases(x):
operator.lt(x,3)
operator.le(x,3)
operator.eq(x,3)
operator.ne(x,3)
operator.gt(x,3)
operator.ge(x,3)
is_operator(x,3)
operator.__lt__(x,3)
operator.__le__(x,3)
operator.__eq__(x,3)
operator.__ne__(x,3)
operator.__gt__(x,3)
operator.__ge__(x,3)
# the following ones are constant-folded
operator.eq(2,3)
operator.__gt__(2,3)
def pause_count(records, min_pause, max_pause): # The meaning of minVol
# is still the minimum volume to count, but now it determines
# exclusion not inclusion.
silences = filter(lambda x: (operator.eq(0, int(x[3]))), records)
time_diffs = [int(records[i][0]) - int(records[i - 1][0]) for i in range(len(records))]
return len(
filter(lambda x: (operator.and_(operator.gt(x, min_pause), operator.lt(x, max_pause))), time_diffs)
) / float(len(records) - 1)
def NetCountFilterPerItem(self,df,state): # Usado para completar la info y determinar las altas y bajas netas comparison = op.gt(df[self.colsum],0) if state else op.lt(df[self.colsum],0) df_state=df[(df['filter']=='new_filter') & comparison] (index_filter, value_filter)=self.RepositoryProcessSupport.IndexValueState(df_state,self.sort_list,self.order_list,self.colsum,self.nombre_filtro,self.filtro_principal) df.loc[index_filter,'filter']=value_filter return df
def play(self):
while(True):
print("\n(1) : Rock\n(2) : Paper\n(3) : Scissors\n(4) : Spock\n(5) : Lizard\n")
choice = int(input("Enter your move: "))
if operator.gt(choice,0) & operator.lt(choice,6):
break
else:
choice = input("Enter your move: ")
choice-=1
return moves[choice]
def play(self):
while (True):
try:
print("Please choose a move:\n (1) Rock\n (2) Paper\n (3) Scissors")
choice = int(input(" (4) Lizard\n (5) Spock\n"))
if (operator.lt(choice, 6) & operator.gt(choice, 0)):
break
else:
print("Please enter a number between 1 and 5.")
except ValueError:
print("Please enter a number between 1 and 5.")
return moves[choice-1]
def test_gt(self):
self.failUnless(operator.gt(1, 0))
self.failUnless(operator.gt(1, 0.0))
self.failIf(operator.gt(1, 1))
self.failIf(operator.gt(1, 1.0))
self.failIf(operator.gt(1, 2))
self.failIf(operator.gt(1, 2.0))
def get_comparision_verdict_with_text(comp_operator,
actual_value,
expected_value,
expected_min_value,
expected_max_value,
property_name):
"""
comp_operator: Enum comp_operator
values: for comparision
property_name: string used for verdict text message.
Return dictionary with verdict as bool and verdict text
"""
verdict = False
expected_filter_string = 'None'
if comp_operator == 'LESS_THAN':
verdict = operator.lt(actual_value, expected_value)
expected_filter_string = ' less than ' + str(expected_value)
elif comp_operator == 'LESS_THAN_OR_EQUAL':
verdict = operator.le(actual_value, expected_value)
expected_filter_string = ' less than or equal to ' + str(expected_value)
elif comp_operator == 'GREATER_THAN':
verdict = operator.gt(actual_value, expected_value)
expected_filter_string = ' greater than ' + str(expected_value)
elif comp_operator == 'GREATER_THAN_OR_EQUAL':
verdict = operator.ge(actual_value, expected_value)
expected_filter_string = ' greater than or equal to ' + str(expected_value)
elif comp_operator == 'EQUAL':
verdict = operator.eq(actual_value, expected_value)
expected_filter_string = ' equal to ' + str(expected_value)
elif comp_operator == 'NOT_EQUAL':
verdict = operator.ne(actual_value, expected_value)
expected_filter_string = ' not equal to ' + str(expected_value)
elif comp_operator == 'BETWEEN':
verdict = operator.le(expected_min_value, actual_value) and \
operator.le(actual_value, expected_max_value)
expected_filter_string = ' between ' + str(expected_min_value) + \
' and ' + str(expected_max_value) + ', inclusive'
else:
raise Exception("Unsupported comparision operator {0}".format(comp_operator))
pass_fail_text = ' does not match '
if verdict is True:
pass_fail_text = ' matches '
verdict_text = 'Actual ' + property_name + pass_fail_text + 'expected ' + \
property_name + '. Actual count: ' + str(actual_value) + \
'; expected count:' + expected_filter_string + '.'
data = {}
data[ProviderConst.VERDICT] = verdict
data[ProviderConst.VERDICT_TEXT] = verdict_text
return data
def degreesToCardinal(self, deg): if(((operator.gt(deg, 326)) and (operator.lt(deg, 360))) or ((operator.gt(deg, 0)) and (operator.lt(deg, 12)))): return 'North' elif((operator.gt(deg, 11)) and (operator.lt(deg, 57))): return 'Northeast' elif((operator.gt(deg, 56)) and (operator.lt(deg, 102))): return 'East' elif((operator.gt(deg, 101)) and (operator.lt(deg, 169))): return 'Southeast' elif((operator.gt(deg, 168)) and (operator.lt(deg, 192))): return 'South' elif((operator.gt(deg, '191')) and (operator.lt(deg, 237))): return 'Southwest' elif((operator.gt(deg, 236)) and (operator.lt(deg, 282))): return 'West' elif((operator.gt(deg, 281)) and (operator.lt(deg, 327))): return 'Northwest' else: return 'Unknown'
def test_gt(self):
#operator = self.module
self.assertRaises(TypeError, operator.gt)
self.assertTrue(operator.gt(1, 0))
self.assertTrue(operator.gt(1, 0.0))
self.assertFalse(operator.gt(1, 1))
self.assertFalse(operator.gt(1, 1.0))
self.assertFalse(operator.gt(1, 2))
self.assertFalse(operator.gt(1, 2.0))
def test_gt(self):
self.assertRaises(TypeError, operator.gt)
self.assertRaises(TypeError, operator.gt, 1j, 2j)
self.assertTrue(operator.gt(1, 0))
self.assertTrue(operator.gt(1, 0.0))
self.assertFalse(operator.gt(1, 1))
self.assertFalse(operator.gt(1, 1.0))
self.assertFalse(operator.gt(1, 2))
self.assertFalse(operator.gt(1, 2.0))
def test_gt(self):
self.failUnlessRaises(TypeError, operator.gt)
self.failUnlessRaises(TypeError, operator.gt, 1j, 2j)
self.failUnless(operator.gt(1, 0))
self.failUnless(operator.gt(1, 0.0))
self.failIf(operator.gt(1, 1))
self.failIf(operator.gt(1, 1.0))
self.failIf(operator.gt(1, 2))
self.failIf(operator.gt(1, 2.0))
def gt(self, a, b, rtol=None, atol=None):
"""Tests a > b with tolerance."""
if rtol is None: rtol = FloatComparison.rtol
if atol is None: atol = FloatComparison.atol
if isinstance(a, (float, int)):
return operator.gt(a, b - atol - rtol*math.fabs(b))
elif isinstance(a, complex):
return self.gt(a.real, b.real, op, rtol, atol) and \
self.gt(a.imag, b.imag, op, rtol, atol)
else: # assume NumPy array
try:
r = a > b - atol - rtol*abs(b)
return r.all() # all must be true
except:
raise TypeError('Illegal types: a is %s and b is %s' % \
(type(a), type(b)))
def check_condition(operand_a, oper, operand_b):
"""
Checks condition:
\t**operand_a op operand_b**
where:
\t\t*operand_a*, *operand_b* - numbers\n
\t\t*op* - operator = [< | > | <= | >= | == | =]
Returns True if condition is met, False otherwise.
:param operand_a: number
:type operand_a: int
:param oper: operator = [< | > | <= | >= | == | =]
:type oper: str
:param operand_b: number
:type operand_b: int
:returns: True if condition is met, False otherwise.
:raise Exception: when operator is not in [< | > | <= | >= | == | =]
"""
if isinstance(operand_a, int):
# if type(operand_a) is not int:
a_n = int(operand_a)
else:
a_n = operand_a
if isinstance(operand_b, int):
# if type(operand_b) is not int:
b_n = int(operand_b)
else:
b_n = operand_b
if oper == "=" or oper == "==":
return operator.eq(a_n, b_n)
elif oper == "<=":
return operator.le(a_n, b_n)
elif oper == "<":
return operator.lt(a_n, b_n)
elif oper == ">=":
return operator.ge(a_n, b_n)
elif oper == ">":
return operator.gt(a_n, b_n)
else:
raise Exception("Not supported operator: " + oper)
def _query_chunks(query, model, orderings, chunk_size):
"""Paginate query by chunks of specific size.
The main difference here from util functions generating chunkyfied query
provided in utils module is that here no offset is used. Chunks are queried
here using filters which is faster comparing to offsets in case of large
number of records in query.
Args:
query: Query to be paginated.
model: Model used in `query`.
orderings: Orderings used in `query`.
chunk_size: Size of chunks.
Yields:
Objects in chunks from query query.
"""
filters = [sa.true() for _ in orderings]
count = query.count()
for _ in range(0, count, chunk_size):
# Pagination is performed by filtering here insted of using offset since
# using offset with large values is much slower than plain filtering.
paginated_q = query.from_self().filter(*filters).limit(chunk_size)
chunk = paginated_q.all()
yield chunk
if chunk:
# Filters should be recalculated here to return new chunk on next iter.
# New filters should be in form "ordering field >= last in chunk" except
# for the last field in orderings - this one should be > last in chunk.
ge_filter_fields, gt_filter_field = orderings[:-1], orderings[-1]
last_in_chunk = chunk[-1]
filters = [
op.ge(getattr(model, field), getattr(last_in_chunk, field))
for field in ge_filter_fields
]
filters.append(
op.gt(
getattr(model, gt_filter_field),
getattr(last_in_chunk, gt_filter_field),
)
)
def _draw_surfaces(self, surface, rect, surfaces):
""" Draw surfaces onto map, then redraw tiles that cover them
:param surface: destination
:param rect: clipping area
:param surfaces: sequence of surfaces to blit
"""
surface_blit = surface.blit
left, top = self._tile_view.topleft
ox = self._x_offset - rect.left
oy = self._y_offset - rect.top
hit = self._layer_quadtree.hit
get_tile = self.data.get_tile_image
tile_layers = tuple(self.data.visible_tile_layers)
dirty = [(surface_blit(i[0], i[1]), i[2]) for i in surfaces]
for dirty_rect, layer in dirty:
for r in hit(dirty_rect.move(ox, oy)):
x, y, tw, th = r
for l in [i for i in tile_layers if gt(i, layer)]:
tile = get_tile((x // tw + left, y // th + top, l))
if tile:
surface_blit(tile, (x - ox, y - oy))
def execute_binary_operator(cls, val, x, y):
"""Execute binary operators
Execute binary operator
Arguments:
val {int} -- int
x {int} -- int
y {int} -- int
Returns:
int -- operation result
"""
if val == 0:
return operator.add(x,y)
elif val == 1:
return operator.sub(x,y)
elif val == 2:
return operator.mul(x,y)
elif val == 3:
return operator.div(x,y)
elif val == 4:
return operator.lt(x,y)
elif val == 5:
return operator.gt(x,y)
elif val == 6:
return operator.le(x,y)
elif val == 7:
return operator.ge(x,y)
elif val == 8:
return operator.eq(x,y)
elif val == 9:
return operator.ne(x,y)
elif val == 12:
return operator.mod(x,y)
def gt_usecase(x, y):
return operator.gt(x, y)
if not label: label = name
return """<a href="/desk#!Form/%(doctype)s/%(name)s">%(label)s</a>""" % locals()
operator_map = {
# startswith
"^": lambda (a, b): (a or "").startswith(b),
# in or not in a list
"in": lambda (a, b): operator.contains(b, a),
"not in": lambda (a, b): not operator.contains(b, a),
# comparison operators
"=": lambda (a, b): operator.eq(a, b),
"!=": lambda (a, b): operator.ne(a, b),
">": lambda (a, b): operator.gt(a, b),
"<": lambda (a, b): operator.lt(a, b),
">=": lambda (a, b): operator.ge(a, b),
"<=": lambda (a, b): operator.le(a, b),
"not None": lambda (a, b): a and True or False,
"None": lambda (a, b): (not a) and True or False
}
def compare(val1, condition, val2):
ret = False
if condition in operator_map:
ret = operator_map[condition]((val1, val2))
return ret
def scrub_urls(html):
from __main__ import display
except ImportError:
from ansible.utils.display import Display
display = Display()
if version_info[0] > 2:
raise AnsibleError(('Trellis does not yet support Python {}.{}.{}. \n'
'Please use Python 2.7.').format(version_info[0], version_info[1], version_info[2]))
version_requirement = '2.4.0.0'
version_tested_max = '2.5.3'
if not ge(LooseVersion(__version__), LooseVersion(version_requirement)):
raise AnsibleError(('Trellis no longer supports Ansible {}.\n'
'Please upgrade to Ansible {} or higher.').format(__version__, version_requirement))
elif gt(LooseVersion(__version__), LooseVersion(version_tested_max)):
display.warning(u'You Ansible version is {} but this version of Trellis has only been tested for '
u'compatability with Ansible {} -> {}. It is advisable to check for Trellis updates or '
u'downgrade your Ansible version.'.format(__version__, version_requirement, version_tested_max))
if eq(LooseVersion(__version__), LooseVersion('2.5.0')):
display.warning(u'You Ansible version is {}. Consider upgrading your Ansible version to avoid '
u'erroneous warnings such as `Removed restricted key from module data...`'.format(__version__))
# Import BaseVarsPlugin after Ansible version check.
# Otherwise import error for Ansible versions older than 2.4 would prevent display of version check message.
from ansible.plugins.vars import BaseVarsPlugin
class VarsModule(BaseVarsPlugin):
def __lt__(self, other):
return operator.gt(self.obj, other.obj)
def test_view_set(self):
oc = NSDictionary(a=1, b=2, c=3, d=4, e=5)
v = oc.viewkeys() | {'a', 'f' }
self.assertEqual(v, {'a', 'b', 'c', 'd', 'e', 'f' })
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.or_, oc.viewkeys(), ('a', 'f'))
self.assertRaises(TypeError, operator.or_, ('a', 'f'), oc.keys())
v = oc.viewkeys() & {'a', 'f' }
self.assertEqual(v, {'a'})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.and_, oc.viewkeys(), ('a', 'f'))
self.assertRaises(TypeError, operator.and_, ('a', 'f'), oc.keys())
v = oc.viewkeys() ^ {'a', 'f' }
self.assertEqual(v, {'b', 'c', 'd', 'e', 'f'})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.xor, oc.viewkeys(), ('a', 'f'))
self.assertRaises(TypeError, operator.xor, ('a', 'f'), oc.keys())
v = oc.viewkeys() - {'a', 'f' }
self.assertEqual(v, {'b', 'c', 'd', 'e'})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.sub, oc.viewkeys(), ('a', 'f'))
self.assertRaises(TypeError, operator.sub, ('a', 'f'), oc.keys())
self.assertTrue(operator.lt(oc.viewkeys(), ('a', 'f')))
self.assertTrue(operator.le(oc.viewkeys(), ('a', 'f')))
self.assertFalse(operator.gt(oc.viewkeys(), ('a', 'f')))
self.assertFalse(operator.ge(oc.viewkeys(), ('a', 'f')))
v = oc.viewvalues() | {1, 9 }
self.assertEqual(v, {1,2,3,4,5,9})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.or_, oc.viewvalues(), (1, 9))
self.assertRaises(TypeError, operator.or_, (1, 9), oc.viewvalues())
v = oc.viewvalues() & {1, 9 }
self.assertEqual(v, {1})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.and_, oc.viewvalues(), (1, 9))
self.assertRaises(TypeError, operator.and_, (1, 9), oc.viewvalues())
v = oc.viewvalues() ^ {1, 9 }
self.assertEqual(v, {2, 3, 4, 5, 9})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.xor, oc.viewvalues(), (1, 9))
self.assertRaises(TypeError, operator.xor, (1, 9), oc.viewvalues())
v = oc.viewvalues() - {1, 9 }
self.assertEqual(v, {2,3,4,5})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.sub, oc.viewvalues(), (1, 9))
self.assertRaises(TypeError, operator.sub, (1, 9), oc.viewvalues())
self.assertTrue(operator.lt(oc.viewvalues(), (1, 9)))
self.assertTrue(operator.le(oc.viewvalues(), (1, 9)))
self.assertFalse(operator.gt(oc.viewvalues(), (1, 9)))
self.assertFalse(operator.ge(oc.viewvalues(), (1, 9)))
v = oc.viewitems() | {('a', 1), ('f', 9) }
self.assertEqual(v, {('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 9)})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.or_, oc.viewitems(), (('a', 1), ('f', 9)))
self.assertRaises(TypeError, operator.or_, (1, 9), oc.viewitems())
v = oc.viewitems() & {('a',1), ('f',9)}
self.assertEqual(v, {('a', 1)})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.and_, oc.viewitems(), (('a', 1), ('f', 9)))
self.assertRaises(TypeError, operator.and_, (('a', 1), ('f', 9)), oc.viewitems())
v = oc.viewitems() ^ {('a',1), ('f',9)}
self.assertEqual(v, {('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 9)})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.xor, oc.viewitems(), (('a', 1), ('f', 9)))
self.assertRaises(TypeError, operator.xor, (('a', 1), ('f', 9)), oc.viewitems())
v = oc.viewitems() - {('a',1), ('f',9)}
self.assertEqual(v, {('b', 2), ('c', 3), ('d', 4), ('e', 5)})
self.assertIsInstance(v, set)
self.assertRaises(TypeError, operator.sub, oc.viewitems(), (('a', 1), ('f', 9)))
self.assertRaises(TypeError, operator.sub, (('a', 1), ('f', 9)), oc.viewitems())
self.assertTrue(operator.lt(oc.viewitems(), (('a', 1), ('f', 9))))
self.assertTrue(operator.le(oc.viewitems(), (('a', 1), ('f', 9))))
self.assertFalse(operator.gt(oc.viewitems(), (('a', 1), ('f', 9))))
self.assertFalse(operator.ge(oc.viewitems(), (('a', 1), ('f', 9))))
def gt(a,b): #wrapper to handle imaginary numbers
if(a.imag==0 and b.imag==0):
return float(operator.gt(a.real,b.real))
else:
raise TypeError
return get_url(uri = "desk#Report/{0}/{1}".format(quoted(doctype), quoted(name)))
else:
return get_url(uri = "desk#query-report/{0}".format(quoted(name)))
operator_map = {
# startswith
"^": lambda a, b: (a or "").startswith(b),
# in or not in a list
"in": lambda a, b: operator.contains(b, a),
"not in": lambda a, b: not operator.contains(b, a),
# comparison operators
"=": lambda a, b: operator.eq(a, b),
"!=": lambda a, b: operator.ne(a, b),
">": lambda a, b: operator.gt(a, b),
"<": lambda a, b: operator.lt(a, b),
">=": lambda a, b: operator.ge(a, b),
"<=": lambda a, b: operator.le(a, b),
"not None": lambda a, b: a and True or False,
"None": lambda a, b: (not a) and True or False
}
def evaluate_filters(doc, filters):
'''Returns true if doc matches filters'''
if isinstance(filters, dict):
for key, value in iteritems(filters):
f = get_filter(None, {key:value})
if not compare(doc.get(f.fieldname), f.operator, f.value):
return False
