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 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 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',
