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)