def test_dataframe_apply_projections_cache(self):
Car, CarForPedestrian, cars = CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df_cache = dataframe(mode = DataframeModes.ApplicationCache)
df_cache.add_type(CarForPedestrian)
df_cache.start_recording = True
df.connect(df_cache)
df.apply_all(update_json10)
self.assertTrue(len(df.get(Car)) == 2)
self.assertTrue(len(df.get(CarForPedestrian)) == 2)
#print json.dumps(df_cache.get_record(), sort_keys = True, separators = (',', ': '), indent = 4)
self.assertTrue(df_cache.get_record() == resp_json10)
def test_dataframe_apply_between_master_slaves1(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df_m = dataframe()
df_s = dataframe(mode = DataframeModes.ApplicationCache)
df_m.add_types([Car, ActiveCar, RedActiveCar])
df_s.add_types([Car, ActiveCar, RedActiveCar])
df_m.connect(df_s)
df_s.start_recording = True
df_m.apply_all(update_json1)
self.assertTrue(df_s.get_record()["gc"] == update_json1["gc"])
self.assertTrue(df_s.get(Car) == df_m.get(Car))
self.assertTrue(df_s.get(ActiveCar) == df_m.get(ActiveCar))
self.assertTrue(df_s.get(RedActiveCar) == df_m.get(RedActiveCar))
def test_dataframe_transfer_changes4(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df1 = dataframe()
df1.add_types([Car, ActiveCar, RedActiveCar])
df1.extend(Car, cars)
df2 = dataframe()
df2.add_types([Car, ActiveCar, RedActiveCar])
df2.extend(Car, cars) # Linked by reference
df1.start_recording = True
df2.start_recording = True
for c in df1.get(Car):
c.velocity += 1
self.assertTrue(df1.get_record() == df2.get_record())
def test_dataframe_transfer_changes4(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df1 = dataframe()
df1.add_types([Car, ActiveCar, RedActiveCar])
df1.extend(Car, cars)
df2 = dataframe()
df2.add_types([Car, ActiveCar, RedActiveCar])
df2.extend(Car, cars) # Linked by reference
df1.start_recording = True
df2.start_recording = True
for c in df1.get(Car):
c.velocity += 1
self.assertTrue(df1.get_record() != df2.get_record())
def test_dataframe_apply_between_master_slaves1(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df_m = dataframe()
df_m.add_types([Car, ActiveCar, RedActiveCar])
df_s = ApplicationQueue("df_s", [Car, ActiveCar, RedActiveCar], df_m)
df_m.apply_changes(update_json1)
self.assertTrue(df_s.get_record()["gc"] == update_json1["gc"])
def test_cyclic_reference_serialize(self):
class B(object):
def __init__(self, c):
self.c = c
class C(object):
def __init__(self):
self.b = None
@pcc_set
class A(object):
@primarykey(str)
def ID(self): return self._id
@ID.setter
def ID(self, v): self._id = v
@dimension(B)
def b(self): return self._b
@b.setter
def b(self, v): self._b = v
def __init__(self): self.ID = "hi"
a = A()
c = C()
b = B(c)
c.b = b
a.b = b
df = dataframe()
df.add_type(A)
df.start_recording = True
with self.assertRaises(RuntimeError) as assR:
df.append(A, a)
def test_dataframe_high_volume(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
cars = [Car(str(i), i%5, ["RED", "BLUE", "GREEN", "YELLOW"][i%4]) for i in xrange(1000)]
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.start_recording = True
df.extend(Car, cars)
df_c = dataframe_client()
df_c.add_types([Car, ActiveCar, RedActiveCar])
df_c.apply_changes(df.get_record())
df.clear_record()
self.assertTrue(len(df_c.get(Car)) == 1000)
self.assertTrue(len(df_c.get(ActiveCar)) == 800)
self.assertTrue(len(df_c.get(RedActiveCar)) == 200)
i = 0
for c in df.get(Car):
c.velocity = i % 3
i += 1
values = df.get_record()
df_c.apply_changes(values)
self.assertTrue(len(df_c.get(Car)) == 1000)
self.assertTrue(len(df_c.get(ActiveCar)) == 666)
self.assertTrue(len(df_c.get(RedActiveCar)) == 157)
def test_dataframe_apply_all_new(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.apply_all(update_json1)
self.assertTrue(len(df.get(Car)) == 4)
self.assertTrue(len(df.get(ActiveCar)) == 2)
self.assertTrue(len(df.get(RedActiveCar)) == 1)
def test_dataframe_apply_all_new_full_objs(self):
Car, InactiveCar, ActiveCar = create_complex_cartypes()
df = dataframe()
df.add_types([Car, ActiveCar, InactiveCar])
df.apply_changes(update_json9)
self.assertTrue(len(df.get(Car)) == 2)
self.assertTrue(len(df.get(InactiveCar)) == 2)
self.assertTrue(len(df.get(ActiveCar)) == 0)
def test_dataframe_apply_to_client2(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe(mode = DataframeModes.Client)
df.add_types([Car, ActiveCar, RedActiveCar])
df.apply_all(update_json1)
self.assertTrue(len(df.get(Car)) == 4)
self.assertTrue(len(df.get(ActiveCar)) == 2)
self.assertTrue(len(df.get(RedActiveCar)) == 1)
def test_dataframe_apply_all_new_full_objs(self):
Car, InactiveCar, ActiveCar = create_complex_cartypes()
df = dataframe()
df.add_types([Car, ActiveCar, InactiveCar])
df.apply_all(update_json9)
self.assertTrue(len(df.get(Car)) == 2)
self.assertTrue(len(df.get(InactiveCar)) == 2)
self.assertTrue(len(df.get(ActiveCar)) == 0)
def test_dataframe_get_join(self):
Person, Card, Transaction, RedAlert, people, cards, trans = _join_example_data()
df = dataframe()
df.add_types([Person, Card, Transaction, RedAlert])
df.extend(Person, people)
df.extend(Card, cards)
df.extend(Transaction, trans)
df.start_recording = True
df_c = dataframe(mode = DataframeModes.Client)
df_c.add_types([Person, Card, Transaction, RedAlert])
df_c.extend(Person, people)
df_c.extend(Card, cards)
df_c.extend(Transaction, trans)
df_c.apply_all(df.get_record())
self.assertTrue(len(df_c.get(RedAlert)) == 1)
def test_dataframe_apply_all_new(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.apply_changes(update_json1)
self.assertTrue(len(df.get(Car)) == 4)
self.assertTrue(len(df.get(ActiveCar)) == 2)
self.assertTrue(len(df.get(RedActiveCar)) == 1)
def test_multi_level_subset_get(self):
@pcc_set
class Car(object):
@primarykey(str)
def oid(self):
return self._id
@oid.setter
def oid(self, value):
self._id = value
@dimension(int)
def velocity(self):
return self._velocity
@velocity.setter
def velocity(self, value):
self._velocity = value
@dimension(str)
def color(self):
return self._color
@color.setter
def color(self, value):
self._color = value
def __init__(self, vel, col):
self.velocity = vel
self.color = col
@subset(Car)
class ActiveCar(Car):
@staticmethod
def __predicate__(c):
return c.velocity != 0
@subset(ActiveCar)
class RedActiveCar(Car):
@staticmethod
def __predicate__(ac):
return ac.color == "RED"
cars = [
Car(0, "BLUE"),
Car(0, "RED"),
Car(1, "GREEN"),
Car(1, "RED"),
Car(2, "RED")
]
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
self.assertTrue(len(df.get(RedActiveCar)) == 2)
self.assertTrue(len(df.get(ActiveCar)) == 3)
df.get(RedActiveCar)[0].velocity = 0
self.assertTrue(len(df.get(RedActiveCar)) == 1)
self.assertTrue(len(df.get(ActiveCar)) == 2)
def test_dataframe_apply_between_master_slaves3(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df_m = dataframe()
df_m.add_types([Car, ActiveCar, RedActiveCar])
df_s = ApplicationQueue("df_s", [ActiveCar, RedActiveCar], df_m)
df_m.apply_changes(update_json8)
#print json.dumps(df_s.get_record(), sort_keys = True, separators = (',', ': '), indent = 4)
self.assertTrue(df_s.get_record() == resp_json1)
self.assertTrue(len(df_m.get(Car)) == 4)
def test_dataframe_apply_with_normal_objects(self):
Car = create_cars_withobjects()
df = dataframe()
df.add_types([Car])
df.apply_changes(update_json7)
self.assertTrue(len(df.get(Car)) == 1)
c = df.get(Car)[0]
self.assertTrue(c.velocity.x == 10 and c.velocity.y == 10 and c.velocity.z == 10)
self.assertTrue(c.color == ["BLUE"])
def test_dataframe_apply_mod1(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
df.apply_all(update_json2)
self.assertTrue(len(df.get(Car)) == 5)
self.assertTrue(df.object_map["Car"]["id2"].color == "GREEN")
def test_dataframe_apply_mod1(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
df.apply_changes(update_json2)
self.assertTrue(len(df.get(Car)) == 5)
self.assertTrue(df.object_manager.object_map["Car"]["id2"].color == "GREEN")
def test_dataframe_apply_with_normal_objects(self):
Car = create_cars_withobjects()
df = dataframe()
df.add_types([Car])
df.apply_all(update_json7)
self.assertTrue(len(df.get(Car)) == 1)
c = df.get(Car)[0]
self.assertTrue(c.velocity.x == 10 and c.velocity.y == 10 and c.velocity.z == 10)
self.assertTrue(c.color == ["BLUE"])
def test_dataframe_apply_projections(self):
Car, CarForPedestrian, cars = CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df.apply_changes(update_json10)
self.assertTrue(len(df.get(Car)) == 2)
self.assertTrue(len(df.get(CarForPedestrian)) == 2)
for c in df.get(CarForPedestrian):
self.assertFalse(hasattr(c, "owner"))
self.assertTrue(hasattr(c, "location"))
def test_base_set_addition(self):
Node, Edge, nodes, edges = _CreateNodesAndEdges()
df = dataframe()
df.add_types([Node, Edge])
df.extend(Node, nodes)
df.extend(Edge, edges)
new_nodes = df.get(Node)
new_edges = df.get(Edge)
self.failUnless(len(new_nodes) == 4)
self.failUnless(len(new_edges) == 5)
def test_base_set_addition(self):
Node, Edge, nodes, edges = _CreateNodesAndEdges()
df = dataframe()
df.add_types([Node, Edge])
df.extend(Node, nodes)
df.extend(Edge, edges)
new_nodes = df.get(Node)
new_edges = df.get(Edge)
self.failUnless(len(new_nodes) == 4)
self.failUnless(len(new_edges) == 5)
def test_dataframe_apply_between_master_slaves3(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df_m = dataframe()
df_s = dataframe(mode = DataframeModes.ApplicationCache)
df_m.add_types([Car, ActiveCar, RedActiveCar])
df_s.add_types([ActiveCar, RedActiveCar])
df_m.connect(df_s)
df_s.start_recording = True
df_m.apply_all(update_json8)
#print json.dumps(df_s.get_record(), sort_keys = True, separators = (',', ': '), indent = 4)
self.assertTrue(df_s.get_record() == resp_json1)
try:
df_s.get(Car)
self.fail("Didn't catch exception at previous line")
except TypeError:
self.assertTrue(True)
self.assertTrue(len(df_m.get(Car)) == 4)
self.assertTrue(df_s.get(ActiveCar) == df_m.get(ActiveCar))
self.assertTrue(df_s.get(RedActiveCar) == df_m.get(RedActiveCar))
def test_dataframe_apply_projections(self):
Car, CarForPedestrian, cars = CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df.apply_all(update_json10)
self.assertTrue(len(df.get(Car)) == 2)
self.assertTrue(len(df.get(CarForPedestrian)) == 2)
for c in df.get(CarForPedestrian):
self.assertFalse(hasattr(c, "owner"))
self.assertTrue(hasattr(c, "location"))
def test_dataframe_transfer_changes3(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df1 = dataframe()
df1.add_types([Car, ActiveCar, RedActiveCar])
df1.extend(Car, cars)
Car, ActiveCar, RedActiveCar, cars = create_cars()
df2 = dataframe()
df2.add_types([Car, ActiveCar, RedActiveCar])
df2.extend(Car, cars) # So they are not linked by reference.
#print len(df1.get(ActiveCar)), len(df2.get(ActiveCar))
df1.start_recording = True
for c in df1.get(Car):
c.velocity += 1
self.assertFalse(len(df1.get(ActiveCar)) == len(df2.get(ActiveCar)))
#print len(df1.get(ActiveCar)), len(df2.get(ActiveCar))
df2.apply_all(df1.get_record())
#print len(df1.get(ActiveCar)), len(df2.get(ActiveCar))
self.assertTrue(len(df1.get(ActiveCar)) == len(df2.get(ActiveCar)))
def test_dataframe_apply_projections_cache(self):
Car, CarForPedestrian, cars = CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df_cache = ApplicationQueue("cache", [CarForPedestrian], df)
df.apply_changes(update_json10)
self.assertTrue(len(df.get(Car)) == 2)
self.assertTrue(len(df.get(CarForPedestrian)) == 2)
record = df_cache.get_record()
#print json.dumps(record, sort_keys = True, separators = (',', ': '), indent = 4)
self.assertTrue(record == resp_json10)
def test_dataframe_transfer_changes3(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df1 = dataframe()
df1.add_types([Car, ActiveCar, RedActiveCar])
df1.extend(Car, cars)
Car, ActiveCar, RedActiveCar, cars = create_cars()
df2 = dataframe()
df2.add_types([Car, ActiveCar, RedActiveCar])
df2.extend(Car, cars) # So they are not linked by reference.
#print len(df1.get(ActiveCar)), len(df2.get(ActiveCar))
df1.start_recording = True
for c in df1.get(Car):
c.velocity += 1
self.assertFalse(len(df1.get(ActiveCar)) == len(df2.get(ActiveCar)))
#print len(df1.get(ActiveCar)), len(df2.get(ActiveCar))
x = df1.get_record()
df2.apply_changes(x)
#print len(df1.get(ActiveCar)), len(df2.get(ActiveCar))
self.assertTrue(len(df1.get(ActiveCar)) == len(df2.get(ActiveCar)))
def test_parameter_supplied(self):
Node, Edge, nodes, edges = _CreateNodesAndEdges()
InEdge, OutEdge = _CreateInAndOutEdgeTypes(Edge, Node)
df = dataframe()
df.add_types([Node, Edge, InEdge, OutEdge])
df.extend(Node, nodes)
df.extend(Edge, edges)
self.assertTrue((OutEdge.__realname__ in df.object_map) == False)
self.assertTrue((InEdge.__realname__ in df.object_map) == False)
self.assertTrue(len(df.get(OutEdge, (nodes[0],))) == 3)
self.assertTrue(isinstance(df.get(OutEdge, (nodes[0],))[0], OutEdge))
self.assertTrue(len(df.get(InEdge, (nodes[0],))) == 0)
def test_dataframe_apply_mod2(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
self.assertTrue(len(df.get(Car)) == 5)
self.assertTrue(len(df.get(ActiveCar)) == 3)
self.assertTrue(len(df.get(RedActiveCar)) == 2)
df.apply_all(update_json3)
self.assertTrue(len(df.get(Car)) == 5)
self.assertTrue(len(df.get(ActiveCar)) == 4)
self.assertTrue(len(df.get(RedActiveCar)) == 3)
def test_dataframe_apply_serialize_all(self):
Car, CarForPedestrian, cars = CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df.extend(Car, cars)
serialized = df.serialize_all()
self.assertTrue(len(serialized["gc"]) == 1)
self.assertTrue("Car" in serialized["gc"])
self.assertTrue(len(serialized["gc"]["Car"]) == 2)
for oid, obj_c in serialized["gc"]["Car"].items():
self.assertTrue(len(obj_c["dims"]) == 4)
self.assertTrue(len(obj_c["types"]) == 2)
def test_dataframe_apply_mod2(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
self.assertTrue(len(df.get(Car)) == 5)
self.assertTrue(len(df.get(ActiveCar)) == 3)
self.assertTrue(len(df.get(RedActiveCar)) == 2)
df.apply_changes(update_json3)
self.assertTrue(len(df.get(Car)) == 5)
self.assertTrue(len(df.get(ActiveCar)) == 4)
self.assertTrue(len(df.get(RedActiveCar)) == 3)
def test_dataframe_apply_serialize_all(self):
Car, CarForPedestrian, cars = CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df.extend(Car, cars)
serialized = df.serialize_all()
self.assertTrue(len(serialized["gc"]) == 1)
self.assertTrue("Car" in serialized["gc"])
self.assertTrue(len(serialized["gc"]["Car"]) == 2)
for oid, obj_c in serialized["gc"]["Car"].items():
self.assertTrue(len(obj_c["dims"]) == 4)
self.assertTrue(len(obj_c["types"]) == 2)
def test_projection_get(self):
Car, CarForPedestrian, cars = _CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df.extend(Car, cars)
self.assertTrue(len(df.object_map[CarForPedestrian.__realname__]) == 2)
cars_p = df.get(CarForPedestrian)
self.assertTrue(len(cars_p) == 2)
for c in cars_p:
self.assertTrue(hasattr(c, "location"))
self.assertTrue(hasattr(c, "velocity"))
self.assertTrue(hasattr(c, "oid"))
self.assertFalse(hasattr(c, "owner"))
def test_dataframe_apply_get_mod(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
df.apply_all(update_json2)
self.assertTrue(len(df.get_new(Car)) == 0)
self.assertTrue(len(df.get_mod(Car)) == 1)
self.assertTrue(len(df.get_deleted(Car)) == 0)
self.assertTrue(len(df.get_new(ActiveCar)) == 0)
self.assertTrue(len(df.get_new(RedActiveCar)) == 0)
self.assertTrue(len(df.get_mod(RedActiveCar)) == 0)
self.assertTrue(len(df.get_deleted(RedActiveCar)) == 0)
def test_dataframe_apply_get_mod(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
df.apply_changes(update_json2)
self.assertTrue(len(df.get_new(Car)) == 0)
self.assertTrue(len(df.get_mod(Car)) == 1)
self.assertTrue(len(df.get_deleted(Car)) == 0)
self.assertTrue(len(df.get_new(ActiveCar)) == 0)
self.assertTrue(len(df.get_new(RedActiveCar)) == 0)
self.assertTrue(len(df.get_mod(RedActiveCar)) == 0)
self.assertTrue(len(df.get_deleted(RedActiveCar)) == 0)
def test_pure_subset_get(self):
Transaction, HighValueTransaction, ts = _subset_classes()
df = dataframe()
df.add_types([Transaction, HighValueTransaction])
df.extend(Transaction, ts)
self.assertTrue(len(df.object_map[HighValueTransaction.__realname__]) == 1)
hvts = df.get(HighValueTransaction)
self.assertTrue(len(hvts) == 1)
for hvt in hvts:
hvt.flag()
self.assertTrue(len(df.get(Transaction)) == 3)
self.assertTrue([t.suspicious for t in df.get(Transaction)].count(False) == 2)
self.assertTrue([t.suspicious for t in df.get(Transaction)].count(True) == 1)
def test_distinct_subset_get(self):
BaseClass, DistinctSubset, bc_objs = _CreateSubsetWithDistinct()
df = dataframe()
df.add_types([BaseClass, DistinctSubset])
df.extend(BaseClass, bc_objs)
distinct_subs = df.get(DistinctSubset)
self.assertTrue(len(distinct_subs) == 2)
flag = True
seen = set()
for d in distinct_subs:
if d.prop2 in seen:
flag = False
else:
seen.add(d.prop2)
self.assertTrue(flag)
def test_distinct_subset_get(self):
BaseClass, DistinctSubset, bc_objs = _CreateSubsetWithDistinct()
df = dataframe()
df.add_types([BaseClass, DistinctSubset])
df.extend(BaseClass, bc_objs)
distinct_subs = df.get(DistinctSubset)
self.assertTrue(len(distinct_subs) == 2)
flag = True
seen = set()
for d in distinct_subs:
if d.prop2 in seen:
flag = False
else:
seen.add(d.prop2)
self.assertTrue(flag)
def test_projection_get(self):
Car, CarForPedestrian, cars = _CreateProjectionTypesAndObjects()
df = dataframe()
df.add_types([Car, CarForPedestrian])
df.extend(Car, cars)
self.assertTrue(
len(df.object_manager.object_map[CarForPedestrian.__realname__]) ==
2)
cars_p = df.get(CarForPedestrian)
self.assertTrue(len(cars_p) == 2)
for c in cars_p:
self.assertTrue(hasattr(c, "location"))
self.assertTrue(hasattr(c, "velocity"))
self.assertTrue(hasattr(c, "oid"))
self.assertFalse(hasattr(c, "owner"))
def test_parameter_supplied(self):
Node, Edge, nodes, edges = _CreateNodesAndEdges()
InEdge, OutEdge = _CreateInAndOutEdgeTypes(Edge, Node)
df = dataframe()
df.add_types([Node, Edge, InEdge, OutEdge])
df.extend(Node, nodes)
df.extend(Edge, edges)
self.assertTrue(
len(df.object_manager.object_map[OutEdge.__realname__]) == 0)
self.assertTrue(
len(df.object_manager.object_map[InEdge.__realname__]) == 0)
self.assertTrue(len(df.get(OutEdge, parameters=(nodes[0], ))) == 3)
self.assertTrue(
isinstance(df.get(OutEdge, parameters=(nodes[0], ))[0], OutEdge))
self.assertTrue(len(df.get(InEdge, parameters=(nodes[0], ))) == 0)
def test_join_get(self):
Person, Card, Transaction, RedAlert, persons, cards, transactions = _join_example_data()
df = dataframe()
df.add_types([Person, Card, Transaction, RedAlert])
df.extend(Person, persons)
df.extend(Card, cards)
df.extend(Transaction, transactions)
self.assertTrue((RedAlert.__realname__ in df.object_map) == False)
self.assertTrue(len(df.get(RedAlert)) == 2)
for ra in df.get(RedAlert):
ra.Protect()
self.assertTrue(transactions[2].flagged == True)
self.assertTrue(transactions[0].flagged == False)
self.assertTrue(cards[0].holdstate == True)
self.assertTrue(cards[1].holdstate == False)
def test_dataframe_apply_no_base(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([ActiveCar, RedActiveCar])
df.apply_changes(update_json4)
self.assertTrue(len(df.get(ActiveCar)) == 1)
self.assertTrue(len(df.get(RedActiveCar)) == 1)
rac = df.get(RedActiveCar)[0]
rac.velocity = 5
ac = df.get(ActiveCar)[0]
self.assertTrue(ac.velocity == 5)
try:
print df.get(Car)
self.fail()
except TypeError:
self.assertTrue(True)
def test_dataframe_apply_no_base(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([ActiveCar, RedActiveCar])
df.apply_all(update_json4)
self.assertTrue(len(df.get(ActiveCar)) == 1)
self.assertTrue(len(df.get(RedActiveCar)) == 1)
rac = df.get(RedActiveCar)[0]
rac.velocity = 5
ac = df.get(ActiveCar)[0]
self.assertTrue(ac.velocity == 5)
try:
df.get(Car)
self.fail()
except TypeError:
self.assertTrue(True)
def test_dataframe_get_join(self):
Person, Card, Transaction, RedAlert, people, cards, trans = _join_example_data()
df = dataframe()
df.add_types([Person, Card, Transaction, RedAlert])
df.extend(Person, people)
df.extend(Card, cards)
df.extend(Transaction, trans)
df.start_recording = True
df_c = dataframe_client()
df_c.add_types([Person, Card, Transaction, RedAlert])
df_c.extend(Person, people)
df_c.extend(Card, cards)
df_c.extend(Transaction, trans)
df_c.apply_changes(df.get_record())
self.assertTrue(len(df_c.get(RedAlert)) == 0)
self.assertTrue(len(df.get(RedAlert)) == 1)
def test_join_get(self):
Person, Card, Transaction, RedAlert, persons, cards, transactions = _join_example_data(
)
df = dataframe()
df.add_types([Person, Card, Transaction, RedAlert])
df.extend(Person, persons)
df.extend(Card, cards)
df.extend(Transaction, transactions)
self.assertTrue(
len(df.object_manager.object_map[RedAlert.__realname__]) == 0)
self.assertTrue(len(df.get(RedAlert)) == 2)
for ra in df.get(RedAlert):
ra.Protect()
self.assertTrue(transactions[2].flagged == True)
self.assertTrue(transactions[0].flagged == False)
self.assertTrue(cards[0].holdstate == True)
self.assertTrue(cards[1].holdstate == False)
def test_multi_level_subset_get(self):
@pcc_set
class Car(object):
@primarykey(str)
def oid(self): return self._id
@oid.setter
def oid(self, value): self._id = value
@dimension(int)
def velocity(self): return self._velocity
@velocity.setter
def velocity(self, value): self._velocity = value
@dimension(str)
def color(self): return self._color
@color.setter
def color(self, value): self._color = value
def __init__(self, vel, col):
self.velocity = vel
self.color = col
@subset(Car)
class ActiveCar(Car):
@staticmethod
def __predicate__(c):
return c.velocity != 0
@subset(ActiveCar)
class RedActiveCar(Car):
@staticmethod
def __predicate__(ac):
return ac.color == "RED"
cars = [Car(0, "BLUE"), Car(0, "RED"), Car(1, "GREEN"), Car(1, "RED"), Car(2, "RED")]
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
self.assertTrue(len(df.get(RedActiveCar)) == 2)
self.assertTrue(len(df.get(ActiveCar)) == 3)
df.get(RedActiveCar)[0].velocity = 0
self.assertTrue(len(df.get(RedActiveCar)) == 1)
self.assertTrue(len(df.get(ActiveCar)) == 2)
def test_pure_subset_get(self):
Transaction, HighValueTransaction, ts = _subset_classes()
df = dataframe()
df.add_types([Transaction, HighValueTransaction])
df.extend(Transaction, ts)
self.assertTrue(
len(df.object_manager.object_map[
HighValueTransaction.__realname__]) == 1)
hvts = df.get(HighValueTransaction)
self.assertTrue(len(hvts) == 1)
for hvt in hvts:
hvt.flag()
self.assertTrue(len(df.get(Transaction)) == 3)
self.assertTrue([t.suspicious
for t in df.get(Transaction)].count(False) == 2)
self.assertTrue([t.suspicious
for t in df.get(Transaction)].count(True) == 1)
def __init__(self,
address="http://127.0.0.1:12000/",
time_step=500,
instrument=False,
profiling=False,
wire_format="cbor",
compress=False):
frame.framelist.add(self)
self.thread = None
self.__app = None
self.__appname = ""
self.__host_typemap = {}
self.__host_wire_format = {}
self.__typemap = {}
self.__name2type = {}
self.object_store = dataframe(mode=DataframeModes.Client)
self.object_store.start_recording = True
if not address.endswith('/'):
address += '/'
self.__address = address
self.__default_wire_format = wire_format
self.__compress = compress
self.__time_step = (float(time_step) / 1000)
self.__new = {}
self.__mod = {}
self.__del = {}
self.__observed_types = set()
self.__observed_types_new = set()
self.__observed_types_mod = set()
self.__curtime = time.time()
self.__curstep = 0
self.__start_time = time.strftime("%Y-%m-%d_%H-%M-%S")
self.__instrumented = instrument
self.__profiling = profiling
self.__sessions = {}
self.__host_to_push_groupkey = {}
if instrument:
self._instruments = {}
self._instrument_headers = []
self._instrument_headers.append('bytes sent')
self._instrument_headers.append('bytes received')
def test_cyclic_reference_serialize(self):
class B(object):
def __init__(self, c):
self.c = c
class C(object):
def __init__(self):
self.b = None
@pcc_set
class A(object):
@primarykey(str)
def ID(self):
return self._id
@ID.setter
def ID(self, v):
self._id = v
@dimension(B)
def b(self):
return self._b
@b.setter
def b(self, v):
self._b = v
def __init__(self):
self.ID = "hi"
a = A()
c = C()
b = B(c)
c.b = b
a.b = b
df = dataframe()
df.add_type(A)
df.start_recording = True
with self.assertRaises(RuntimeError) as assR:
df.append(A, a)
def test_dataframe_get_changes1(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
df.start_recording = True
for c in df.get(RedActiveCar):
c.velocity = 0
#print json.dumps(df.get_record(), sort_keys = True, separators = (',', ': '), indent = 4)
self.assertTrue(df.get_record() == convert_json_to_proto({
"Car" :{
"id4" :{
"dims" :{
"velocity" :{
"type" :1,
"value" :0
}
},
"types" :{
"ActiveCar" :0,
"Car" :2,
"RedActiveCar" :0
}
},
"id5" :{
"dims" :{
"velocity" :{
"type" :1,
"value" :0
}
},
"types" :{
"ActiveCar" :0,
"Car" :2,
"RedActiveCar" :0
}
}
}
}))
def test_dataframe_get_changes1(self):
Car, ActiveCar, RedActiveCar, cars = create_cars()
df = dataframe()
df.add_types([Car, ActiveCar, RedActiveCar])
df.extend(Car, cars)
df.start_recording = True
for c in df.get(RedActiveCar):
c.velocity = 0
#print json.dumps(df.get_record(), sort_keys = True, separators = (',', ': '), indent = 4)
self.assertTrue(df.get_record() == convert_json_to_proto({
"Car" :{
"id4" :{
"dims" :{
"velocity" :{
"type" :1,
"value" :0
}
},
"types" :{
"ActiveCar" :0,
"Car" :2,
"RedActiveCar" :0
}
},
"id5" :{
"dims" :{
"velocity" :{
"type" :1,
"value" :0
}
},
"types" :{
"ActiveCar" :0,
"Car" :2,
"RedActiveCar" :0
}
}
}
}))
def register_app(self, app, type_map, wire_format = "json"):
self.__pause()
df = dataframe(mode=DataframeModes.ApplicationCache)
df.start_recording = True
types_to_get = set()
for mode in FETCHING_MODES:
types_to_get.update(set(type_map.setdefault(mode, set())))
types_to_track = set()
for mode in TRACKING_MODES:
types_to_track.update(set(type_map.setdefault(mode, set())))
types_to_track = types_to_track.difference(types_to_get)
real_types_to_get = [self.name2class[tpstr] for tpstr in types_to_get]
real_types_to_track = [self.name2class[tpstr] for tpstr in types_to_track]
df.add_types(real_types_to_get)
self.master_dataframe.add_types(real_types_to_get)
df.add_types(real_types_to_track, tracking = True)
self.master_dataframe.add_types(real_types_to_track, tracking = True)
self.add_new_dataframe(app, df)
# Add all types to master.
types_to_add_to_master = set()
for mode in ALL_MODES:
types_to_add_to_master.update(set(type_map.setdefault(mode, set())))
self.master_dataframe.add_types([self.name2class[tpstr] for tpstr in types_to_add_to_master])
self.app_wire_format[app] = wire_format
def __init__(self, name2class):
self.master_dataframe = dataframe()
self.app_to_df = {}
self.name2class = name2class
self.pause_servers = False
self.app_wire_format = {}
def test_aggregate_dimension(self):
@pcc_set
class Car(object):
@primarykey(str)
def oid(self):
return self._id
@oid.setter
def oid(self, value):
self._id = value
@dimension(int)
def velocity(self):
return self._velocity
@velocity.setter
def velocity(self, value):
self._velocity = value
@dimension(str)
def color(self):
return self._color
@color.setter
def color(self, value):
self._color = value
def __init__(self, vel, col):
self.velocity = vel
self.color = col
@subset(Car)
class ActiveCarCountByColor(object):
__group_by__ = Car.color
@count(Car.oid)
def total_count(self):
return self._tc
@total_count.setter
def total_count(self, v):
self._tc = v
@staticmethod
def __predicate__(c):
return c.velocity != 0
cars = [
Car(0, "RED"),
Car(1, "RED"),
Car(2, "RED"),
Car(2, "BLUE"),
Car(0, "BLUE")
]
df = dataframe()
df.add_types([Car, ActiveCarCountByColor])
df.extend(Car, cars)
car_by_count = df.get(ActiveCarCountByColor)
self.assertTrue(len(car_by_count) == 2)
for c in car_by_count:
if c.__group_by__ == "RED":
self.assertTrue(c.total_count == 2)
if c.__group_by__ == "BLUE":
self.assertTrue(c.total_count == 1)
