def test_it(self): class foo(object): def __init__(self, **kwargs): for attr, val in kwargs.items(): setattr(self, attr, val) obj = foo() d = self.kls(obj) with pytest.raises(KeyError): operator.__getitem__(d, 'x') with pytest.raises(KeyError): operator.__delitem__(d, 'x') assert 'x' not in d d['x'] = 1 assert d['x'] == 1 assert 'x' in d assert ['x'] == list(x for x in d if not x.startswith("__")) del d['x'] assert 'x' not in d with pytest.raises(KeyError): operator.__delitem__(d, 'x') with pytest.raises(KeyError): operator.__getitem__(d, 'x') # Finally, verify that immutable attribute errors are handled correctly. d = self.kls(object()) with pytest.raises(KeyError): operator.__setitem__(d, 'x', 1) with pytest.raises(KeyError): operator.__delitem__(d, 'x')
def fromStr(cls, string): '''Convert string representation of SynchDomain enum e.g. 'SynchDomain.Time' to SynchDomain objects. It also works with just domain strings like 'Time'. The following expressions are True: SynchDomain.fromStr(str(SynchDomain.Time)) == SynchDomain.Time SynchDomain.fromStr('Time') == SynchDomain.Time ''' domain = string.split('.') if len(domain) == 1: return __getitem__(cls, domain[0]) elif len(domain) == 2: return __getitem__(cls, domain[1]) else: raise ValueError('Can not convert %s to SynchDomain' % string)
def test_AttrAccessible(self, kls=None): if kls is None: kls = self.kls o = kls(f=2, g=3) assert ['f', 'g'] == sorted(o) self.assertBoth(o, 'g', 3) o.g = 4 self.assertBoth(o, 'g', 4) del o.g with pytest.raises(KeyError): operator.__getitem__(o, 'g') with pytest.raises(AttributeError): getattr(o, 'g') del o['f'] with pytest.raises(KeyError): operator.__getitem__(o, 'f') with pytest.raises(AttributeError): getattr(o, 'f')
def fnSourceID(arg1, arg2): print("\nWe are now creating the SourceID....", ) def pause(): programPause = input("Press <Enter> key to continue...") pause() #define a lambda expression to flatten a nested list flatten = lambda *n: (e for a in n for e in (flatten(*a) if isinstance(a, (tuple, list)) else (a, ))) #Assign CID and zList to local var var1, var2 = arg1, arg2 f = [] #Assign the prefix to be used for series for idx, x in enumerate(var2): CollectID = var1[4] #get reformatted date spread vals x[8] for single or double entry f = operator.__getitem__(x, 8) x += f x.pop(8) CID = var1 DoubleEntry = 10 SingleEntry = 9 SID = [] #Create the SourceID for single and double entry x elements for idx, x in enumerate(var2): size = len(x) if size == SingleEntry: #testing for single entry nested element size #then change to single entry format #add CID prefix = SID tempSID = "{}{}".format(CID[4], x[8]) #append SID to z list x.append(tempSID) elif size == DoubleEntry: #testing for double entry nested element size #change to double entry format #add CID prefix = SID tempSID = "{}{}_{}".format(CID[4], x[8], x[9]) #append SID to z list x.append(tempSID) print("END fnSourceID\n") z = var2 return z
def compute(self): import operator a = self.get_input("Array") dims = self.get_input("Dims") a_dims = len(a.get_shape()) if dims > a_dims: raise ModuleError("Output Dimensionality larger than Input Dimensionality") slices = [] for i in xrange(dims): (start, stop) = self.get_input("dim"+str(i)) slices.append(slice(start, stop)) ar = operator.__getitem__(a.get_array(), tuple(slices)) out = NDArray() out.set_array(ar) self.set_output("Array Output", out)
def test_sanity(self): """Performs a set of simple sanity checks on most operators.""" #__abs__ self.assertEqual(operator.__abs__(0), 0) self.assertEqual(operator.__abs__(1), 1) self.assertEqual(operator.__abs__(-1), 1) self.assertEqual(operator.__abs__(0.0), 0.0) self.assertEqual(operator.__abs__(1.1), 1.1) self.assertEqual(operator.__abs__(-1.1), 1.1) self.assertEqual(operator.__abs__(big(0)), big(0)) self.assertEqual(operator.__abs__(big(1)), big(1)) self.assertEqual(operator.__abs__(-big(1)), big(1)) #__neg__ self.assertEqual(operator.__neg__(0), 0) self.assertEqual(operator.__neg__(1), -1) self.assertEqual(operator.__neg__(-1), 1) self.assertEqual(operator.__neg__(0.0), 0.0) self.assertEqual(operator.__neg__(1.1), -1.1) self.assertEqual(operator.__neg__(-1.1), 1.1) self.assertEqual(operator.__neg__(big(0)), big(0)) self.assertEqual(operator.__neg__(big(1)), -big(1)) self.assertEqual(operator.__neg__(-big(1)), big(1)) #__pos__ self.assertEqual(operator.__pos__(0), 0) self.assertEqual(operator.__pos__(1), 1) self.assertEqual(operator.__pos__(-1), -1) self.assertEqual(operator.__pos__(0.0), 0.0) self.assertEqual(operator.__pos__(1.1), 1.1) self.assertEqual(operator.__pos__(-1.1), -1.1) self.assertEqual(operator.__pos__(big(0)), big(0)) self.assertEqual(operator.__pos__(big(1)), big(1)) self.assertEqual(operator.__pos__(-big(1)), -big(1)) #__add__ self.assertEqual(operator.__add__(0, 0), 0) self.assertEqual(operator.__add__(1, 2), 3) self.assertEqual(operator.__add__(-1, 2), 1) self.assertEqual(operator.__add__(0.0, 0.0), 0.0) self.assertEqual(operator.__add__(1.1, 2.1), 3.2) self.assertEqual(operator.__add__(-1.1, 2.1), 1.0) self.assertEqual(operator.__add__(big(0), big(0)), big(0)) self.assertEqual(operator.__add__(big(1), big(2)), big(3)) self.assertEqual(operator.__add__(-big(1), big(2)), big(1)) #__sub__ self.assertEqual(operator.__sub__(0, 0), 0) self.assertEqual(operator.__sub__(1, 2), -1) self.assertEqual(operator.__sub__(-1, 2), -3) self.assertEqual(operator.__sub__(0.0, 0.0), 0.0) self.assertEqual(operator.__sub__(1.1, 2.1), -1.0) self.assertEqual(operator.__sub__(-1.1, 2.1), -3.2) self.assertEqual(operator.__sub__(big(0), big(0)), big(0)) self.assertEqual(operator.__sub__(big(1), big(2)), -big(1)) self.assertEqual(operator.__sub__(-big(1), big(2)), -big(3)) #__mul__ self.assertEqual(operator.__mul__(0, 0), 0) self.assertEqual(operator.__mul__(1, 2), 2) self.assertEqual(operator.__mul__(-1, 2), -2) self.assertEqual(operator.__mul__(0.0, 0.0), 0.0) self.assertEqual(operator.__mul__(2.0, 3.0), 6.0) self.assertEqual(operator.__mul__(-2.0, 3.0), -6.0) self.assertEqual(operator.__mul__(big(0), big(0)), big(0)) self.assertEqual(operator.__mul__(big(1), big(2)), big(2)) self.assertEqual(operator.__mul__(-big(1), big(2)), -big(2)) #__div__ self.assertEqual(operator.__div__(0, 1), 0) self.assertEqual(operator.__div__(4, 2), 2) self.assertEqual(operator.__div__(-1, 2), -1) self.assertEqual(operator.__div__(0.0, 1.0), 0.0) self.assertEqual(operator.__div__(4.0, 2.0), 2.0) self.assertEqual(operator.__div__(-4.0, 2.0), -2.0) self.assertEqual(operator.__div__(big(0), big(1)), big(0)) self.assertEqual(operator.__div__(big(4), big(2)), big(2)) self.assertEqual(operator.__div__(-big(4), big(2)), -big(2)) #__floordiv__ self.assertEqual(operator.__floordiv__(0, 1), 0) self.assertEqual(operator.__floordiv__(4, 2), 2) self.assertEqual(operator.__floordiv__(-1, 2), -1) self.assertEqual(operator.__floordiv__(0.0, 1.0), 0.0) self.assertEqual(operator.__floordiv__(4.0, 2.0), 2.0) self.assertEqual(operator.__floordiv__(-4.0, 2.0), -2.0) self.assertEqual(operator.__floordiv__(big(0), big(1)), big(0)) self.assertEqual(operator.__floordiv__(big(4), big(2)), big(2)) self.assertEqual(operator.__floordiv__(-big(4), big(2)), -big(2)) #__truediv__ self.assertEqual(operator.__truediv__(0, 1), 0) self.assertEqual(operator.__truediv__(4, 2), 2) self.assertEqual(operator.__truediv__(-1, 2), -0.5) self.assertEqual(operator.__truediv__(0.0, 1.0), 0.0) self.assertEqual(operator.__truediv__(4.0, 2.0), 2.0) self.assertEqual(operator.__truediv__(-1.0, 2.0), -0.5) self.assertEqual(operator.__truediv__(big(0), big(1)), big(0)) self.assertEqual(operator.__truediv__(big(4), big(2)), big(2)) self.assertEqual(operator.__truediv__(-big(4), big(2)), -big(2)) #__mod__ self.assertEqual(operator.__mod__(0, 1), 0) self.assertEqual(operator.__mod__(4, 2), 0) self.assertEqual(operator.__mod__(-1, 2), 1) self.assertEqual(operator.__mod__(0.0, 1.0), 0.0) self.assertEqual(operator.__mod__(4.0, 2.0), 0.0) self.assertEqual(operator.__mod__(-1.0, 2.0), 1.0) self.assertEqual(operator.__mod__(big(0), big(1)), big(0)) self.assertEqual(operator.__mod__(big(4), big(2)), big(0)) self.assertEqual(operator.__mod__(-big(4), big(2)), big(0)) #__inv__ self.assertEqual(operator.__inv__(0), -1) self.assertEqual(operator.__inv__(1), -2) self.assertEqual(operator.__inv__(-1), 0) self.assertEqual(operator.__inv__(big(0)), -big(1)) self.assertEqual(operator.__inv__(big(1)), -big(2)) self.assertEqual(operator.__inv__(-big(1)), big(0)) #__invert__ self.assertEqual(operator.__invert__(0), -1) self.assertEqual(operator.__invert__(1), -2) self.assertEqual(operator.__invert__(-1), 0) self.assertEqual(operator.__invert__(big(0)), -big(1)) self.assertEqual(operator.__invert__(big(1)), -big(2)) self.assertEqual(operator.__invert__(-big(1)), big(0)) #__lshift__ self.assertEqual(operator.__lshift__(0, 1), 0) self.assertEqual(operator.__lshift__(1, 1), 2) self.assertEqual(operator.__lshift__(-1, 1), -2) self.assertEqual(operator.__lshift__(big(0), 1), big(0)) self.assertEqual(operator.__lshift__(big(1), 1), big(2)) self.assertEqual(operator.__lshift__(-big(1), 1), -big(2)) #__rshift__ self.assertEqual(operator.__rshift__(1, 1), 0) self.assertEqual(operator.__rshift__(2, 1), 1) self.assertEqual(operator.__rshift__(-1, 1), -1) self.assertEqual(operator.__rshift__(big(1), 1), big(0)) self.assertEqual(operator.__rshift__(big(2), 1), big(1)) self.assertEqual(operator.__rshift__(-big(1), 1), -big(1)) #__not__ self.assertEqual(operator.__not__(0), 1) self.assertEqual(operator.__not__(1), 0) self.assertEqual(operator.__not__(-1), 0) self.assertEqual(operator.__not__(big(0)), 1) self.assertEqual(operator.__not__(big(1)), 0) self.assertEqual(operator.__not__(-big(1)), 0) #__and__ self.assertEqual(operator.__and__(0, 0), 0) self.assertEqual(operator.__and__(1, 1), 1) self.assertEqual(operator.__and__(0, 1), 0) self.assertEqual(operator.__and__(1, 0), 0) #__xor__ self.assertEqual(operator.__xor__(0, 0), 0) self.assertEqual(operator.__xor__(1, 1), 0) self.assertEqual(operator.__xor__(0, 1), 1) self.assertEqual(operator.__xor__(1, 0), 1) #__or__ self.assertEqual(operator.__or__(0, 0), 0) self.assertEqual(operator.__or__(1, 1), 1) self.assertEqual(operator.__or__(0, 1), 1) self.assertEqual(operator.__or__(1, 0), 1) #__concat__ self.assertEqual(operator.__concat__([0], [1]), [0, 1]) self.assertEqual(operator.__concat__([2], [1]), [2, 1]) self.assertEqual(operator.__concat__([-1], [1]), [-1, 1]) #__contains__ self.assertTrue(operator.__contains__("abc", "c")) self.assertTrue(not operator.__contains__("abc", "d")) self.assertTrue(operator.__contains__("abc", "")) self.assertTrue(not operator.__contains__("", "c")) self.assertTrue(operator.__contains__([1, 2, 3], 1)) self.assertTrue(not operator.__contains__([1, 2, 3], 4)) #__getitem__ self.assertEqual(operator.__getitem__("abc", 2), "c") self.assertRaises(IndexError, operator.__getitem__, "abc", 3) self.assertEqual(operator.__getitem__([1, 2, 3], 2), 3) self.assertRaises(IndexError, operator.__getitem__, [1, 2, 3], 3) #__setitem__ self.assertRaises(TypeError, operator.__setitem__, "abc", 2, "d") t_list = [1, 2, 3] operator.__setitem__(t_list, 2, 4) self.assertEqual(t_list, [1, 2, 4]) self.assertRaises(IndexError, operator.__setitem__, [1, 2, 3], 4, 9) #__delitem__ #UNIMPLEMENTED #self.assertRaises(TypeError, operator.__delitem__, "abc", 2) t_list = [1, 2, 3] operator.__delitem__(t_list, 2) self.assertEqual(t_list, [1, 2]) self.assertRaises(IndexError, operator.__delitem__, [1, 2, 3], 4) #__repeat__ self.assertEqual(operator.__repeat__("abc", 2), "abcabc") self.assertEqual(operator.__repeat__("", 2), "") self.assertEqual(operator.__repeat__([1, 2, 3], 2), [1, 2, 3, 1, 2, 3]) #__getslice__ self.assertEqual(operator.__getslice__("abc", 1, 2), "b") self.assertEqual(operator.__getslice__("abc", 0, 3), "abc") self.assertEqual(operator.__getslice__("", 0, 0), "") self.assertEqual(operator.__getslice__([1, 2, 3], 1, 2), [2]) self.assertEqual(operator.__getslice__([1, 2, 3], 0, 3), [1, 2, 3]) self.assertEqual(operator.__getslice__([], 0, 0), []) #__delslice__ t_list = [1, 2, 3] operator.__delslice__(t_list, 1, 2) self.assertEqual(t_list, [1, 3]) t_list = [1, 2, 3] operator.__delslice__(t_list, 0, 3) self.assertEqual(t_list, []) t_list = [1, 2, 3] operator.__delslice__(t_list, 0, 0) self.assertEqual(t_list, [1, 2, 3]) #__setslice__ t_list = [1, 2, 3] operator.__setslice__(t_list, 1, 2, [9]) self.assertEqual(t_list, [1, 9, 3]) t_list = [1, 2, 3] operator.__setslice__(t_list, 0, 3, [9, 8]) self.assertEqual(t_list, [9, 8]) t_list = [1, 2, 3] operator.__setslice__(t_list, 0, 0, [9]) self.assertEqual(t_list, [9, 1, 2, 3])
def test_sanity(): ''' Performs a set of simple sanity checks on most operators. ''' #__abs__ AreEqual(operator.__abs__(0), 0) AreEqual(operator.__abs__(1), 1) AreEqual(operator.__abs__(-1), 1) AreEqual(operator.__abs__(0.0), 0.0) AreEqual(operator.__abs__(1.1), 1.1) AreEqual(operator.__abs__(-1.1), 1.1) AreEqual(operator.__abs__(0L), 0L) AreEqual(operator.__abs__(1L), 1L) AreEqual(operator.__abs__(-1L), 1L) #__neg__ AreEqual(operator.__neg__(0), 0) AreEqual(operator.__neg__(1), -1) AreEqual(operator.__neg__(-1), 1) AreEqual(operator.__neg__(0.0), 0.0) AreEqual(operator.__neg__(1.1), -1.1) AreEqual(operator.__neg__(-1.1), 1.1) AreEqual(operator.__neg__(0L), 0L) AreEqual(operator.__neg__(1L), -1L) AreEqual(operator.__neg__(-1L), 1L) #__pos__ AreEqual(operator.__pos__(0), 0) AreEqual(operator.__pos__(1), 1) AreEqual(operator.__pos__(-1), -1) AreEqual(operator.__pos__(0.0), 0.0) AreEqual(operator.__pos__(1.1), 1.1) AreEqual(operator.__pos__(-1.1), -1.1) AreEqual(operator.__pos__(0L), 0L) AreEqual(operator.__pos__(1L), 1L) AreEqual(operator.__pos__(-1L), -1L) #__add__ AreEqual(operator.__add__(0, 0), 0) AreEqual(operator.__add__(1, 2), 3) AreEqual(operator.__add__(-1, 2), 1) AreEqual(operator.__add__(0.0, 0.0), 0.0) AreEqual(operator.__add__(1.1, 2.1), 3.2) AreEqual(operator.__add__(-1.1, 2.1), 1.0) AreEqual(operator.__add__(0L, 0L), 0L) AreEqual(operator.__add__(1L, 2L), 3L) AreEqual(operator.__add__(-1L, 2L), 1L) #__sub__ AreEqual(operator.__sub__(0, 0), 0) AreEqual(operator.__sub__(1, 2), -1) AreEqual(operator.__sub__(-1, 2), -3) AreEqual(operator.__sub__(0.0, 0.0), 0.0) AreEqual(operator.__sub__(1.1, 2.1), -1.0) AreEqual(operator.__sub__(-1.1, 2.1), -3.2) AreEqual(operator.__sub__(0L, 0L), 0L) AreEqual(operator.__sub__(1L, 2L), -1L) AreEqual(operator.__sub__(-1L, 2L), -3L) #__mul__ AreEqual(operator.__mul__(0, 0), 0) AreEqual(operator.__mul__(1, 2), 2) AreEqual(operator.__mul__(-1, 2), -2) AreEqual(operator.__mul__(0.0, 0.0), 0.0) AreEqual(operator.__mul__(2.0, 3.0), 6.0) AreEqual(operator.__mul__(-2.0, 3.0), -6.0) AreEqual(operator.__mul__(0L, 0L), 0L) AreEqual(operator.__mul__(1L, 2L), 2L) AreEqual(operator.__mul__(-1L, 2L), -2L) #__div__ AreEqual(operator.__div__(0, 1), 0) AreEqual(operator.__div__(4, 2), 2) AreEqual(operator.__div__(-1, 2), -1) AreEqual(operator.__div__(0.0, 1.0), 0.0) AreEqual(operator.__div__(4.0, 2.0), 2.0) AreEqual(operator.__div__(-4.0, 2.0), -2.0) AreEqual(operator.__div__(0L, 1L), 0L) AreEqual(operator.__div__(4L, 2L), 2L) AreEqual(operator.__div__(-4L, 2L), -2L) #__floordiv__ AreEqual(operator.__floordiv__(0, 1), 0) AreEqual(operator.__floordiv__(4, 2), 2) AreEqual(operator.__floordiv__(-1, 2), -1) AreEqual(operator.__floordiv__(0.0, 1.0), 0.0) AreEqual(operator.__floordiv__(4.0, 2.0), 2.0) AreEqual(operator.__floordiv__(-4.0, 2.0), -2.0) AreEqual(operator.__floordiv__(0L, 1L), 0L) AreEqual(operator.__floordiv__(4L, 2L), 2L) AreEqual(operator.__floordiv__(-4L, 2L), -2L) #__truediv__ AreEqual(operator.__truediv__(0, 1), 0) AreEqual(operator.__truediv__(4, 2), 2) AreEqual(operator.__truediv__(-1, 2), -0.5) AreEqual(operator.__truediv__(0.0, 1.0), 0.0) AreEqual(operator.__truediv__(4.0, 2.0), 2.0) AreEqual(operator.__truediv__(-1.0, 2.0), -0.5) AreEqual(operator.__truediv__(0L, 1L), 0L) AreEqual(operator.__truediv__(4L, 2L), 2L) AreEqual(operator.__truediv__(-4L, 2L), -2L) #__mod__ AreEqual(operator.__mod__(0, 1), 0) AreEqual(operator.__mod__(4, 2), 0) AreEqual(operator.__mod__(-1, 2), 1) AreEqual(operator.__mod__(0.0, 1.0), 0.0) AreEqual(operator.__mod__(4.0, 2.0), 0.0) AreEqual(operator.__mod__(-1.0, 2.0), 1.0) AreEqual(operator.__mod__(0L, 1L), 0L) AreEqual(operator.__mod__(4L, 2L), 0L) AreEqual(operator.__mod__(-4L, 2L), 0L) #__inv__ AreEqual(operator.__inv__(0), -1) AreEqual(operator.__inv__(1), -2) AreEqual(operator.__inv__(-1), 0) AreEqual(operator.__inv__(0L), -1L) AreEqual(operator.__inv__(1L), -2L) AreEqual(operator.__inv__(-1L), 0L) #__invert__ AreEqual(operator.__invert__(0), -1) AreEqual(operator.__invert__(1), -2) AreEqual(operator.__invert__(-1), 0) AreEqual(operator.__invert__(0L), -1L) AreEqual(operator.__invert__(1L), -2L) AreEqual(operator.__invert__(-1L), 0L) #__lshift__ AreEqual(operator.__lshift__(0, 1), 0) AreEqual(operator.__lshift__(1, 1), 2) AreEqual(operator.__lshift__(-1, 1), -2) AreEqual(operator.__lshift__(0L, 1), 0L) AreEqual(operator.__lshift__(1L, 1), 2L) AreEqual(operator.__lshift__(-1L, 1), -2L) #__rshift__ AreEqual(operator.__rshift__(1, 1), 0) AreEqual(operator.__rshift__(2, 1), 1) AreEqual(operator.__rshift__(-1, 1), -1) AreEqual(operator.__rshift__(1L, 1), 0L) AreEqual(operator.__rshift__(2L, 1), 1L) AreEqual(operator.__rshift__(-1L, 1), -1L) #__not__ AreEqual(operator.__not__(0), 1) AreEqual(operator.__not__(1), 0) AreEqual(operator.__not__(-1), 0) AreEqual(operator.__not__(0L), 1) AreEqual(operator.__not__(1L), 0) AreEqual(operator.__not__(-1L), 0) #__and__ AreEqual(operator.__and__(0, 0), 0) AreEqual(operator.__and__(1, 1), 1) AreEqual(operator.__and__(0, 1), 0) AreEqual(operator.__and__(1, 0), 0) #__xor__ AreEqual(operator.__xor__(0, 0), 0) AreEqual(operator.__xor__(1, 1), 0) AreEqual(operator.__xor__(0, 1), 1) AreEqual(operator.__xor__(1, 0), 1) #__or__ AreEqual(operator.__or__(0, 0), 0) AreEqual(operator.__or__(1, 1), 1) AreEqual(operator.__or__(0, 1), 1) AreEqual(operator.__or__(1, 0), 1) #__concat__ AreEqual(operator.__concat__([0], [1]), [0,1]) AreEqual(operator.__concat__([2], [1]), [2,1]) AreEqual(operator.__concat__([-1], [1]), [-1,1]) #__contains__ Assert(operator.__contains__("abc", "c")) Assert(not operator.__contains__("abc", "d")) Assert(operator.__contains__("abc", "")) Assert(not operator.__contains__("", "c")) Assert(operator.__contains__([1,2,3], 1)) Assert(not operator.__contains__([1,2,3], 4)) #__getitem__ AreEqual(operator.__getitem__("abc", 2), "c") AssertError(IndexError, operator.__getitem__, "abc", 3) AreEqual(operator.__getitem__([1,2,3], 2), 3) AssertError(IndexError, operator.__getitem__, [1,2,3], 3) #__setitem__ AssertError(TypeError, operator.__setitem__, "abc", 2, "d") t_list = [1,2,3] operator.__setitem__(t_list, 2, 4) AreEqual(t_list, [1,2,4]) AssertError(IndexError, operator.__setitem__, [1,2,3], 4, 9) #__delitem__ #UNIMPLEMENTED #AssertError(TypeError, operator.__delitem__, "abc", 2) t_list = [1,2,3] operator.__delitem__(t_list, 2) AreEqual(t_list, [1,2]) AssertError(IndexError, operator.__delitem__, [1,2,3], 4) #__repeat__ AreEqual(operator.__repeat__("abc", 2), "abcabc") AreEqual(operator.__repeat__("", 2), "") AreEqual(operator.__repeat__([1,2,3], 2), [1,2,3,1,2,3]) #__getslice__ AreEqual(operator.__getslice__("abc", 1, 2), "b") AreEqual(operator.__getslice__("abc", 0, 3), "abc") AreEqual(operator.__getslice__("", 0, 0), "") AreEqual(operator.__getslice__([1,2,3], 1, 2), [2]) AreEqual(operator.__getslice__([1,2,3], 0, 3), [1,2,3]) AreEqual(operator.__getslice__([], 0, 0), []) #__delslice__ t_list = [1,2,3] operator.__delslice__(t_list, 1, 2) AreEqual(t_list, [1,3]) t_list = [1,2,3] operator.__delslice__(t_list, 0, 3) AreEqual(t_list, []) t_list = [1,2,3] operator.__delslice__(t_list, 0, 0) AreEqual(t_list, [1,2,3]) #__setslice__ t_list = [1,2,3] operator.__setslice__(t_list, 1, 2, [9]) AreEqual(t_list, [1,9,3]) t_list = [1,2,3] operator.__setslice__(t_list, 0, 3, [9, 8]) AreEqual(t_list, [9, 8]) t_list = [1,2,3] operator.__setslice__(t_list, 0, 0, [9]) AreEqual(t_list, [9,1, 2,3])
def fnDateSpread(a): z = a ################################### REFACTOR DIFF FOR NINE(9)DATE SPREAD CONDITIONS##################### #12/06/17 maintain neg diff value as id marker for beg/end of month - refactor fn create label #create the date spread value for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] diff = [] val = [] val.extend(int(e[3]) for e in z) diff = [val[i + 1] - val[i] for i in range(len(val) - 1)] #do I need to add back position zero here???? #Yes, otherwise list is wrong length, and label processing needed diff.insert(0, val[0]) ################################### REFACTOR DIFF FOR TEN(10)DATE SPREAD(see SpreadTest)CONDITIONS##################### #create YYYY list z2 = (["19" + e[1] for e in z[0:]]) #Append nested list element[4] with 4 digit year from z2 for label formating for e in z: ei = z.index(e) f = operator.__getitem__(z2, ei) e.append(f) #print ("\nPrinting appended z with YYYY: ".join(map(str,z))) #Append nested list element[5] with month name for label formating MonthName = { "jan": "January", "feb": "February", "mar": "March", "apr": "April", "may": "May", "jun": "June", "jul": "July", "aug": "August", "sep": "September", "oct": "October", "nov": "November", "dec": "December" } for e in z: f = MonthName.get(e[2]) e.append(f) #print ("\nPrinting appended z with YYYY,MO: ".join(map(str,z))) #Append nested list element [6] with date spread value for label formatting for e in z: ei = z.index(e) f = operator.__getitem__(diff, ei) e.append(f) #print(e) #12/06/17 11/15/17 DATE SPREAD TESTING #REFACTOR and move after diff value calc append to nested list element [6] #Looking for ten(10) different end of month values per SpreadTest results, and zip file inconsistencies #nested list element [6] diff val to find beg/end of mo. CountElem = 0 for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] #print (ThisElem,NextElem) if (ThisElem[6] == -25): #included for zip file inconsistencies #diff.append(ThisElem) #print("\nDIFF -25 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == -26): #diff.append(ThisElem) #print("\nDIFF -25 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == -27): #diff.append(ThisElem) #print("\nDIFF -27 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == -28): #diff.append(ThisElem) #print("\nDIFF -28 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == -29): #diff.append(ThisElem) #print("\nDIFF -29 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == -30): #diff.append(ThisElem) #print("\nDIFF -30 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == 1): #diff.append(ThisElem) #print("\nDIFF 1 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == 2): #diff.append(ThisElem) #print("\nDIFF 2 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == 3): #diff.append(ThisElem) #print("\nDIFF 3 ",ThisElem) CountElem = CountElem + 1 if (ThisElem[6] == 4): #diff.append(ThisElem) #print("\nDIFF 4 ",ThisElem) CountElem = CountElem + 1 #print("\nTotal neg element count ", CountElem) return z
def fnCreateLabel(a): z = a #DoubleEntry #fixes fnDateSpread error for most DAYS 2 calc DIFF 1 in error. Chg to double entry and DIFF 2 #Caution: date spread values vary. See SpreadTest codeblock regex for counting/grouping of unique value for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] PrevElem = z[(idx - 1) % len(z)] if ThisElem[3] == "02" and ThisElem[ 6] == 1: #test for str(day) value and int(diff) value #01/10/18 update from"2" #print ("\nTesting day 2 and diff 1") #print ("PREVELEM:",PrevElem,"\nTHISELEM:",ThisElem,"\nNEXTELEM:",NextElem) ThisElem[6] = 2 #12/06/17 print ("THISELEM:",ThisElem,"ENDELEM:",EndElem,"NEXTELEM:",NextElem) #print("DoubleEntry day 2 diff 1 ",DoubleEntry,"\n") ############################## Test and treat end of month 10 edge cases ################ #REFACTOR #z is a nested list #create elements to work on for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] PrevElem = z[(idx - 1) % len(z)] #Test for and treat 31 and 30 day months if ThisElem[6] in (-25, -26, -27, -28, -29, -30): #SingleEntry #Test and treat 31 day months for single entry #replace diff value to 1 if ThisElem[6] == -30 and PrevElem[2] in ('jan', 'mar', 'may', 'jul', 'aug', 'oct', 'dec'): #print ("This is a single entry item: ", ThisElem[2]," ",ThisElem[6]) SingleEntry = ("{} {},{}".format(PrevElem[5], PrevElem[3], PrevElem[4])) PrevElem[6] = 1 elem = PrevElem elem.append(SingleEntry) #SingleEntry #Test and treat 30 day months for single entry, replace diff val to 1 if ThisElem[6] == -29 and PrevElem[2] in ('apr', 'jun', 'sep', 'nov'): #print ("This is a single entry 30 day month item : ", ThisElem[2]," ",ThisElem[6]) SingleEntry = ("{} {},{}".format(PrevElem[5], PrevElem[3], PrevElem[4])) PrevElem[6] = 1 elem = PrevElem elem.append(SingleEntry) #DoubleEntry #Test and treat 31 day months double entry by finding 1st of mo and backtrack if ThisElem[6] == -29 and PrevElem[2] in ('jan', 'mar', 'may', 'jul', 'aug', 'oct', 'dec'): #print ("This is a double entry 31 day month item: ", ThisElem[2]," ",ThisElem[6]) #print("Print e[6] ReplaceElem6 ",PrevElem[6]) DayElem = int(PrevElem[3]) + 1 EndElem = ("{} {},{}".format(PrevElem[5], DayElem, PrevElem[4])) ThisElem = ("{} {},{}-".format(PrevElem[5], PrevElem[3], PrevElem[4])) NextElem = ("{} {},{}".format(elem[5], elem[3], elem[4])) DoubleEntry = ThisElem + EndElem elem = PrevElem elem.append(DoubleEntry) #''' #DoubleEntry #this will get most DIFF 2s accross month types for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] PrevElem = z[(idx - 1) % len(z)] if ThisElem[6] == 2 and NextElem[6] == 2: DayElem = int(ThisElem[3]) + 1 EndElem = ("{} {},{}".format(ThisElem[5], DayElem, ThisElem[4])) ThisElem = ("{} {},{}-".format(ThisElem[5], ThisElem[3], ThisElem[4])) NextElem = ("{} {},{}".format(NextElem[5], NextElem[3], NextElem[4])) #for testing DoubleEntry = ThisElem + EndElem elem.append(DoubleEntry) #print ("THISELEM:",ThisElem,"ENDELEM:",EndElem,"NEXTELEM:",NextElem) #print ("\nDoubleEntry all DIFF 2 vals ",DoubleEntry,"\n") #''' #''' #DoubleEntry 30 day months outlier elif ThisElem[3] in ('28', '29') and ThisElem[2] in ( 'apr', 'jun', 'sep', 'nov') and ThisElem[6] == 2: DayElem = int(ThisElem[3]) + 1 EndElem = ("{} {},{}".format(ThisElem[5], DayElem, ThisElem[4])) ThisElem = ("{} {},{}-".format(ThisElem[5], ThisElem[3], ThisElem[4])) NextElem = ("{} {},{}".format(NextElem[5], NextElem[3], NextElem[4])) #for testing DoubleEntry = ThisElem + EndElem elem.append(DoubleEntry) #elem.append("TESTING ELIF") #print ("THISELEM:",ThisElem,"ENDELEM:",EndElem,"NEXTELEM:",NextElem) #print ("\nDoubleEntry 28,29 and 30 day mo DIFF 2 vals ",DoubleEntry,"\n") #''' #''' #DoubleEntry 31 day months outlier elif ThisElem[3] in ( '29') and ThisElem[2] in ('jan', 'mar', 'may', 'jul', 'aug', 'oct', 'dec') and ThisElem[6] == 2: DayElem = int(ThisElem[3]) + 1 EndElem = ("{} {},{}".format(ThisElem[5], DayElem, ThisElem[4])) ThisElem = ("{} {},{}-".format(ThisElem[5], ThisElem[3], ThisElem[4])) NextElem = ("{} {},{}".format(NextElem[5], NextElem[3], NextElem[4])) #for testing DoubleEntry = ThisElem + EndElem elem.append(DoubleEntry) #elem.append("TESTING ELIF") #print ("THISELEM:",ThisElem,"ENDELEM:",EndElem,"NEXTELEM:",NextElem) #print ("\nDoubleEntry 29 and 31 day mo DIFF 2 vals ",DoubleEntry,"\n") #''' #February incl leap year #''' for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] PrevElem = z[(idx - 1) % len(z)] #DoubleEntry February leap year if ThisElem[3] == ('28') and ThisElem[2] == "feb" and ThisElem[1] in ( '20', '24', '28', '32', '36', '40', '44', '48', '52', '56', '60'): DayElem = int(ThisElem[3]) + 1 EndElem = ("{} {},{}".format(ThisElem[5], DayElem, ThisElem[4])) ThisElem = ("{} {},{}-".format(ThisElem[5], ThisElem[3], ThisElem[4])) NextElem = ("{} {},{}".format(NextElem[5], NextElem[3], NextElem[4])) #for testing DoubleEntry = ThisElem + EndElem elem.append(DoubleEntry) #''' #''' #SingleEntry February elif ThisElem[3] == ('28') and ThisElem[2] == "feb": SingleEntry = ("{} {},{}".format(ThisElem[5], ThisElem[3], ThisElem[4])) ThisElem[6] = 1 #elem=PrevElem elem.append(SingleEntry) #''' #1st of month #''' for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] PrevElem = z[(idx - 1) % len(z)] #DoubleEntry 1st of month if ThisElem[3] == ('1') and NextElem[3] == ('3') and ThisElem[6] in ( -25, -26, -27, -28, -29, -30): DayElem = int(ThisElem[3]) + 1 EndElem = ("{} {},{}".format(ThisElem[5], DayElem, ThisElem[4])) ThisElem = ("{} {},{}-".format(ThisElem[5], ThisElem[3], ThisElem[4])) NextElem = ("{} {},{}".format(NextElem[5], NextElem[3], NextElem[4])) #for testing DoubleEntry = ThisElem + EndElem elem.append(DoubleEntry) #''' #''' #SingleEntry 1st of month elif ThisElem[3] == ('1') and NextElem[3] == ('2') and ThisElem[6] in ( -25, -26, -27, -28, -29, -30): SingleEntry = ("{} {},{}".format(ThisElem[5], ThisElem[3], ThisElem[4])) elem.append(SingleEntry) #''' #Treat first/last record(idx), non-sequential DIFFS and correct diff vals #''' for idx, elem in enumerate(z): ThisElem = elem NextElem = z[(idx + 1) % len(z)] PrevElem = z[(idx - 1) % len(z)] FirstRec = 0 LastRec = len(z) - 1 #Update DIFF value first and last record of collection SingleEntry, look for 7 item elements if len(ThisElem) == 7 and idx in (FirstRec, LastRec): #print ("FIRST LAST ", ThisElem) #print ("FirstRec ",FirstRec) #print ("LastRec ",LastRec) SingleEntry = ("{} {},{}".format(ThisElem[5], ThisElem[3], ThisElem[4])) ThisElem[6] = 1 elem.append(SingleEntry) #print ("FIRST LAST ",ThisElem) #CreateLabel and UpdateDiffs of non-sequential outliers, look for 7 item elements if len(ThisElem) == 7: Diff = int(NextElem[3]) - int(ThisElem[3]) if Diff == 1: SingleEntry = ("{} {},{}".format(ThisElem[5], ThisElem[3], ThisElem[4])) ThisElem[6] = 1 elem.append(SingleEntry) else: DayElem = int(ThisElem[3]) + int(Diff) - 1 EndElem = ("{} {},{}".format(ThisElem[5], DayElem, ThisElem[4])) ThisElem = ("{} {},{}-".format(ThisElem[5], ThisElem[3], ThisElem[4])) NextElem = ("{} {},{}".format(NextElem[5], NextElem[3], NextElem[4])) #for testing DoubleEntry = ThisElem + EndElem elem[6] = Diff elem.append(DoubleEntry) #print ("UPDATE DIFF ",Diff, ThisElem, "EndElem ",EndElem, "INDEX ",idx) ########################### REFORMAT LABEL ######################### #create month ordered dictionary dictMonth = collections.OrderedDict() dictMonth = { "January": "01", "February": "02", "March": "03", "April": "04", "May": "05", "June": "06", "July": "07", "August": "08", "September": "09", "October": 10, "November": 11, "December": 12 } TempList = [] TempList.extend([e[7]] for e in z) start = re.compile('(\w*\s)' '(\d{1,2})' ',(\d{1,4})') print("Start regex: ", start) RegexFindall = [start.findall(str(e)) for e in TempList] #change tuples to list TempList = [] TempList2 = [] for idx, ei in enumerate(RegexFindall): ThisElem = ei NextElem = RegexFindall[(idx + 1) % len(RegexFindall)] for i in ThisElem: TempList = [list(map(list, e)) for e in RegexFindall] #convert nested list month names to int for idx, ei in enumerate(TempList): ThisElem = ei NextElem = TempList[(idx + 1) % len(TempList)] for i in ThisElem: for ii in NextElem: for k, v in dictMonth.items(): if k in i[0]: month = v i[0] = month #be careful with indentation, will break code TempList2.append(ThisElem) #print("\nThis",ThisElem,"\nNext",NextElem) #testing #print ("\nTempList2".join(map(str,TempList2))) ################# TESTING REFORMAT LABEL FOR SID ############################## #Append a list with the newley formtted dates TempList3 = [] for idx, ei in enumerate(TempList2): ThisElem = ei TempList3.append( ["{}-{}-{}".format(i[2], i[0], i[1]) for i in ThisElem]) #print ("\nTempList3Reformat".join(map(str,TempList3))) #use python datetime module to convert single to double digit days from datetime import datetime TempFix = TempList3 for x in TempFix: for idx, i in enumerate(x): ei = x.index(i) f = operator.__getitem__(x, ei) g = datetime.strptime(i, '%Y-%m-%d').strftime( '%Y-%m-%d') #reformating to dd days x[idx] = i.replace(i, g) #update each element item with two digit day print("\nFixing single digit to double digit date values" ) #for processing clarity/feedback #appending z nested lists with new values for final return for idx, ei in enumerate(z): ei.append(TempList3[idx]) #print ("\nZAppend ".join(map(str,z))) #01/12/18 z list is updating due to SHALLOW COPY and binding reference ################# TESTING REFORMAT LABEL FOR SID ############################## return z
def test_sanity(self): """Performs a set of simple sanity checks on most operators.""" #__abs__ self.assertEqual(operator.__abs__(0), 0) self.assertEqual(operator.__abs__(1), 1) self.assertEqual(operator.__abs__(-1), 1) self.assertEqual(operator.__abs__(0.0), 0.0) self.assertEqual(operator.__abs__(1.1), 1.1) self.assertEqual(operator.__abs__(-1.1), 1.1) self.assertEqual(operator.__abs__(long(0)), long(0)) self.assertEqual(operator.__abs__(long(1)), long(1)) self.assertEqual(operator.__abs__(-long(1)), long(1)) #__neg__ self.assertEqual(operator.__neg__(0), 0) self.assertEqual(operator.__neg__(1), -1) self.assertEqual(operator.__neg__(-1), 1) self.assertEqual(operator.__neg__(0.0), 0.0) self.assertEqual(operator.__neg__(1.1), -1.1) self.assertEqual(operator.__neg__(-1.1), 1.1) self.assertEqual(operator.__neg__(long(0)), long(0)) self.assertEqual(operator.__neg__(long(1)), -long(1)) self.assertEqual(operator.__neg__(-long(1)), long(1)) #__pos__ self.assertEqual(operator.__pos__(0), 0) self.assertEqual(operator.__pos__(1), 1) self.assertEqual(operator.__pos__(-1), -1) self.assertEqual(operator.__pos__(0.0), 0.0) self.assertEqual(operator.__pos__(1.1), 1.1) self.assertEqual(operator.__pos__(-1.1), -1.1) self.assertEqual(operator.__pos__(long(0)), long(0)) self.assertEqual(operator.__pos__(long(1)), long(1)) self.assertEqual(operator.__pos__(-long(1)), -long(1)) #__add__ self.assertEqual(operator.__add__(0, 0), 0) self.assertEqual(operator.__add__(1, 2), 3) self.assertEqual(operator.__add__(-1, 2), 1) self.assertEqual(operator.__add__(0.0, 0.0), 0.0) self.assertEqual(operator.__add__(1.1, 2.1), 3.2) self.assertEqual(operator.__add__(-1.1, 2.1), 1.0) self.assertEqual(operator.__add__(long(0), long(0)), long(0)) self.assertEqual(operator.__add__(long(1), long(2)), long(3)) self.assertEqual(operator.__add__(-long(1), long(2)), long(1)) #__sub__ self.assertEqual(operator.__sub__(0, 0), 0) self.assertEqual(operator.__sub__(1, 2), -1) self.assertEqual(operator.__sub__(-1, 2), -3) self.assertEqual(operator.__sub__(0.0, 0.0), 0.0) self.assertEqual(operator.__sub__(1.1, 2.1), -1.0) self.assertEqual(operator.__sub__(-1.1, 2.1), -3.2) self.assertEqual(operator.__sub__(long(0), long(0)), long(0)) self.assertEqual(operator.__sub__(long(1), long(2)), -long(1)) self.assertEqual(operator.__sub__(-long(1), long(2)), -long(3)) #__mul__ self.assertEqual(operator.__mul__(0, 0), 0) self.assertEqual(operator.__mul__(1, 2), 2) self.assertEqual(operator.__mul__(-1, 2), -2) self.assertEqual(operator.__mul__(0.0, 0.0), 0.0) self.assertEqual(operator.__mul__(2.0, 3.0), 6.0) self.assertEqual(operator.__mul__(-2.0, 3.0), -6.0) self.assertEqual(operator.__mul__(long(0), long(0)), long(0)) self.assertEqual(operator.__mul__(long(1), long(2)), long(2)) self.assertEqual(operator.__mul__(-long(1), long(2)), -long(2)) #__div__ self.assertEqual(operator.__div__(0, 1), 0) self.assertEqual(operator.__div__(4, 2), 2) self.assertEqual(operator.__div__(-1, 2), -1) self.assertEqual(operator.__div__(0.0, 1.0), 0.0) self.assertEqual(operator.__div__(4.0, 2.0), 2.0) self.assertEqual(operator.__div__(-4.0, 2.0), -2.0) self.assertEqual(operator.__div__(long(0), long(1)), long(0)) self.assertEqual(operator.__div__(long(4), long(2)), long(2)) self.assertEqual(operator.__div__(-long(4), long(2)), -long(2)) #__floordiv__ self.assertEqual(operator.__floordiv__(0, 1), 0) self.assertEqual(operator.__floordiv__(4, 2), 2) self.assertEqual(operator.__floordiv__(-1, 2), -1) self.assertEqual(operator.__floordiv__(0.0, 1.0), 0.0) self.assertEqual(operator.__floordiv__(4.0, 2.0), 2.0) self.assertEqual(operator.__floordiv__(-4.0, 2.0), -2.0) self.assertEqual(operator.__floordiv__(long(0), long(1)), long(0)) self.assertEqual(operator.__floordiv__(long(4), long(2)), long(2)) self.assertEqual(operator.__floordiv__(-long(4), long(2)), -long(2)) #__truediv__ self.assertEqual(operator.__truediv__(0, 1), 0) self.assertEqual(operator.__truediv__(4, 2), 2) self.assertEqual(operator.__truediv__(-1, 2), -0.5) self.assertEqual(operator.__truediv__(0.0, 1.0), 0.0) self.assertEqual(operator.__truediv__(4.0, 2.0), 2.0) self.assertEqual(operator.__truediv__(-1.0, 2.0), -0.5) self.assertEqual(operator.__truediv__(long(0), long(1)), long(0)) self.assertEqual(operator.__truediv__(long(4), long(2)), long(2)) self.assertEqual(operator.__truediv__(-long(4), long(2)), -long(2)) #__mod__ self.assertEqual(operator.__mod__(0, 1), 0) self.assertEqual(operator.__mod__(4, 2), 0) self.assertEqual(operator.__mod__(-1, 2), 1) self.assertEqual(operator.__mod__(0.0, 1.0), 0.0) self.assertEqual(operator.__mod__(4.0, 2.0), 0.0) self.assertEqual(operator.__mod__(-1.0, 2.0), 1.0) self.assertEqual(operator.__mod__(long(0), long(1)), long(0)) self.assertEqual(operator.__mod__(long(4), long(2)), long(0)) self.assertEqual(operator.__mod__(-long(4), long(2)), long(0)) #__inv__ self.assertEqual(operator.__inv__(0), -1) self.assertEqual(operator.__inv__(1), -2) self.assertEqual(operator.__inv__(-1), 0) self.assertEqual(operator.__inv__(long(0)), -long(1)) self.assertEqual(operator.__inv__(long(1)), -long(2)) self.assertEqual(operator.__inv__(-long(1)), long(0)) #__invert__ self.assertEqual(operator.__invert__(0), -1) self.assertEqual(operator.__invert__(1), -2) self.assertEqual(operator.__invert__(-1), 0) self.assertEqual(operator.__invert__(long(0)), -long(1)) self.assertEqual(operator.__invert__(long(1)), -long(2)) self.assertEqual(operator.__invert__(-long(1)), long(0)) #__lshift__ self.assertEqual(operator.__lshift__(0, 1), 0) self.assertEqual(operator.__lshift__(1, 1), 2) self.assertEqual(operator.__lshift__(-1, 1), -2) self.assertEqual(operator.__lshift__(long(0), 1), long(0)) self.assertEqual(operator.__lshift__(long(1), 1), long(2)) self.assertEqual(operator.__lshift__(-long(1), 1), -long(2)) #__rshift__ self.assertEqual(operator.__rshift__(1, 1), 0) self.assertEqual(operator.__rshift__(2, 1), 1) self.assertEqual(operator.__rshift__(-1, 1), -1) self.assertEqual(operator.__rshift__(long(1), 1), long(0)) self.assertEqual(operator.__rshift__(long(2), 1), long(1)) self.assertEqual(operator.__rshift__(-long(1), 1), -long(1)) #__not__ self.assertEqual(operator.__not__(0), 1) self.assertEqual(operator.__not__(1), 0) self.assertEqual(operator.__not__(-1), 0) self.assertEqual(operator.__not__(long(0)), 1) self.assertEqual(operator.__not__(long(1)), 0) self.assertEqual(operator.__not__(-long(1)), 0) #__and__ self.assertEqual(operator.__and__(0, 0), 0) self.assertEqual(operator.__and__(1, 1), 1) self.assertEqual(operator.__and__(0, 1), 0) self.assertEqual(operator.__and__(1, 0), 0) #__xor__ self.assertEqual(operator.__xor__(0, 0), 0) self.assertEqual(operator.__xor__(1, 1), 0) self.assertEqual(operator.__xor__(0, 1), 1) self.assertEqual(operator.__xor__(1, 0), 1) #__or__ self.assertEqual(operator.__or__(0, 0), 0) self.assertEqual(operator.__or__(1, 1), 1) self.assertEqual(operator.__or__(0, 1), 1) self.assertEqual(operator.__or__(1, 0), 1) #__concat__ self.assertEqual(operator.__concat__([0], [1]), [0,1]) self.assertEqual(operator.__concat__([2], [1]), [2,1]) self.assertEqual(operator.__concat__([-1], [1]), [-1,1]) #__contains__ self.assertTrue(operator.__contains__("abc", "c")) self.assertTrue(not operator.__contains__("abc", "d")) self.assertTrue(operator.__contains__("abc", "")) self.assertTrue(not operator.__contains__("", "c")) self.assertTrue(operator.__contains__([1,2,3], 1)) self.assertTrue(not operator.__contains__([1,2,3], 4)) #__getitem__ self.assertEqual(operator.__getitem__("abc", 2), "c") self.assertRaises(IndexError, operator.__getitem__, "abc", 3) self.assertEqual(operator.__getitem__([1,2,3], 2), 3) self.assertRaises(IndexError, operator.__getitem__, [1,2,3], 3) #__setitem__ self.assertRaises(TypeError, operator.__setitem__, "abc", 2, "d") t_list = [1,2,3] operator.__setitem__(t_list, 2, 4) self.assertEqual(t_list, [1,2,4]) self.assertRaises(IndexError, operator.__setitem__, [1,2,3], 4, 9) #__delitem__ #UNIMPLEMENTED #self.assertRaises(TypeError, operator.__delitem__, "abc", 2) t_list = [1,2,3] operator.__delitem__(t_list, 2) self.assertEqual(t_list, [1,2]) self.assertRaises(IndexError, operator.__delitem__, [1,2,3], 4) #__repeat__ self.assertEqual(operator.__repeat__("abc", 2), "abcabc") self.assertEqual(operator.__repeat__("", 2), "") self.assertEqual(operator.__repeat__([1,2,3], 2), [1,2,3,1,2,3]) #__getslice__ self.assertEqual(operator.__getslice__("abc", 1, 2), "b") self.assertEqual(operator.__getslice__("abc", 0, 3), "abc") self.assertEqual(operator.__getslice__("", 0, 0), "") self.assertEqual(operator.__getslice__([1,2,3], 1, 2), [2]) self.assertEqual(operator.__getslice__([1,2,3], 0, 3), [1,2,3]) self.assertEqual(operator.__getslice__([], 0, 0), []) #__delslice__ t_list = [1,2,3] operator.__delslice__(t_list, 1, 2) self.assertEqual(t_list, [1,3]) t_list = [1,2,3] operator.__delslice__(t_list, 0, 3) self.assertEqual(t_list, []) t_list = [1,2,3] operator.__delslice__(t_list, 0, 0) self.assertEqual(t_list, [1,2,3]) #__setslice__ t_list = [1,2,3] operator.__setslice__(t_list, 1, 2, [9]) self.assertEqual(t_list, [1,9,3]) t_list = [1,2,3] operator.__setslice__(t_list, 0, 3, [9, 8]) self.assertEqual(t_list, [9, 8]) t_list = [1,2,3] operator.__setslice__(t_list, 0, 0, [9]) self.assertEqual(t_list, [9,1, 2,3])
def __getitem__(self, key): """self[key]""" return __getitem__(get_wrapped_object(self), get_wrapped_object(key))
def update_event(self, inp=-1): self.set_output_val(0, operator.__getitem__(self.input(0), self.input(1)))
floordiv = spice(lambda x, y: operator.floordiv(x, y), name='floordiv', doc=operator.floordiv.__doc__) __floordiv__ = spice(lambda x, y: operator.__floordiv__(x, y), name='__floordiv__', doc=operator.floordiv.__doc__) # reversed ge = spice(lambda x, y: operator.ge(y, x), name='ge') __ge__ = spice(lambda x, y: operator.__ge__(y, x), name='__ge__') getitem = spice(lambda x, y: operator.getitem(x, y), name='getitem', doc=operator.getitem.__doc__) __getitem__ = spice(lambda x, y: operator.__getitem__(x, y), name='__getitem__', doc=operator.getitem.__doc__) # reversed gt = spice(lambda x, y: operator.gt(y, x), name='gt') __gt__ = spice(lambda x, y: operator.__gt__(y, x)) indexOf = spice(lambda x, y: operator.indexOf(x, y), name='indexOf', doc=operator.indexOf.__doc__) is_ = spice(lambda x, y: operator.is_(x, y), name='is_', doc=operator.is_.__doc__) is_not = spice(lambda x, y: operator.is_not(x, y), name='is_not',