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 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 cmp(a, b): if op.lt(a,b): return -1 elif op.gt(a,b): return 1 else: return 0
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