improve docs and delete file query

Author: swilly22

code_graph/git_utils/git_graph.py

@@ -94,7 +94,7 @@ def set_child_transition(self, child: str, parent: str, queries: List[tuple[str:
         self.g.query(q, params)
 
 
-    def get_parent_transition(self, child: str, parent: str) -> List[tuple[str: dict]]:
+    def get_parent_transitions(self, child: str, parent: str) -> List[tuple[str: dict]]:
         """
             Get queries and parameters transitioning from child commit to parent commit
         """
@@ -112,9 +112,9 @@ def get_parent_transition(self, child: str, parent: str) -> List[tuple[str: dict
         return (res[0][0], res[0][1])
 
 
-    def get_child_transition(self, child: str, parent: str) -> List[tuple[str: dict]]:
+    def get_child_transitions(self, child: str, parent: str) -> List[tuple[str: dict]]:
         """
-            Get queries transitioning from parent to child
+            Get queries and parameters transitioning from parent commit to child commit
         """
         q = """MATCH path = (:Commit {hash: $parent_hash})-[:CHILD*]->(:Commit {hash: $child_hash})
                WITH path

code_graph/git_utils/git_utils.py

@@ -2,17 +2,24 @@
 import time
 import json
 import redis
+import logging
 import threading
 import subprocess
 from git import Repo
 from ..graph import Graph
 from .git_graph import GitGraph
 from typing import List, Optional
 
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
 monitor_thread = None
 replica_process = None
 monitor_exit_event = threading.Event()
 
+def GitRepoName(repo_name):
+    return "{" + repo_name + "}_git"
+
 # setup replication to the master
 def setup_replication():
     global replica_process
@@ -108,8 +115,10 @@ def build_commit_graph(path: str, ignore_list: Optional[List[str]] = []) -> GitG
     repo = Repo(path)
 
     repo_name = os.path.split(os.path.normpath(path))[-1]
-    g =         Graph(repo_name)
-    git_graph = GitGraph('{' + repo_name + '}' + '_git')
+
+    # Clone graph into a temporary graph
+    g =         Graph(repo_name).clone(repo_name + "_tmp")
+    git_graph = GitGraph(GitRepoName(repo_name))
 
     #setup_replication()
 
@@ -194,46 +203,111 @@ def build_commit_graph(path: str, ignore_list: Optional[List[str]] = []) -> GitG
     #stop_monitor_effects()
     #teardown_replica()
 
-    return git_graph
+    # Delete temporaty graph
+    g.delete()
 
-def switch_commit(repo: str, to: str):
-    """switch graph state from its current commit to given commit"""
+    return git_graph
 
+def switch_commit(repo: str, to: str) -> dict[str, dict[str, list]]:
+    """
+    Switches the state of a graph repository from its current commit to the given commit.
+
+    This function handles switching between two git commits for a graph-based repository.
+    It identifies the changes (additions, deletions, modifications) in nodes and edges between
+    the current commit and the target commit and then applies the necessary transitions.
+
+    Args:
+        repo (str): The name of the graph repository to switch commits.
+        to (str): The target commit hash to switch the graph to.
+
+    Returns:
+        dict: A dictionary containing the changes made during the commit switch, organized by:
+            - 'deletions': {
+                'nodes': List of node IDs deleted,
+                'edges': List of edge IDs deleted
+            },
+            - 'additions': {
+                'nodes': List of new Node objects added,
+                'edges': List of new Edge objects added
+            },
+            - 'modifications': {
+                'nodes': List of modified Node objects,
+                'edges': List of modified Edge objects
+            }
+    """
+
+    # Validate input arguments
+    if not repo or not isinstance(repo, str):
+        raise ValueError("Invalid repository name")
+
+    if not to or not isinstance(to, str):
+        raise ValueError("Invalid desired commit value")
+
+    # Initialize return value to an empty change set
+    change_set = {
+        'deletions': {
+            'nodes': [],
+            'edges': []
+        },
+        'additions': {
+            'nodes': [],
+            'edges': [],
+        },
+        'modifications': {
+            'nodes': [],
+            'edges': []
+        }
+    }
+
+    # Initialize the graph and GitGraph objects
     g = Graph(repo)
-    git_graph = GitGraph('{' + repo + '}' + 'git')
+    git_graph = GitGraph(GitRepoName(repo))
 
-    # Get the graph's current commit
+    # Get the current commit hash of the graph
     current_hash = g.get_graph_commit()
+    logging.info(f"Current graph commit: {current_hash}")
 
-    # Find path from current commit to desired commit
+    if current_hash == to:
+        # No change remain at the current commit
+        return change_set
+
+    # Find the path between the current commit and the desired commit
     commits = git_graph.get_commits([current_hash, to])
 
+    # Ensure both current and target commits are present
     if len(commits) != 2:
-        print("missing commits")
-        return
+        logging.error("Missing commits. Unable to proceed.")
+        raise ValueError("Commits not found")
 
-    # determine relation between commits
-    current_commit = commits[0] if commits[0]['hash'] == current_hash else commits[1]
-    new_commit     = commits[0] if commits[0]['hash'] == to else commits[1]
+    # Identify the current and new commits based on their hashes
+    current_commit, new_commit = (commits if commits[0]['hash'] == current_hash else reversed(commits))
 
+    # Determine the direction of the switch (forward or backward in commit history)
     if current_commit['date'] > new_commit['date']:
-        print("moving backwared")
-        queries, params = git_graph.get_parent_transition(current_commit['hash'], new_commit['hash'])
+        logging.info(f"Moving backward from {current_commit['hash']} to {new_commit['hash']}")
+        # Get the transitions (queries and parameters) for moving backward
+        queries, params = git_graph.get_parent_transitions(current_commit['hash'], new_commit['hash'])
     else:
-        print("moving forwards")
-        queries, params = git_graph.get_child_transition(current_commit['hash'], new_commit['hash'])
-
-    # Apply transitions
-    for i in range(0, len(queries)):
-        q = queries[i]
-        p = json.loads(params[i])
-        print(f"query: {q}")
-        print(f"params: {p}")
-
-        g.rerun_query(q, p)
-
-    # update graph's commit
+        logging.info(f"Moving forward from {current_commit['hash']} to {new_commit['hash']}")
+        # Get the transitions (queries and parameters) for moving forward
+        queries, params = git_graph.get_child_transitions(current_commit['hash'], new_commit['hash'])
+
+    # Apply each transition query with its respective parameters
+    for q, p in zip(queries, params):
+        p = json.loads(p)
+        logging.debug(f"Executing query: {q} with params: {p}")
+
+        # Rerun the query with parameters on the graph
+        res = g.rerun_query(q, p)
+        if "DELETE" in q:
+            deleted_nodes = res.result_set[0][0]
+            change_set['deletions']['nodes'] += deleted_nodes
+
+    # Update the graph's commit to the new target commit
     g.set_graph_commit(to)
+    logging.info(f"Graph commit updated to {to}")
+
+    return change_set
 
 if __name__ == "__main__":
     build_commit_graph("/Users/roilipman/Dev/FalkorDB")

code_graph/graph.py

@@ -1,6 +1,7 @@
+import time
 from .entities import *
 from typing import List, Optional
-from falkordb import FalkorDB, Node
+from falkordb import FalkorDB, Node, QueryResult
 
 class Graph():
     """
@@ -11,6 +12,12 @@ def __init__(self, name: str, host: str = 'localhost', port: int = 6379,
                  username: Optional[str] = None, password: Optional[str] = None) -> None:
         self.db = FalkorDB(host=host, port=port, username=username,
                            password=password)
+
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+
         self.g = self.db.select_graph(name)
 
         # create indicies
@@ -27,6 +34,35 @@ def __init__(self, name: str, host: str = 'localhost', port: int = 6379,
         except Exception:
             pass
 
+    def clone(self, clone: str) -> "Graph":
+        """
+        Create a copy of the graph under the name clone
+
+        Returns:
+            a new instance of Graph
+        """
+
+        # Make sure key clone isn't already exists
+        if self.db.connection.exists(clone):
+            raise Exception(f"Can not create clone, key: {clone} already exists.")
+
+        self.g.copy(clone)
+
+        # Wait for the clone to become available
+        while not self.db.connection.exists(clone):
+            # TODO: add a waiting limit
+            time.sleep(1)
+
+        return Graph(clone, self.host, self.port, self.username, self.password)
+
+
+    def delete(self) -> None:
+        """
+        Delete graph
+        """
+        self.g.delete()
+
+
     def add_class(self, c: Class) -> None:
         """
         Adds a class node to the graph database.
@@ -240,7 +276,7 @@ def add_file(self, file: File) -> None:
         res = self.g.query(q, params)
         file.id = res.result_set[0][0]
 
-    def delete_files(self, files: List[dict], log: bool = False) -> tuple[str, dict]:
+    def delete_files(self, files: List[dict], log: bool = False) -> tuple[str, dict, List[int]]:
         """
         Deletes file(s) from the graph in addition to any other entity
         defined in the file
@@ -249,14 +285,16 @@ def delete_files(self, files: List[dict], log: bool = False) -> tuple[str, dict]
         files = [{'path':_, 'name': _, 'ext': _}, ...]
         """
 
-        q = """UNWIND $files as file
+        q = """UNWIND $files AS file
                MATCH (f:File {path: file['path'], name: file['name'], ext: file['ext']})
-               CALL {
-                   WITH f
-                   MATCH (f)-[:DEFINES]->(e)
-                   DELETE e
-               }
-               DELETE f
+               WITH collect(f) AS Fs
+               UNWIND Fs AS f
+               MATCH (f)-[:DEFINES]->(e)
+               WITH Fs, collect(e) AS Es
+               WITH Fs + Es AS entities
+               UNWIND entities AS e
+               DELETE e
+               RETURN collect(ID(e))
         """
 
         params = {'files': files}
@@ -440,9 +478,9 @@ def get_graph_commit(self) -> str:
         return self.db.connection.get('{' + self.g.name + '}' + '_commit')
 
 
-    def rerun_query(self, q: str, params: dict) -> None:
+    def rerun_query(self, q: str, params: dict) -> QueryResult:
         """
             Re-run a query to transition the graph from one state to another
         """
 
-        res = self.g.query(q, params)
+        return self.g.query(q, params)

main.py

@@ -287,11 +287,12 @@ def process_switch_commit():
     if commit is None:
         return jsonify({'status': f'Missing mandatory parameter "commit"'}), 400
 
-    switch_commit(repo, commit)
+    change_set = switch_commit(repo, commit)
 
     # Create a response
     response = {
         'status': 'success',
+        'change_set': change_set
     }
 
     return jsonify(response), 200