def test_copy(self) -> None: u = List([1, 2, 3]) v = u.copy() self.assertEqual(v, [1, 2, 3]) u = List([]) v = u.copy() self.assertEqual(v, []) # test that it's indeed a copy and not a reference u = List(["a", "b"]) v = u.copy() v.append("i") self.assertEqual(u, ["a", "b"]) self.assertEqual(v, u + ["i"]) # test that it's a shallow, not a deep copy u = List([1, 2, [3, 4], 5]) v = u.copy() self.assertEqual(u, v) # we upcast to remove the randomly generated IDs if hasattr(v[3], "upcast") and hasattr(u[3], "upcast"): self.assertIs(v[3].upcast(), u[3].upcast()) else: self.assertIs(v[3], u[3]) self.assertRaises(TypeError, u.copy, None)
def avg_plan(avg=List(local_model.parameters()), item=List(local_model.parameters()), num=Int(0)): new_avg = [] for i, param in enumerate(avg): new_avg.append((avg[i] * num + item[i]) / (num + 1)) return new_avg
def test_append(self) -> None: a = List([]) a.append(0) a.append(1) a.append(2) self.assertEqual(a, List([0, 1, 2])) self.assertRaises(TypeError, a.append)
def test_reversed(self) -> None: a = List(range(20)) r = reversed(a) self.assertEqual(list(r), List(range(19, -1, -1))) self.assertRaises(StopIteration, next, r) self.assertEqual(list(reversed(List())), List()) # Bug 3689: make sure list-reversed-iterator doesn't have __len__ self.assertRaises(TypeError, len, reversed([1, 2, 3]))
def avg_plan( # type: ignore avg=List(model.parameters()), item=List(model.parameters()), num=Int(0), ): new_avg = [] for i, param in enumerate(avg): new_avg.append((avg[i] * num + item[i]) / (num + 1)) return new_avg
def test_exhausted_iterator(self) -> None: a = List([1, 2, 3]) exhit = iter(a) empit = iter(a) for x in exhit: # exhaust the iterator next(empit) # not exhausted a.append(9) self.assertEqual(list(exhit), []) self.assertEqual(list(empit), [9]) self.assertEqual(a, List([1, 2, 3, 9]))
def averaging_plan( # Average of diffs, not parameters current_average=List(local_agent.parameters()), next_diff=List(local_agent.parameters()), num=Int(0), ): return [ (current_param * num + diff_param) / (num + 1) for current_param, diff_param in zip(current_average, next_diff) ]
def test_imul(self) -> None: u = List([0, 1]) u *= 3 self.assertEqual(u, List([0, 1, 0, 1, 0, 1])) u *= 0 self.assertEqual(u, List([])) s = List([]) oldid = id(s) s *= 10 self.assertEqual(id(s), oldid)
def test_pop(self) -> None: a = List([-1, 0, 1]) a.pop() self.assertEqual(a, [-1, 0]) a.pop(0) self.assertEqual(a, [0]) self.assertRaises(IndexError, a.pop, 5) a.pop(0) self.assertEqual(a, []) self.assertRaises(IndexError, a.pop) self.assertRaises(TypeError, a.pop, 42, 42) a = List([0, 10, 20, 30, 40])
def test_sort(self) -> None: u = List([1, 0]) u.sort() self.assertEqual(u, [0, 1]) u = List([2, 1, 0, -1, -2]) u.sort() self.assertEqual(u, List([-2, -1, 0, 1, 2])) self.assertRaises(TypeError, u.sort, 42, 42) def revcmp(a: Any, b: Any) -> int: if a == b: return 0 elif a < b: return 1 else: # a > b return -1 u.sort(key=cmp_to_key(revcmp)) self.assertEqual(u, List([2, 1, 0, -1, -2])) # The following dumps core in unpatched Python 1.5: def myComparison(x: Any, y: Any) -> int: xmod, ymod = x % 3, y % 7 if xmod == ymod: return 0 elif xmod < ymod: return -1 else: # xmod > ymod return 1 z = List(range(12)) z.sort(key=cmp_to_key(myComparison)) self.assertRaises(TypeError, z.sort, 2) def selfmodifyingComparison(x: Any, y: Any) -> int: z.append(1) if x == y: return 0 elif x < y: return -1 else: # x > y return 1 self.assertRaises(ValueError, z.sort, key=cmp_to_key(selfmodifyingComparison)) self.assertRaises(TypeError, z.sort, 42, 42, 42, 42)
def test_insert(self) -> None: a = List([0, 1, 2]) a.insert(0, -2) a.insert(1, -1) a.insert(2, 0) self.assertEqual(a, [-2, -1, 0, 0, 1, 2]) b = a[:] b.insert(-2, "foo") b.insert(-200, "left") b.insert(200, "right") self.assertEqual(b, List(["left", -2, -1, 0, 0, "foo", 1, 2, "right"])) self.assertRaises(TypeError, a.insert)
def test_set_subscript(self) -> None: a = List(range(20)) self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 0), [1, 2, 3]) self.assertRaises(TypeError, a.__setitem__, slice(0, 10), 1) self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 2), [1, 2]) self.assertRaises(TypeError, a.__getitem__, "x", 1) a[slice(2, 10, 3)] = [1, 2, 3] self.assertEqual( a, List([ 0, 1, 1, 3, 4, 2, 6, 7, 3, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ]), )
def test_clear(self) -> None: u = List([2, 3, 4]) u.clear() self.assertEqual(u, []) u = List([]) u.clear() self.assertEqual(u, []) u = List([]) u.append(1) u.clear() u.append(2) self.assertEqual(u, [2]) self.assertRaises(TypeError, u.clear, None)
def test_repr(self) -> None: l0: ListT[int] = [] l2: ListT[int] = [0, 1, 2] a0 = List(l0) a2 = List(l2) self.assertEqual(str(a0), str(l0)) self.assertEqual(repr(a0), repr(l0)) self.assertEqual(repr(a2), repr(l2)) self.assertEqual(str(a2), "[0, 1, 2]") self.assertEqual(repr(a2), "[0, 1, 2]") a2.append(a2) a2.append(3) self.assertEqual(str(a2), "[0, 1, 2, [...], 3]") self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
def test_list_serde() -> None: t1 = th.tensor([1, 2]) t2 = th.tensor([1, 3]) syft_list = List([t1, t2]) serialized = syft_list._object2proto() assert isinstance(serialized, List_PB) deserialized = List._proto2object(proto=serialized) assert isinstance(deserialized, List) assert deserialized.id == syft_list.id for deserialized_el, original_el in zip(deserialized, syft_list): assert (deserialized_el == original_el).all()
def test_reverse(self) -> None: u = List([-2, -1, 0, 1, 2]) u2 = u[:] u.reverse() self.assertEqual(u, [2, 1, 0, -1, -2]) u.reverse() self.assertEqual(u, u2) self.assertRaises(TypeError, u.reverse, 42)
def test_delitem(self) -> None: a = List([0, 1]) del a[1] self.assertEqual(a, [0]) del a[0] self.assertEqual(a, []) a = List([0, 1]) del a[-2] self.assertEqual(a, [1]) del a[-1] self.assertEqual(a, []) a = List([0, 1]) self.assertRaises(IndexError, a.__delitem__, -3) self.assertRaises(IndexError, a.__delitem__, 2) a = List([]) self.assertRaises(IndexError, a.__delitem__, 0) self.assertRaises(TypeError, a.__delitem__)
def training_plan(xs=th.rand(64, 1, 28, 28), ys=th.zeros([64, 10]), params=List(local_model.parameters())): model = local_model.send(ROOT_CLIENT) set_params(model, params) out = model(xs) loss = cross_entropy_loss(out, ys, 64) loss.backward() sgd_step(model) return model.parameters(), loss
def test_setslice(self) -> None: l = [0, 1] # noqa: E741 a = List(l) for i in range(-3, 4): a[:i] = l[:i] self.assertEqual(a, l) a2 = a[:] a2[:i] = a[:i] self.assertEqual(a2, a) a[i:] = l[i:] self.assertEqual(a, l) a2 = a[:] a2[i:] = a[i:] self.assertEqual(a2, a) for j in range(-3, 4): a[i:j] = l[i:j] self.assertEqual(a, l) a2 = a[:] a2[i:j] = a[i:j] self.assertEqual(a2, a) aa2 = a2[:] aa2[:0] = [-2, -1] self.assertEqual(aa2, [-2, -1, 0, 1]) aa2[0:] = [] self.assertEqual(aa2, []) a = List([1, 2, 3, 4, 5]) a[:-1] = a self.assertEqual(a, List([1, 2, 3, 4, 5, 5])) a = List([1, 2, 3, 4, 5]) a[1:] = a self.assertEqual(a, List([1, 1, 2, 3, 4, 5])) a = List([1, 2, 3, 4, 5]) a[1:-1] = a self.assertEqual(a, List([1, 1, 2, 3, 4, 5, 5])) a = List([]) a[:] = tuple(range(10)) self.assertEqual(a, List(range(10))) self.assertRaises(TypeError, a.__setitem__, slice(0, 1, 5)) self.assertRaises(TypeError, a.__setitem__)
def test_extend(self) -> None: a1 = List([0]) a2 = List((0, 1)) a = a1[:] a.extend(a2) self.assertEqual(a, a1 + a2) a.extend(List([])) self.assertEqual(a, a1 + a2) a.extend(a) self.assertEqual(a, List([0, 0, 1, 0, 0, 1])) a = List("spam") a.extend("eggs") self.assertEqual(a, list("spameggs")) self.assertRaises(TypeError, a.extend, None) self.assertRaises(TypeError, a.extend) # overflow test. issue1621 class CustomIter: def __iter__(self) -> "CustomIter": return self def __next__(self) -> Any: raise StopIteration def __length_hint__(self) -> int: return sys.maxsize a = List([1, 2, 3, 4]) a.extend(CustomIter()) self.assertEqual(a, [1, 2, 3, 4])
def test_remove(self) -> None: a = List([0, 0, 1]) a.remove(1) self.assertEqual(a, [0, 0]) a.remove(0) self.assertEqual(a, [0]) a.remove(0) self.assertEqual(a, []) self.assertRaises(ValueError, a.remove, 0) self.assertRaises(TypeError, a.remove) class BadExc(Exception): pass class BadCmp: def __eq__(self, other: Any) -> bool: if other == 2: raise BadExc() return False a = List([0, 1, 2, 3]) self.assertRaises(BadExc, a.remove, BadCmp()) class BadCmp2: def __eq__(self, other: Any) -> bool: raise BadExc() d = List("abcdefghcij") d.remove("c") self.assertEqual(d, List("abdefghcij")) d.remove("c") self.assertEqual(d, List("abdefghij")) self.assertRaises(ValueError, d.remove, "c") self.assertEqual(d, List("abdefghij")) # Handle comparison errors d = List(["a", "b", BadCmp2(), "c"]) e = List(d) self.assertRaises(BadExc, d.remove, "c") for x, y in zip(d, e): # verify that original order and values are retained. # we upcast to remove the randomly generated IDs if hasattr(x, "upcast") and hasattr(y, "upcast"): self.assertIs(x.upcast(), y.upcast()) else: self.assertIs(x, y)
def test_slice_types() -> None: py_string = "Python" py_list = ["P", "y", "t", "h", "o", "n"] py_tuple = ("P", "y", "t", "h", "o", "n") sy_string = String(py_string) sy_tuple = Tuple(py_tuple) sy_list = List(py_list) py_slice1 = slice(1) sy_slice1 = Slice(1) assert py_slice1.start == sy_slice1.start assert py_slice1.stop == sy_slice1.stop assert py_slice1.step == sy_slice1.step assert py_slice1 == sy_slice1 py_slice2 = slice(1, 2) sy_slice2 = Slice(1, 2) assert py_slice2 == sy_slice2 assert py_slice2.start == sy_slice2.start assert py_slice2.stop == sy_slice2.stop assert py_slice2.step == sy_slice2.step py_slice3 = slice(1, 2, -1) sy_slice3 = Slice(1, 2, -1) assert py_slice3 == sy_slice3 assert py_slice3.start == sy_slice3.start assert py_slice3.stop == sy_slice3.stop assert py_slice3.step == sy_slice3.step assert sy_string[sy_slice1] == py_string[py_slice1] assert sy_string[sy_slice2] == py_string[py_slice2] assert sy_string[sy_slice3] == py_string[py_slice3] assert sy_tuple[sy_slice1] == py_tuple[py_slice1] assert sy_tuple[sy_slice2] == py_tuple[py_slice2] assert sy_tuple[sy_slice3] == py_tuple[py_slice3] assert sy_list[sy_slice1] == py_list[py_slice1] assert sy_list[sy_slice2] == py_list[py_slice2] assert sy_list[sy_slice3] == py_list[py_slice3] assert sy_list[py_slice3] == py_list[py_slice3]
def test_setitem(self) -> None: a = List([0, 1]) a[0] = 0 a[1] = 100 self.assertEqual(a, List([0, 100])) a[-1] = 200 self.assertEqual(a, List([0, 200])) a[-2] = 100 self.assertEqual(a, List([100, 200])) self.assertRaises(IndexError, a.__setitem__, -3, 200) self.assertRaises(IndexError, a.__setitem__, 2, 200) a = List([]) self.assertRaises(IndexError, a.__setitem__, 0, 200) self.assertRaises(IndexError, a.__setitem__, -1, 200) self.assertRaises(TypeError, a.__setitem__) a = List([0, 1, 2, 3, 4]) a[0] = 1 a[1] = 2 a[2] = 3 self.assertEqual(a, List([1, 2, 3, 3, 4])) a[0] = 5 a[1] = 6 a[2] = 7 self.assertEqual(a, List([5, 6, 7, 3, 4])) a[-2] = 88 a[-1] = 99 self.assertEqual(a, List([5, 6, 7, 88, 99])) a[-2] = 8 a[-1] = 9 self.assertEqual(a, List([5, 6, 7, 8, 9])) msg = "list indices must be integers or slices" with self.assertRaisesRegex(TypeError, msg): a["a"] = "python"
def test_list_send() -> None: alice = sy.VirtualMachine(name="alice") alice_client = alice.get_client() t1 = th.tensor([1, 2]) t2 = th.tensor([1, 3]) syft_list = List([t1, t2]) ptr = syft_list.send(alice_client) # Check pointer type assert ptr.__class__.__name__ == "ListPointer" # Check that we can get back the object res = ptr.get() for res_el, original_el in zip(res, syft_list): assert (res_el == original_el).all()
def train( # type: ignore xs=th.rand([64 * 3, 1, 28, 28]), ys=th.randint(0, 10, [64 * 3, 10]), params=List(local_model.parameters()), ): model = local_model.send(ROOT_CLIENT) set_params(model, params) for i in range(2): indices = th.tensor(range(64 * i, 64 * (i + 1))) x, y = xs.index_select(0, indices), ys.index_select(0, indices) out = model(x) loss = cross_entropy_loss(out, y, 64) loss.backward() sgd_step(model) return model.parameters()
def test_init(self) -> None: # Iterable arg is optional self.assertEqual(List([]), List()) # Init clears previous values a = List([1, 2, 3]) a.__init__() self.assertEqual(a, List([])) # Init overwrites previous values a = List([1, 2, 3]) a.__init__([4, 5, 6]) self.assertEqual(a, List([4, 5, 6])) # Mutables always return a new object b = List(a) self.assertNotEqual(id(a), id(b)) self.assertEqual(a, b)
def test_repr_deep(self) -> None: a = List([]) for i in range(sys.getrecursionlimit() + 100): a = List([a]) self.assertRaises(RecursionError, repr, a)
def test_extendedslicing(self) -> None: # subscript a = List([0, 1, 2, 3, 4]) # deletion del a[::2] self.assertEqual(a, List([1, 3])) a = List(range(5)) del a[1::2] self.assertEqual(a, List([0, 2, 4])) a = List(range(5)) del a[1::-2] self.assertEqual(a, List([0, 2, 3, 4])) a = List(range(10)) del a[::1000] self.assertEqual(a, List([1, 2, 3, 4, 5, 6, 7, 8, 9])) # assignment a = List(range(10)) a[::2] = [-1] * 5 self.assertEqual(a, List([-1, 1, -1, 3, -1, 5, -1, 7, -1, 9])) a = List(range(10)) a[::-4] = [10] * 3 self.assertEqual(a, List([0, 10, 2, 3, 4, 10, 6, 7, 8, 10])) a = List(range(4)) a[::-1] = a self.assertEqual(a, List([3, 2, 1, 0])) a = List(range(10)) b = a[:] c = a[:] a[2:3] = List(["two", "elements"]) b[slice(2, 3)] = List(["two", "elements"]) c[2:3:] = List(["two", "elements"]) self.assertEqual(a, b) self.assertEqual(a, c) a = List(range(10)) a[::2] = tuple(range(5)) self.assertEqual(a, List([0, 1, 1, 3, 2, 5, 3, 7, 4, 9])) # test issue7788 a = List(range(10)) del a[9::1 << 333] # noqa: E203
def test_iadd(self) -> None: u = List([0, 1]) u += List() self.assertEqual(u, List([0, 1])) u += List([2, 3]) self.assertEqual(u, List([0, 1, 2, 3])) u += List([4, 5]) self.assertEqual(u, List([0, 1, 2, 3, 4, 5])) u = List("spam") u += List("eggs") self.assertEqual(u, List("spameggs")) u = List([0, 1]) u2 = u u += [2, 3] self.assertIs(u, u2) u = List("spam") u += "eggs" self.assertEqual(u, List("spameggs")) self.assertRaises(TypeError, u.__iadd__, None)
def test_slice(self) -> None: u = List("spam") u[:2] = "h" self.assertEqual(u, list("ham"))