def testDeleteAll(self): keys = [(i, num2words(i)) for i in range(100)] cxt = tc.Context() cxt.tree = tc.btree.BTree(SCHEMA) cxt.inserts = [cxt.tree.insert(key) for key in keys] cxt.delete = tc.After(cxt.inserts, cxt.tree.delete()) cxt.result = tc.After(cxt.delete, cxt.tree) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, expected([]))
def testDelete(self): count = 2 values = [(v,) for v in range(count)] keys = [(num2words(i),) for i in range(count)] cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.delete = tc.After(cxt.inserts, cxt.table.delete()) cxt.result = tc.After(cxt.delete, cxt.table) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, expected(SCHEMA, []))
def testDeleteSlice(self): count = 50 values = [[v] for v in range(count)] keys = [[num2words(i)] for i in range(count)] remaining = sorted([k + v for k, v in zip(keys, values) if v[0] >= 40]) cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.delete = tc.After(cxt.inserts, cxt.table.delete(tc.Map(views=slice(40)))) cxt.result = tc.After(cxt.delete, cxt.table) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, expected(SCHEMA, remaining))
def testCreate(self): cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.result = tc.After(cxt.table.insert(("name",), (0,)), cxt.table.count()) count = self.host.post(ENDPOINT, cxt) self.assertEqual(count, 1)
def testCreate(self): cxt = tc.Context() cxt.tree = tc.btree.BTree(SCHEMA) cxt.result = tc.After(cxt.tree.insert((1, "one")), cxt.tree.count()) count = self.host.post(ENDPOINT, cxt) self.assertEqual(count, 1)
def testSlice(self): schema = tc.table.Schema([ tc.Column("0", tc.U64), tc.Column("1", tc.U64), tc.Column("2", tc.U64), tc.Column("3", tc.U64), ], [ tc.Column("value", tc.Number), ]) for i in range(4): schema.create_index(str(i), [str(i)]) data = [ ([0, 0, 1, 0], 1), ([0, 1, 2, 0], 2), ([1, 0, 0, 0], 3), ([1, 0, 1, 0], 3), ] cxt = tc.Context() cxt.table = tc.table.Table(schema) cxt.inserts = [cxt.table.insert(coord, [value]) for (coord, value) in data] cxt.result = tc.After(cxt.inserts, cxt.table.where({ "0": slice(2), "1": slice(3), "2": slice(4), "3": slice(1) })) expect = expected(schema, [coord + [value] for coord, value in data]) actual = self.host.post(ENDPOINT, cxt) self.assertEqual(actual, expect)
def weigh(self, txn, key: tc.Nil, new_value: tc.Number): left = tc.use(Left) txn.total = CONSERVED txn.current = self.weight.subject() txn.update = tc.After(self.weight.set(new_value), left.weigh(None, txn.total - new_value)) return tc.If(txn.current == new_value, None, txn.update)
def buy(self, txn, quantity: tc.Number): txn.inventory = self.inventory() txn.new_inventory = txn.inventory - quantity txn.sale = tc.If( quantity > txn.inventory, tc.error.BadRequest("requested quantity is unavailable"), self.in_stock.set(txn.new_inventory)) return tc.After(self.authorize(SCOPE), txn.sale)
def testSliceRange(self): keys = [[i, num2words(i)] for i in range(50)] cxt = tc.Context() cxt.tree = tc.btree.BTree(SCHEMA) cxt.inserts = [cxt.tree.insert(key) for key in keys] cxt.result = tc.After(cxt.inserts, cxt.tree[29:32]) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, expected(keys[29:32]))
def recommend(self, txn, user_id: tc.U32): txn.vector = tc.graph.Vector.create() txn.user_ids = tc.After(txn.vector[user_id].write(True), txn.vector) txn.friend_ids = tc.If( user_id.is_some(), self.friend.match(txn.user_ids, 2), tc.error.BadRequest("invalid user ID: {{user_id}}", user_id=user_id)) txn.order_ids = self.user_order.foreign(txn.friend_ids) txn.product_ids = self.order_product.foreign(txn.order_ids) return self.product.read_vector(txn.product_ids)
def testSlice(self): count = 50 values = [(v, ) for v in range(count)] keys = [(num2words(i), ) for i in range(count)] cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.result = tc.After(cxt.inserts, cxt.table.where({"name": "one"})) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, expected(SCHEMA, [["one", 1]]))
def testGroupBy(self): count = 50 values = [(v % 2, ) for v in range(count)] keys = [(num2words(i), ) for i in range(count)] cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.result = tc.After(cxt.inserts, cxt.table.group_by(["views"])) actual = self.host.post(ENDPOINT, cxt) self.assertEqual(actual, [[0], [1]])
def testConstant(self): c = 1.414 shape = [3, 2, 1] cxt = tc.Context() cxt.tensor = tc.tensor.Dense.constant(shape, c) cxt.result = tc.After(cxt.tensor[0, 0, 0].write(0), cxt.tensor) expected = expect_dense(tc.F64, shape, [0] + [c] * (np.product(shape) - 1)) actual = self.host.post(ENDPOINT, cxt) self.assertEqual(expected, actual)
def testCreate(self): shape = [2, 5] coord = [0, 0] value = 1 cxt = tc.Context() cxt.tensor = tc.tensor.Sparse.zeros(shape, tc.I32) cxt.result = tc.After(cxt.tensor[coord].write(value), cxt.tensor) actual = self.host.post(ENDPOINT, cxt) expected = expect_sparse(tc.I32, shape, [[coord, value]]) self.assertEqual(actual, expected)
def testWriteAndSlice(self): shape = [2, 5] cxt = tc.Context() cxt.tensor = tc.tensor.Sparse.zeros(shape) cxt.result = tc.After(cxt.tensor[:, 2:-1].write(1), cxt.tensor) actual = self.host.post(ENDPOINT, cxt) expected = expect_sparse( tc.F32, shape, [[[0, 2], 1], [[0, 3], 1], [[1, 2], 1], [[1, 3], 1]]) self.assertEqual(actual, expected)
def testMul(self): cxt = tc.Context() cxt.dense = tc.tensor.Dense.arange([3], 0, 3) cxt.sparse = tc.tensor.Sparse.zeros([2, 3], tc.I32) cxt.result = tc.After(cxt.sparse[0, 1:3].write(2), cxt.dense * cxt.sparse) actual = self.host.post(ENDPOINT, cxt) expected = np.zeros([2, 3]) expected[0, 1:3] = 2 expected = expected * np.arange(0, 3) self.assertEqual(actual, expect_sparse(tc.I64, [2, 3], expected))
def testLimit(self): count = 50 values = [(v,) for v in range(count)] keys = [(num2words(i),) for i in range(count)] cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.result = tc.After(cxt.inserts, cxt.table.limit(1)) result = self.host.post(ENDPOINT, cxt) first_row = sorted(list(k + v) for k, v in zip(keys, values))[0] self.assertEqual(result, expected(SCHEMA, [first_row]))
def testOrderBy(self): count = 50 values = [(v, ) for v in range(count)] keys = [(num2words(i), ) for i in range(count)] rows = list(reversed([list(k + v) for k, v in zip(keys, values)])) cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.result = tc.After(cxt.inserts, cxt.table.order_by(["views"], True)) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, expected(SCHEMA, rows))
def testDeleteSlice(self): keys = [[i, num2words(i)] for i in range(10)] ordered = keys[:25] + keys[35:] random.shuffle(keys) cxt = tc.Context() cxt.tree = tc.btree.BTree.load(SCHEMA, ordered) cxt.delete = cxt.tree.delete([slice(25, 35)]) cxt.result = tc.After(cxt.delete, cxt.tree) actual = self.host.post(ENDPOINT, cxt) self.assertEqual(actual, expected(ordered))
def testDiv(self): self.maxDiff = None cxt = tc.Context() cxt.dense = tc.tensor.Dense.arange([30, 3, 2], 1., 181.) cxt.sparse = tc.tensor.Sparse.zeros([3, 2], tc.F32) cxt.result = tc.After(cxt.sparse[1].write(2), cxt.sparse / cxt.dense) actual = self.host.post(ENDPOINT, cxt) l = np.arange(1, 181).reshape([30, 3, 2]) r = np.zeros([3, 2], float) r[1] = 2. expected = r / l self.assertEqual(actual, expect_sparse(tc.F64, [30, 3, 2], expected))
def testAdd(self): cxt = tc.Context() cxt.dense = tc.tensor.Dense.arange([3, 5, 2], 0, 30) cxt.sparse = tc.tensor.Sparse.zeros([5, 2], tc.I32) cxt.result = tc.After(cxt.sparse[1].write(3), cxt.dense + cxt.sparse) actual = self.host.post(ENDPOINT, cxt) l = np.arange(0, 30).reshape([3, 5, 2]) r = np.zeros([5, 2], np.int32) r[1] = 3 expected = l + r self.assertEqual(actual, expect_dense(tc.I64, [3, 5, 2], expected.flatten()))
def testSliceAndWriteTensor(self): cxt = tc.Context() cxt.big = tc.tensor.Dense.zeros([2, 2, 5]) cxt.small = tc.tensor.Dense.arange([2, 5], 1, 11) cxt.result = tc.After(cxt.big[1, :2].write(cxt.small[0]), cxt.big) actual = self.host.post(ENDPOINT, cxt) expected = np.zeros([2, 2, 5], np.int64) expected[1, 0:2] = np.arange(1, 11).reshape(2, 5)[0] expected = expect_dense(tc.F64, [2, 2, 5], expected.flatten()) self.assertEqual(actual, expected)
def testSum(self): shape = [2, 4, 3, 5] axis = 1 cxt = tc.Context() cxt.big = tc.tensor.Sparse.zeros(shape, tc.I32) cxt.result = tc.After(cxt.big[0, 1:3].write(2), cxt.big.sum(axis)) actual = self.host.post(ENDPOINT, cxt) expected = np.zeros(shape, dtype=np.int32) expected[0, 1:3] = 2 expected = expected.sum(axis) expected = expect_sparse(tc.I32, [2, 3, 5], expected) self.assertEqual(actual, expected)
def testSetDiagonal(self): size = 3 shape = [size, size] x = np.arange(0, size**2).reshape(shape) diag = [2] * size cxt = tc.Context() cxt.x = tc.tensor.Dense.load(x.shape, x.flatten().tolist(), tc.I32) cxt.diag = tc.tensor.Dense.load([size], diag, tc.I32) cxt.result = tc.After(tc.linalg.set_diagonal(cxt.x, cxt.diag), cxt.x) x[range(size), range(size)] = diag actual = self.host.post(ENDPOINT, cxt) self.assertEqual(actual, expect_dense(x, tc.I32))
def testSliceAndWriteConstant(self): shape = [2, 5, 3, 3] cxt = tc.Context() cxt.tensor = tc.tensor.Dense.arange(shape, 1, 91) cxt.result = tc.After(cxt.tensor[:, :, 1:-1, 1:-1].write(1), cxt.tensor) actual = self.host.post(ENDPOINT, cxt) expected = np.arange(1, 91).reshape([2, 5, 3, 3]) expected[:, :, 1:-1, 1:-1] = 1 expected = expect_dense(tc.I64, list(expected.shape), expected.flatten()) self.assertEqual(actual, expected)
def testSliceAuxiliaryIndex(self): count = 50 values = [(v, ) for v in range(count)] keys = [(num2words(i), ) for i in range(count)] cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.result = tc.After(cxt.inserts, cxt.table.where({"views": slice(10, 20)})) result = self.host.post(ENDPOINT, cxt) self.assertEqual( result, expected(SCHEMA, list([[num2words(i), i] for i in range(10, 20)])))
def testInsert(self): for x in range(0, 100, 10): keys = list(range(x)) random.shuffle(keys) cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [ cxt.table.insert((num2words(i),), (i,)) for i in keys] cxt.result = tc.After(cxt.inserts, cxt.table.count()) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, x)
def testUpdateSlice(self): count = 50 values = [[v] for v in range(count)] keys = [[num2words(i)] for i in range(count)] cxt = tc.Context() cxt.table = tc.table.Table.load(SCHEMA, [k + v for k, v in zip(keys, values)]) cxt.update = cxt.table.update({"views": 0}, {"views": slice(10)}) cxt.result = tc.After(cxt.update, cxt.table.where({ "views": slice(1) }).count()) result = self.host.post(ENDPOINT, cxt) self.assertEqual(result, 10)
def testSelect(self): count = 5 values = [[v] for v in range(count)] keys = [[num2words(i)] for i in range(count)] cxt = tc.Context() cxt.table = tc.table.Table(SCHEMA) cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)] cxt.result = tc.After(cxt.inserts, cxt.table.select(["name"])) expected = { str(tc.URI(tc.table.Table)): [ tc.to_json(tc.table.Schema([tc.Column("name", tc.String, 512)])), list(sorted(keys)) ] } actual = self.host.post(ENDPOINT, cxt) self.assertEqual(actual, expected)
def testSub(self): shape = [3, 5, 2] cxt = tc.Context() cxt.big = tc.tensor.Sparse.zeros(shape, tc.I16) cxt.small = tc.tensor.Sparse.zeros([5, 2], tc.U32) cxt.result = tc.After([ cxt.big[:, 1:-2].write(2), cxt.small[1].write(3), ], cxt.small - cxt.big) actual = self.host.post(ENDPOINT, cxt) big = np.zeros(shape) big[:, 1:-2] = 2 small = np.zeros([5, 2]) small[1] = 3 expected = small - big expected = expect_sparse(tc.I32, shape, expected) self.assertEqual(actual, expected)