Python operator.ge() Examples
The following are 30
code examples of operator.ge().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
operator
, or try the search function
.
Example #1
Source File: test_fractions.py From ironpython2 with Apache License 2.0 | 6 votes |
def testBigComplexComparisons(self): self.assertFalse(F(10**23) == complex(10**23)) self.assertRaises(TypeError, operator.gt, F(10**23), complex(10**23)) self.assertRaises(TypeError, operator.le, F(10**23), complex(10**23)) x = F(3, 8) z = complex(0.375, 0.0) w = complex(0.375, 0.2) self.assertTrue(x == z) self.assertFalse(x != z) self.assertFalse(x == w) self.assertTrue(x != w) for op in operator.lt, operator.le, operator.gt, operator.ge: self.assertRaises(TypeError, op, x, z) self.assertRaises(TypeError, op, z, x) self.assertRaises(TypeError, op, x, w) self.assertRaises(TypeError, op, w, x)
Example #2
Source File: util.py From segpy with GNU Affero General Public License v3.0 | 6 votes |
def is_sorted(iterable, key=None, reverse=False, distinct=False): if key is None: key = identity if reverse: if distinct: if isinstance(iterable, range) and iterable.step < 0: return True op = operator.gt else: op = operator.ge else: if distinct: if isinstance(iterable, range) and iterable.step > 0: return True if isinstance(iterable, SortedFrozenSet): return True op = operator.lt else: op = operator.le return all(op(a, b) for a, b in pairwise(map(key, iterable)))
Example #3
Source File: __init__.py From jbox with MIT License | 6 votes |
def get_op(cls, op): ops = { symbol.test: cls.test, symbol.and_test: cls.and_test, symbol.atom: cls.atom, symbol.comparison: cls.comparison, 'not in': lambda x, y: x not in y, 'in': lambda x, y: x in y, '==': operator.eq, '!=': operator.ne, '<': operator.lt, '>': operator.gt, '<=': operator.le, '>=': operator.ge, } if hasattr(symbol, 'or_test'): ops[symbol.or_test] = cls.test return ops[op]
Example #4
Source File: sa_utils.py From aiohttp_admin with Apache License 2.0 | 6 votes |
def op(operation, column): if operation == 'in': def comparator(column, v): return column.in_(v) elif operation == 'like': def comparator(column, v): return column.like(v + '%') elif operation == 'eq': comparator = _operator.eq elif operation == 'ne': comparator = _operator.ne elif operation == 'le': comparator = _operator.le elif operation == 'lt': comparator = _operator.lt elif operation == 'ge': comparator = _operator.ge elif operation == 'gt': comparator = _operator.gt else: raise ValueError('Operation {} not supported'.format(operation)) return comparator # TODO: fix comparators, keys should be something better
Example #5
Source File: __init__.py From aireamhan with MIT License | 6 votes |
def add_globals(self): "Add some Scheme standard procedures." import math, cmath, operator as op from functools import reduce self.update(vars(math)) self.update(vars(cmath)) self.update({ '+':op.add, '-':op.sub, '*':op.mul, '/':op.itruediv, 'níl':op.not_, 'agus':op.and_, '>':op.gt, '<':op.lt, '>=':op.ge, '<=':op.le, '=':op.eq, 'mod':op.mod, 'frmh':cmath.sqrt, 'dearbhluach':abs, 'uas':max, 'íos':min, 'cothrom_le?':op.eq, 'ionann?':op.is_, 'fad':len, 'cons':cons, 'ceann':lambda x:x[0], 'tóin':lambda x:x[1:], 'iarcheangail':op.add, 'liosta':lambda *x:list(x), 'liosta?': lambda x:isa(x,list), 'folamh?':lambda x: x == [], 'adamh?':lambda x: not((isa(x, list)) or (x == None)), 'boole?':lambda x: isa(x, bool), 'scag':lambda f, x: list(filter(f, x)), 'cuir_le':lambda proc,l: proc(*l), 'mapáil':lambda p, x: list(map(p, x)), 'lódáil':lambda fn: load(fn), 'léigh':lambda f: f.read(), 'oscail_comhad_ionchuir':open,'dún_comhad_ionchuir':lambda p: p.file.close(), 'oscail_comhad_aschur':lambda f:open(f,'w'), 'dún_comhad_aschur':lambda p: p.close(), 'dac?':lambda x:x is eof_object, 'luacháil':lambda x: evaluate(x), 'scríobh':lambda x,port=sys.stdout:port.write(to_string(x) + '\n')}) return self
Example #6
Source File: utils.py From mars with Apache License 2.0 | 6 votes |
def _filter_range_index(pd_range_index, min_val, min_val_close, max_val, max_val_close): if is_pd_range_empty(pd_range_index): return pd_range_index raw_min, raw_max, step = pd_range_index.min(), pd_range_index.max(), _get_range_index_step(pd_range_index) # seek min range greater_func = operator.gt if min_val_close else operator.ge actual_min = raw_min while greater_func(min_val, actual_min): actual_min += abs(step) if step < 0: actual_min += step # on the right side # seek max range less_func = operator.lt if max_val_close else operator.le actual_max = raw_max while less_func(max_val, actual_max): actual_max -= abs(step) if step > 0: actual_max += step # on the right side if step > 0: return pd.RangeIndex(actual_min, actual_max, step) return pd.RangeIndex(actual_max, actual_min, step)
Example #7
Source File: validate_data.py From tcex with Apache License 2.0 | 6 votes |
def operator_ge(self, app_data, test_data): """Compare app data is greater than or equal to tests data. Args: app_data (dict, list, str): The data created by the App. test_data (dict, list, str): The data provided in the test case. Returns: bool, str: The results of the operator and any error message """ if app_data is None: return False, 'Invalid app_data: {app_data}' if test_data is None: return False, 'Invalid test_data: {test_data}' app_data = self._string_to_int_float(app_data) test_data = self._string_to_int_float(test_data) results = operator.ge(app_data, test_data) details = '' if not results: details = f'{app_data} {type(app_data)} !(>=) {test_data} {type(test_data)}' return results, details
Example #8
Source File: test_regression.py From auto-alt-text-lambda-api with MIT License | 6 votes |
def test_richcompare_crash(self): # gh-4613 import operator as op # dummy class where __array__ throws exception class Foo(object): __array_priority__ = 1002 def __array__(self,*args,**kwargs): raise Exception() rhs = Foo() lhs = np.array(1) for f in [op.lt, op.le, op.gt, op.ge]: if sys.version_info[0] >= 3: assert_raises(TypeError, f, lhs, rhs) else: f(lhs, rhs) assert_(not op.eq(lhs, rhs)) assert_(op.ne(lhs, rhs))
Example #9
Source File: test_arithmetic.py From recruit with Apache License 2.0 | 6 votes |
def test_comparison_flex_basic(self): left = pd.Series(np.random.randn(10)) right = pd.Series(np.random.randn(10)) tm.assert_series_equal(left.eq(right), left == right) tm.assert_series_equal(left.ne(right), left != right) tm.assert_series_equal(left.le(right), left < right) tm.assert_series_equal(left.lt(right), left <= right) tm.assert_series_equal(left.gt(right), left > right) tm.assert_series_equal(left.ge(right), left >= right) # axis for axis in [0, None, 'index']: tm.assert_series_equal(left.eq(right, axis=axis), left == right) tm.assert_series_equal(left.ne(right, axis=axis), left != right) tm.assert_series_equal(left.le(right, axis=axis), left < right) tm.assert_series_equal(left.lt(right, axis=axis), left <= right) tm.assert_series_equal(left.gt(right, axis=axis), left > right) tm.assert_series_equal(left.ge(right, axis=axis), left >= right) # msg = 'No axis named 1 for object type' for op in ['eq', 'ne', 'le', 'le', 'gt', 'ge']: with pytest.raises(ValueError, match=msg): getattr(left, op)(right, axis=1)
Example #10
Source File: test_operators.py From recruit with Apache License 2.0 | 6 votes |
def test_compare_frame(self): # GH#24282 check that Categorical.__cmp__(DataFrame) defers to frame data = ["a", "b", 2, "a"] cat = Categorical(data) df = DataFrame(cat) for op in [operator.eq, operator.ne, operator.ge, operator.gt, operator.le, operator.lt]: with pytest.raises(ValueError): # alignment raises unless we transpose op(cat, df) result = cat == df.T expected = DataFrame([[True, True, True, True]]) tm.assert_frame_equal(result, expected) result = cat[::-1] != df.T expected = DataFrame([[False, True, True, False]]) tm.assert_frame_equal(result, expected)
Example #11
Source File: test_regression.py From recruit with Apache License 2.0 | 6 votes |
def test_richcompare_crash(self): # gh-4613 import operator as op # dummy class where __array__ throws exception class Foo(object): __array_priority__ = 1002 def __array__(self, *args, **kwargs): raise Exception() rhs = Foo() lhs = np.array(1) for f in [op.lt, op.le, op.gt, op.ge]: if sys.version_info[0] >= 3: assert_raises(TypeError, f, lhs, rhs) elif not sys.py3kwarning: # With -3 switch in python 2, DeprecationWarning is raised # which we are not interested in f(lhs, rhs) assert_(not op.eq(lhs, rhs)) assert_(op.ne(lhs, rhs))
Example #12
Source File: test_regression.py From vnpy_crypto with MIT License | 6 votes |
def test_richcompare_crash(self): # gh-4613 import operator as op # dummy class where __array__ throws exception class Foo(object): __array_priority__ = 1002 def __array__(self, *args, **kwargs): raise Exception() rhs = Foo() lhs = np.array(1) for f in [op.lt, op.le, op.gt, op.ge]: if sys.version_info[0] >= 3: assert_raises(TypeError, f, lhs, rhs) elif not sys.py3kwarning: # With -3 switch in python 2, DeprecationWarning is raised # which we are not interested in f(lhs, rhs) assert_(not op.eq(lhs, rhs)) assert_(op.ne(lhs, rhs))
Example #13
Source File: test_flow.py From dwave-hybrid with Apache License 2.0 | 6 votes |
def test_energy_threshold_termination(self): class ExactSolver(Runnable): def next(self, state): return state.updated( samples=dimod.ExactSolver().sample(state.problem)) bqm = dimod.BinaryQuadraticModel({'a': 1}, {}, 0, dimod.SPIN) state = State.from_sample({'a': 1}, bqm) w = LoopUntilNoImprovement(ExactSolver(), key=operator.attrgetter('samples.first.energy'), terminate=partial(operator.ge, -1)) s = w.run(state).result() self.assertEqual(s.samples.first.energy, -1) w = LoopUntilNoImprovement(ExactSolver(), key='samples.first.energy', terminate=partial(operator.ge, -1)) s = w.run(state).result() self.assertEqual(s.samples.first.energy, -1) w = LoopUntilNoImprovement(ExactSolver(), terminate=partial(operator.ge, -1)) s = w.run(state).result() self.assertEqual(s.samples.first.energy, -1)
Example #14
Source File: __init__.py From lambda-chef-node-cleanup with Apache License 2.0 | 6 votes |
def get_op(cls, op): ops = { symbol.test: cls.test, symbol.and_test: cls.and_test, symbol.atom: cls.atom, symbol.comparison: cls.comparison, 'not in': lambda x, y: x not in y, 'in': lambda x, y: x in y, '==': operator.eq, '!=': operator.ne, '<': operator.lt, '>': operator.gt, '<=': operator.le, '>=': operator.ge, } if hasattr(symbol, 'or_test'): ops[symbol.or_test] = cls.test return ops[op]
Example #15
Source File: test_operators.py From vnpy_crypto with MIT License | 6 votes |
def test_comparison_flex_alignment(self): left = Series([1, 3, 2], index=list('abc')) right = Series([2, 2, 2], index=list('bcd')) exp = pd.Series([False, False, True, False], index=list('abcd')) assert_series_equal(left.eq(right), exp) exp = pd.Series([True, True, False, True], index=list('abcd')) assert_series_equal(left.ne(right), exp) exp = pd.Series([False, False, True, False], index=list('abcd')) assert_series_equal(left.le(right), exp) exp = pd.Series([False, False, False, False], index=list('abcd')) assert_series_equal(left.lt(right), exp) exp = pd.Series([False, True, True, False], index=list('abcd')) assert_series_equal(left.ge(right), exp) exp = pd.Series([False, True, False, False], index=list('abcd')) assert_series_equal(left.gt(right), exp)
Example #16
Source File: test_operators.py From vnpy_crypto with MIT License | 6 votes |
def test_comparison_flex_alignment_fill(self): left = Series([1, 3, 2], index=list('abc')) right = Series([2, 2, 2], index=list('bcd')) exp = pd.Series([False, False, True, True], index=list('abcd')) assert_series_equal(left.eq(right, fill_value=2), exp) exp = pd.Series([True, True, False, False], index=list('abcd')) assert_series_equal(left.ne(right, fill_value=2), exp) exp = pd.Series([False, False, True, True], index=list('abcd')) assert_series_equal(left.le(right, fill_value=0), exp) exp = pd.Series([False, False, False, True], index=list('abcd')) assert_series_equal(left.lt(right, fill_value=0), exp) exp = pd.Series([True, True, True, False], index=list('abcd')) assert_series_equal(left.ge(right, fill_value=0), exp) exp = pd.Series([True, True, False, False], index=list('abcd')) assert_series_equal(left.gt(right, fill_value=0), exp)
Example #17
Source File: test_operators.py From vnpy_crypto with MIT License | 6 votes |
def test_timestamp_compare(self): # make sure we can compare Timestamps on the right AND left hand side # GH4982 df = DataFrame({'dates1': date_range('20010101', periods=10), 'dates2': date_range('20010102', periods=10), 'intcol': np.random.randint(1000000000, size=10), 'floatcol': np.random.randn(10), 'stringcol': list(tm.rands(10))}) df.loc[np.random.rand(len(df)) > 0.5, 'dates2'] = pd.NaT ops = {'gt': 'lt', 'lt': 'gt', 'ge': 'le', 'le': 'ge', 'eq': 'eq', 'ne': 'ne'} for left, right in ops.items(): left_f = getattr(operator, left) right_f = getattr(operator, right) # no nats expected = left_f(df, Timestamp('20010109')) result = right_f(Timestamp('20010109'), df) assert_frame_equal(result, expected) # nats expected = left_f(df, Timestamp('nat')) result = right_f(Timestamp('nat'), df) assert_frame_equal(result, expected)
Example #18
Source File: test_richcmp.py From ironpython2 with Apache License 2.0 | 6 votes |
def test_dicts(self): # Verify that __eq__ and __ne__ work for dicts even if the keys and # values don't support anything other than __eq__ and __ne__ (and # __hash__). Complex numbers are a fine example of that. import random imag1a = {} for i in range(50): imag1a[random.randrange(100)*1j] = random.randrange(100)*1j items = imag1a.items() random.shuffle(items) imag1b = {} for k, v in items: imag1b[k] = v imag2 = imag1b.copy() imag2[k] = v + 1.0 self.assertTrue(imag1a == imag1a) self.assertTrue(imag1a == imag1b) self.assertTrue(imag2 == imag2) self.assertTrue(imag1a != imag2) for opname in ("lt", "le", "gt", "ge"): for op in opmap[opname]: self.assertRaises(TypeError, op, imag1a, imag2)
Example #19
Source File: test_operators.py From vnpy_crypto with MIT License | 5 votes |
def test_comparison_operators_with_nas(self): ser = Series(bdate_range('1/1/2000', periods=10), dtype=object) ser[::2] = np.nan # test that comparisons work ops = ['lt', 'le', 'gt', 'ge', 'eq', 'ne'] for op in ops: val = ser[5] f = getattr(operator, op) result = f(ser, val) expected = f(ser.dropna(), val).reindex(ser.index) if op == 'ne': expected = expected.fillna(True).astype(bool) else: expected = expected.fillna(False).astype(bool) assert_series_equal(result, expected) # fffffffuuuuuuuuuuuu # result = f(val, s) # expected = f(val, s.dropna()).reindex(s.index) # assert_series_equal(result, expected) # boolean &, |, ^ should work with object arrays and propagate NAs ops = ['and_', 'or_', 'xor'] mask = ser.isna() for bool_op in ops: func = getattr(operator, bool_op) filled = ser.fillna(ser[0]) result = func(ser < ser[9], ser > ser[3]) expected = func(filled < filled[9], filled > filled[3]) expected[mask] = False assert_series_equal(result, expected)
Example #20
Source File: _utils.py From UWGeodynamics with GNU General Public License v3.0 | 5 votes |
def __init__(self, velocity): self._Model = None self._wall = None self._time = None self.velocity = velocity self.material = None if isinstance(velocity, (list, tuple)): self.velocityFn = fn.branching.conditional(velocity) else: self.velocityFn = fn.misc.constant(nd(velocity)) self.wall_operators = {"left": op.le, "right": op.ge, "top":op.ge, "bottom": op.le, "front": op.ge, "back": op.le} self.wall_direction_axis = {"left": 0, "right": 0, "front": 1, "back": 1, "top": -1, "bottom": -1}
Example #21
Source File: test_query_eval.py From vnpy_crypto with MIT License | 5 votes |
def test_query_lex_compare_strings(self, parser, engine): import operator as opr a = Series(np.random.choice(list('abcde'), 20)) b = Series(np.arange(a.size)) df = DataFrame({'X': a, 'Y': b}) ops = {'<': opr.lt, '>': opr.gt, '<=': opr.le, '>=': opr.ge} for op, func in ops.items(): res = df.query('X %s "d"' % op, engine=engine, parser=parser) expected = df[func(df.X, 'd')] assert_frame_equal(res, expected)
Example #22
Source File: test_arithmetic.py From vnpy_crypto with MIT License | 5 votes |
def test_timestamp_compare_series(self): # make sure we can compare Timestamps on the right AND left hand side # GH#4982 ser = pd.Series(pd.date_range('20010101', periods=10), name='dates') s_nat = ser.copy(deep=True) ser[0] = pd.Timestamp('nat') ser[3] = pd.Timestamp('nat') ops = {'lt': 'gt', 'le': 'ge', 'eq': 'eq', 'ne': 'ne'} for left, right in ops.items(): left_f = getattr(operator, left) right_f = getattr(operator, right) # no nats expected = left_f(ser, pd.Timestamp('20010109')) result = right_f(pd.Timestamp('20010109'), ser) tm.assert_series_equal(result, expected) # nats expected = left_f(ser, pd.Timestamp('nat')) result = right_f(pd.Timestamp('nat'), ser) tm.assert_series_equal(result, expected) # compare to timestamp with series containing nats expected = left_f(s_nat, pd.Timestamp('20010109')) result = right_f(pd.Timestamp('20010109'), s_nat) tm.assert_series_equal(result, expected) # compare to nat with series containing nats expected = left_f(s_nat, pd.Timestamp('nat')) result = right_f(pd.Timestamp('nat'), s_nat) tm.assert_series_equal(result, expected)
Example #23
Source File: test_operators.py From vnpy_crypto with MIT License | 5 votes |
def test_comparison_object_numeric_nas(self): ser = Series(np.random.randn(10), dtype=object) shifted = ser.shift(2) ops = ['lt', 'le', 'gt', 'ge', 'eq', 'ne'] for op in ops: func = getattr(operator, op) result = func(ser, shifted) expected = func(ser.astype(float), shifted.astype(float)) assert_series_equal(result, expected)
Example #24
Source File: base.py From vnpy_crypto with MIT License | 5 votes |
def _add_comparison_methods(cls): """ add in comparison methods """ cls.__eq__ = _make_comparison_op(operator.eq, cls) cls.__ne__ = _make_comparison_op(operator.ne, cls) cls.__lt__ = _make_comparison_op(operator.lt, cls) cls.__gt__ = _make_comparison_op(operator.gt, cls) cls.__le__ = _make_comparison_op(operator.le, cls) cls.__ge__ = _make_comparison_op(operator.ge, cls)
Example #25
Source File: validate_data.py From tcex with Apache License 2.0 | 5 votes |
def get_operator(self, op): """Get the corresponding operator""" operators = { 'date_format': self.operator_date_format, 'df': self.operator_date_format, 'dd': self.operator_deep_diff, 'is_url': self.operator_is_url, 'is_date': self.operator_is_date, 'is_number': self.operator_is_number, 'length_eq': self.operator_length_eq, 'leq': self.operator_length_eq, 'eq': self.operator_eq, '=': self.operator_eq, 'le': self.operator_le, '<=': self.operator_le, 'lt': self.operator_lt, '<': self.operator_lt, 'ge': self.operator_ge, '>=': self.operator_ge, 'gt': self.operator_gt, '>': self.operator_gt, 'jeq': self.operator_json_eq, 'json_eq': self.operator_json_eq, 'kveq': self.operator_keyvalue_eq, 'keyvalue_eq': self.operator_keyvalue_eq, 'ne': self.operator_ne, '!=': self.operator_ne, 'rex': self.operator_regex_match, 'skip': self.operator_skip, } return operators.get(op, None)
Example #26
Source File: core_test.py From auto-alt-text-lambda-api with MIT License | 5 votes |
def setUp(self): super(CoreBinaryOpsTest, self).setUp() self.x_probs_broadcast_tensor = array_ops.reshape( self.x_probs_lt.tensor, [self.x_size, 1, self.probs_size]) self.channel_probs_broadcast_tensor = array_ops.reshape( self.channel_probs_lt.tensor, [1, self.channel_size, self.probs_size]) # == and != are not element-wise for tf.Tensor, so they shouldn't be # elementwise for LabeledTensor, either. self.ops = [ ('add', operator.add, math_ops.add, core.add), ('sub', operator.sub, math_ops.subtract, core.sub), ('mul', operator.mul, math_ops.multiply, core.mul), ('div', operator.truediv, math_ops.div, core.div), ('mod', operator.mod, math_ops.mod, core.mod), ('pow', operator.pow, math_ops.pow, core.pow_function), ('equal', None, math_ops.equal, core.equal), ('less', operator.lt, math_ops.less, core.less), ('less_equal', operator.le, math_ops.less_equal, core.less_equal), ('not_equal', None, math_ops.not_equal, core.not_equal), ('greater', operator.gt, math_ops.greater, core.greater), ('greater_equal', operator.ge, math_ops.greater_equal, core.greater_equal), ] self.test_lt_1 = self.x_probs_lt self.test_lt_2 = self.channel_probs_lt self.test_lt_1_broadcast = self.x_probs_broadcast_tensor self.test_lt_2_broadcast = self.channel_probs_broadcast_tensor self.broadcast_axes = [self.a0, self.a1, self.a3]
Example #27
Source File: test_richcmp.py From ironpython2 with Apache License 2.0 | 5 votes |
def test_mixed(self): # check that comparisons involving Vector objects # which return rich results (i.e. Vectors with itemwise # comparison results) work a = Vector(range(2)) b = Vector(range(3)) # all comparisons should fail for different length for opname in opmap: self.checkfail(ValueError, opname, a, b) a = range(5) b = 5 * [2] # try mixed arguments (but not (a, b) as that won't return a bool vector) args = [(a, Vector(b)), (Vector(a), b), (Vector(a), Vector(b))] for (a, b) in args: self.checkequal("lt", a, b, [True, True, False, False, False]) self.checkequal("le", a, b, [True, True, True, False, False]) self.checkequal("eq", a, b, [False, False, True, False, False]) self.checkequal("ne", a, b, [True, True, False, True, True ]) self.checkequal("gt", a, b, [False, False, False, True, True ]) self.checkequal("ge", a, b, [False, False, True, True, True ]) for ops in opmap.itervalues(): for op in ops: # calls __nonzero__, which should fail self.assertRaises(TypeError, bool, op(a, b))
Example #28
Source File: observer.py From raspberrypi-examples with MIT License | 5 votes |
def addSensor(self, sensor_id, threshold, operator=operator.ge, action=None): self.sensors[sensor_id] = { "threshold": threshold, "operator": operator, "action": action, }
Example #29
Source File: test_operator.py From ironpython2 with Apache License 2.0 | 5 votes |
def test_ge(self): self.assertRaises(TypeError, operator.ge) self.assertRaises(TypeError, operator.ge, 1j, 2j) self.assertTrue(operator.ge(1, 0)) self.assertTrue(operator.ge(1, 0.0)) self.assertTrue(operator.ge(1, 1)) self.assertTrue(operator.ge(1, 1.0)) self.assertFalse(operator.ge(1, 2)) self.assertFalse(operator.ge(1, 2.0))
Example #30
Source File: test_deprecations.py From auto-alt-text-lambda-api with MIT License | 5 votes |
def test_array_richcompare_legacy_weirdness(self): # It doesn't really work to use assert_deprecated here, b/c part of # the point of assert_deprecated is to check that when warnings are # set to "error" mode then the error is propagated -- which is good! # But here we are testing a bunch of code that is deprecated *because* # it has the habit of swallowing up errors and converting them into # different warnings. So assert_warns will have to be sufficient. assert_warns(FutureWarning, lambda: np.arange(2) == "a") assert_warns(FutureWarning, lambda: np.arange(2) != "a") # No warning for scalar comparisons with warnings.catch_warnings(): warnings.filterwarnings("error") assert_(not (np.array(0) == "a")) assert_(np.array(0) != "a") assert_(not (np.int16(0) == "a")) assert_(np.int16(0) != "a") for arg1 in [np.asarray(0), np.int16(0)]: struct = np.zeros(2, dtype="i4,i4") for arg2 in [struct, "a"]: for f in [operator.lt, operator.le, operator.gt, operator.ge]: if sys.version_info[0] >= 3: # py3 with warnings.catch_warnings() as l: warnings.filterwarnings("always") assert_raises(TypeError, f, arg1, arg2) assert_(not l) else: # py2 assert_warns(DeprecationWarning, f, arg1, arg2)