encode node, edge and path objects

Author: swilly22

code_graph/entities/__init__.py

@@ -1,10 +1,9 @@
 # __init__.py
 
-__all__ = ['File', 'Function', 'Argument', 'Class', 'Struct']
-
 from .file import File
 from .cls import Class
 from .struct import Struct
 from .function import Function
 from .argument import Argument
+from .entity_encoder import *
 

code_graph/entities/entity_encoder.py

@@ -0,0 +1,25 @@
+from falkordb import Node, Edge, Path
+
+def encode_node(n: Node) -> dict:
+    n.labels.remove('Searchable')
+    return vars(n)
+
+def encode_edge(e: Edge) -> dict:
+    return vars(e)
+
+def encode_path(p: Path) -> dict:
+    return {
+            'nodes': [encode_node(n) for n in p.nodes()],
+            'edges': [encode_edge(e) for e in p.edges()]
+            }
+
+def encode_graph_entity(e) -> dict:
+    if isinstance(e, Node):
+        return encode_node(e)
+    elif isinstance(e, Edge):
+        return encode_edge(e)
+    elif isinstance(e, Path):
+        return encode_path(e)
+    else:
+        raise Exception("Unable to encode graph entity, unknown graph entity type: {type(e)}")
+

code_graph/graph.py

@@ -1,7 +1,7 @@
 import time
 from .entities import *
 from typing import List, Optional
-from falkordb import FalkorDB, Node, QueryResult
+from falkordb import FalkorDB, Path, Node, QueryResult
 
 FALKORDB_HOST     = "localhost"
 FALKORDB_PORT     = 6379
@@ -86,6 +86,29 @@ def delete(self) -> None:
         self.g.delete()
 
 
+    def get_sub_graph(self, l: int) -> dict:
+
+        q = """MATCH (src)
+                   OPTIONAL MATCH (src)-[e]->(dest)
+                   RETURN src, e, dest
+                   LIMIT $limit"""
+
+        sub_graph = {'nodes': [], 'edges': [] }
+
+        result_set = self.g.query(q, {'limit': l}).result_set
+        for row in result_set:
+            src  = row[0]
+            e    = row[1]
+            dest = row[2]
+
+            sub_graph['nodes'].append(encode_node(src))
+
+            if e is not None:
+                sub_graph['edges'].append(encode_edge(e))
+                sub_graph['nodes'].append(encode_node(dest))
+
+        return sub_graph
+
     def add_class(self, c: Class) -> None:
         """
         Adds a class node to the graph database.
@@ -554,3 +577,38 @@ def rerun_query(self, q: str, params: dict) -> QueryResult:
 
         return self.g.query(q, params)
 
+    def find_paths(self, src: int, dest: int) -> List[Path]:
+        """
+        Find all paths between the source (src) and destination (dest) nodes.
+
+        Args:
+            src (int): The ID of the source node.
+            dest (int): The ID of the destination node.
+
+        Returns:
+            List[Optional[Path]]: A list of paths found between the src and dest nodes.
+            Returns an empty list if no paths are found.
+
+        Raises:
+            Exception: If the query fails or the graph database returns an error.
+        """
+
+        # Define the query to match paths between src and dest nodes.
+        q = """MATCH (src), (dest)
+               WHERE ID(src) = $src_id AND ID(dest) = $dest_id
+               WITH src, dest
+               MATCH p = (src)-[:CALLS*]->(dest)
+               RETURN p
+           """
+
+        # Perform the query with the source and destination node IDs.
+        result_set = self.g.query(q, {'src_id': src, 'dest_id': dest}).result_set
+
+        paths = []
+
+        # Extract paths from the query result set.
+        for row in result_set:
+            paths.append(row[0])
+
+        return paths
+

main.py

@@ -34,42 +34,15 @@ def extract_org_name_from_url(url: str) -> Optional[tuple[str, str]]:
 
 @app.route('/graph_entities', methods=['GET'])
 def graph_entities():
-    # Access the 'graph_id' parameter from the GET request
-    graph_id = request.args.get('graph_id')
-
-    # Connect to FalkorDB
-    db = FalkorDB(host=FALKORDB_HOST, port=FALKORDB_PORT,
-                  username=FALKORDB_USERNAME, password=FALKORDB_PASSWORD)
+    # Access the 'repo' parameter from the GET request
+    repo = request.args.get('repo')
 
-    # Select graph
-    g = db.select_graph(graph_id)
-
-    query = """MATCH (src)
-               OPTIONAL MATCH (src)-[e]->(dest)
-               RETURN src, e, dest
-               LIMIT 100"""
-
-    data = []
-    res = g.query(query).result_set
-    for row in res:
-        src  = row[0]
-        e    = row[1]
-        dest = row[2]
-
-        data.append({'data': {'id': src.id,
-                              'label': src.labels[0]} })
-
-        if e is not None:
-            data.append({'data': {'id': dest.id,
-                                  'label': dest.labels[0]} })
-            data.append({'data': {'source': src.id, 'target': dest.id, 'relation': e.relation} })
+    g = Graph(repo, host=FALKORDB_HOST, port=FALKORDB_PORT,
+                 username=FALKORDB_USERNAME, password=FALKORDB_PASSWORD)
 
-    # [
-    #   { data: { id: 'e' } },
-    #   { data: { source: 'a', target: 'b' } }
-    # ]
+    sub_graph = g.get_sub_graph(100)
 
-    return jsonify(data), 200
+    return jsonify(sub_graph), 200
 
 @app.route('/get_neighbors', methods=['GET'])
 def get_neighbors():
@@ -325,6 +298,41 @@ def process_list_commits():
 
     return jsonify(response), 200
 
+@app.route('/find_paths', methods=['POST'])
+def find_paths():
+    # Get JSON data from the request
+    data = request.get_json()
+
+    # name of repository
+    repo = data.get('repo')
+    if repo is None:
+        return jsonify({'status': f'Missing mandatory parameter "repo"'}), 400
+
+    # source ID
+    src = data.get('src')
+    if src is None:
+        return jsonify({'status': f'Missing mandatory parameter "src"'}), 400
+
+    # dest ID
+    dest = data.get('dest')
+    if dest is None:
+        return jsonify({'status': f'Missing mandatory parameter "dest"'}), 400
+
+    # Get JSON data from the request
+    g = Graph(repo, host=FALKORDB_HOST, port=FALKORDB_PORT,
+                 username=FALKORDB_USERNAME, password=FALKORDB_PASSWORD)
+
+    paths = g.find_paths(src, dest)
+
+    # Create a response
+    response = {
+        'status': 'success',
+        'paths': paths
+    }
+
+    return jsonify(response), 200
+
+
 if __name__ == '__main__':
     app.run(debug=True)