class RedisModelGraph(Graph):
def __init__(self, name, redis_conn):
super().__init__(name, redis_conn)
self.class_manager = ClassManager(self)
def add_model(self, model: BaseModel):
self.class_manager.model_to_db_object(model, auto_add=True)
def add_node_model(self, node_model: NodeModel):
self.class_manager.model_to_node(node_model, auto_add=True)
def add_edge_model(self, edge_model: EdgeModel):
"""
Addes an edge to the graph.
"""
# Make sure edge both ends are in the graph
self.class_manager.model_to_edge(edge_model, auto_add=True)
def match_node(self, node_model: NodeModel):
if not node_model.get_alias():
node_model._alias = 'a'
result = self.model_query(
f"""Match {str(node_model)} return {node_model.get_alias()}""")
return [row[0] for row in result.result_set]
def match_edge(self, edge_model: EdgeModel):
if not edge_model.get_alias():
edge_model._alias = 'a'
result = self.model_query(
f"""Match {str(edge_model)} return {edge_model.get_alias()}""")
return [row[0] for row in result.result_set]
def model_query(self, q, params=None):
result = self.query(q, params)
model_result_set = []
for row in result.result_set:
model_row = []
for element in row:
try:
model_row.append(
self.class_manager.db_object_to_model(element))
except RuntimeError:
model_row.append(element)
model_result_set.append(model_row)
result.result_set = model_result_set
return result
def get_class(self, class_name):
return self.class_manager.get(class_name)
def insert_defined_class(self, defined_class, upload=True):
return self.class_manager.insert_defined_class(defined_class,
upload=upload)
def delete_defined_class(self, class_name, sync=True):
return self.class_manager.delete(class_name, sync=sync)
def test_delete_class(self):
redis_graph = redisgraph.Graph('delete_class', self.r)
manager = ClassManager(redis_graph)
manager.insert_defined_class(definition_forms.test_a_definition_forms)
manager.delete([raw_definition.__name__ for raw_definition in definition_forms.test_a_definition_forms])
result = redis_graph.query("""Match (a:ClassDefinitionWrapper) return count(a) as cnt""")
self.assertEqual(result.result_set[0][0], 0)
redis_graph.delete()
def test_upload_embedded_list_to_redis_graph(self):
redis_graph = redisgraph.Graph('embedded_list', self.r)
manager = ClassManager(redis_graph)
manager.insert_defined_class(definition_forms.ExceptionNodeB)
T = manager.get("ExceptionNodeB")
a = T(a=100, b=[123, "abc", [[99, True], []]])
manager.model_to_node(a, auto_add=True)
redis_graph.flush()
res = redis_graph.query("match (a:ExceptionNodeB) return a")
a = res.result_set[0][0]
print(a)
redis_graph.delete()
def test_duplicate_upload_class(self):
redis_graph = redisgraph.Graph('duplicate_upload_class', self.r)
manager = ClassManager(redis_graph)
manager.insert_defined_class(definition_forms.test_a_definition_forms)
manager.insert_defined_class(definition_forms.test_a_definition_forms)
manager.insert_defined_class(definition_forms.test_a_definition_forms)
result = redis_graph.query("""Match (a:ClassDefinitionWrapper) return count(a) as cnt""")
self.assertEqual(result.result_set[0][0], len(definition_forms.test_a_definition_forms))
redis_graph.delete()
class BaseModelGraph(Graph):
def __init__(self, name):
super().__init__(name)
self.class_manager = ClassManager(self)
def add_node(self, model: NodeModel):
self.class_manager.model_to_node(model, auto_add=True)
def add_edge(self, model: EdgeModel):
"""
Addes an edge to the graph.
"""
# Make sure edge both ends are in the graph
self.class_manager.model_to_edge(model, auto_add=True)
def get_class(self, class_name):
return self.class_manager.get(class_name)
def insert_defined_class(self, raw_definitions, upload=True):
return self.class_manager.insert_defined_class(raw_definitions,
upload=upload)
def delete_defined_class(self, class_names, sync=True):
return self.class_manager.delete(class_names, sync=sync)
def __init__(self, name):
super().__init__(name)
self.class_manager = ClassManager(self)
def test_on_redis_graph(self):
redis_graph = redisgraph.Graph('school', self.r)
old_manager = ClassManager(redis_graph)
old_manager.insert_defined_class(definition_forms.test_a_definition_forms)
# get all the classes
IntlStudent = old_manager.get("IntlStudent")
Teacher = old_manager.get("Teacher")
Teach = old_manager.get("Teach")
print(Teacher.code)
self.assertEqual(Teacher.code[0][2], 'a')
self.assertEqual(Teacher.code[1]['banana'], 123)
john = IntlStudent(name="John", age=23, school="Columbia", country="No country")
kate = Teacher(name="Kate", age=18, subject="Computer Science")
teach = Teach(in_node=kate, out_node=john)
old_manager.model_to_node(john, auto_add=True)
old_manager.model_to_node(kate, auto_add=True)
old_manager.model_to_edge(teach, auto_add=True)
redis_graph.flush()
r = redis.Redis(host='localhost', port=6379, decode_responses=True)
redis_graph = redisgraph.Graph('school', r)
manager = ClassManager(redis_graph)
results = redis_graph.query("""Match (p) return p""")
nodes = [row[0] for row in results.result_set]
models = [manager.node_to_model(node) for node in nodes]
for model in models:
print(model)
results = redis_graph.query("""Match ()-[a]->() return a""")
edges = [row[0] for row in results.result_set]
models = [manager.edge_to_model(edge) for edge in edges]
for model in models:
print(model)
redis_graph.delete()
def test_basic_b(self):
graph = base_element.Graph("test")
old_manager = ClassManager(graph)
old_manager.insert_defined_class(definition_forms.test_b_definition_forms)
manager = ClassManager(graph)
Circuit = manager.get('Circuit')
FruitFly = manager.get('FruitFly')
Own = manager.get('Own')
fly = FruitFly(id="No. 1", sex='male', age=3, location='Mars', lived=True)
c = Circuit(name='circuit-1')
own = Own(in_node=fly, out_node=c)
print(fly)
print(own)
print(c)
n = manager.model_to_node(fly)
print(n)
fly = manager.node_to_model(n)
print(fly)
n = manager.model_to_node(c)
print(n)
c = manager.node_to_model(n)
print(c)
e = manager.model_to_edge(own)
print(e)
own = manager.edge_to_model(e)
print(own)
def __init__(self, name, redis_conn):
super().__init__(name, redis_conn)
self.class_manager = ClassManager(self)
def __init__(self, uri=None, **settings):
self.class_manager = ClassManager(self)
class Neo4jModelGraph(Graph):
def __init__(self, uri=None, **settings):
self.class_manager = ClassManager(self)
def create_model(self, model: BaseModel):
self.class_manager.model_to_db_object(model, auto_add=True)
def create_node_model(self, node_model: NodeModel):
self.class_manager.model_to_node(node_model, auto_add=True)
def create_edge_model(self, edge_model: EdgeModel):
"""
Addes an edge to the graph.
"""
# Make sure edge both ends are in the graph
self.class_manager.model_to_edge(edge_model, auto_add=True)
def merge_node_model(self, node_model: NodeModel):
node = self.class_manager.model_to_node(node_model)
self.run(f"MERGE {node_model}")
return node
def merge_edge_model(self, edge_model: EdgeModel):
"""
Addes an edge to the graph.
"""
# Make sure edge both ends are in the graph
edge = self.class_manager.model_to_edge(edge_model)
in_node = edge_model.get_in_node()
in_node.set_alias(None)
out_node = edge_model.get_out_node()
out_node.set_alias(None)
edge_model.set_alias("edge_a")
self.run(f"MATCH {in_node}, {out_node} MERGE {edge_model}")
return edge
def match_node(self, node_model: NodeModel):
matcher = NodeMatcher(self).match(
type(node_model).__name__, **node_model.get_properties())
return list(matcher)
def match_edge(self, edge_model: EdgeModel):
if not edge_model.get_alias():
edge_model._alias = 'edge_a'
cursor = self.run(
f"""Match {str(edge_model)} return {edge_model.get_alias()}""")
return [record[0] for record in cursor]
def model_query(self, q, parameters=None, **kwparameters):
cursor = self.run(q, parameters=parameters, **kwparameters)
model_result_set = []
for record in cursor:
model_row = []
for element in record:
try:
model_row.append(
self.class_manager.db_object_to_model(element))
except RuntimeError:
model_row.append(element)
model_result_set.append(model_row)
return model_result_set
def get_class(self, class_name):
return self.class_manager.get(class_name)
def insert_defined_class(self, defined_class, upload=True):
return self.class_manager.insert_defined_class(defined_class,
upload=upload)
def delete_defined_class(self, class_name, sync=True):
return self.class_manager.delete(class_name, sync=sync)