Merge pull request #2 from dalager/deranged

Range expansions redefined

Author: dalager

Book1.xlsx

@@ -17,7 +17,29 @@ This is a simple tool and maybe even naïve in its approach - it was hacked toge
 
 Single-cell references in a formula sitting in cell `A3` like `=A1+A2` is considered a dependency between the node `A3` and the nodes `A2` and `A1`.
 
-A range defined in a formula like `=SUM(B1:B200)` is semantically handled like a single reference or node in the tree and not 200 individual nodes in the graph.
+```mermaid
+graph TD
+    A1 --> A3
+    A2 --> A3
+    A3["=A1 + A2"]
+```
+
+A range defined in a formula like `=SUM(B1:B3)` is kept as a single node in the graph, but all the containing cells are expanded as dependencies of the range node.
+
+So when a cell, `C1` contains `=SUM(B1:B3)` the graph will look like this:
+
+```mermaid
+
+graph TD
+    R -->B1
+    R -->B2
+    R -->B3
+    R["B1:B3"]
+    C1 --> R
+
+    C1["C1=SUM(B1:B3)"]
+
+```
 
 The way the graph is built is by iterating over all cells in the spreadsheet and extracting the references in the formula of each cell. The references are then added as edges in the graph.
 
@@ -40,6 +62,8 @@ python graphbuilder.py <path_to_excel_file> [--verbose] [--no-visualize] [--keep
 
 Depending on the size of the spreadsheet you might want to adjust the plot configuration in the code to to make the graph more readable (remove labels, decrease widths and sizes etc)
 
+In [graph_visualizer.py](graph_visualizer.py) you will find three configuration for small, medium and large graphs. You can adjust the configuration to your needs.
+
 ### Arguments
 
 `--verbose` will dump formula cell contents during (more quiet)

README.md

@@ -46,16 +46,18 @@ def extract_references(formula):
 
     expanded_references = []
     dependencies = {}
+    direct_references = []
+    range_references = []
 
     for ref in references:
         if ":" in ref:  # it's a range like A1:A3
             expanded_cells = expand_range(ref)
             expanded_references.extend(expanded_cells)
-
+            range_references.append(ref)
             # Store the range-to-cells relationship
             for cell in expanded_cells:
                 dependencies[cell] = ref
         else:  # single cell
-            expanded_references.append(ref)
+            direct_references.append(ref)
 
-    return expanded_references, dependencies
+    return direct_references, range_references, dependencies

excel_parser.py

@@ -7,8 +7,8 @@
 small_graph_settings = {
     "node_size": 50,
     "edge_color": "black",
-    "with_labels": True,
-    "font_size": 7,
+    "with_labels": False,
+    "font_size": 10,
     "linewidths": 0.8,
     "alpha": 0.8,
     "width": 0.2,

graph_visualizer.py

@@ -25,6 +25,24 @@ def log(msg):
         print(msg)
 
 
+def sanitize_sheetname(sheetname):
+    """
+    Remove any special characters from the sheet name.
+    """
+    return sheetname.replace("'", "")
+
+
+def sanitize_range(rangestring):
+    """
+    Remove any special characters from the range.
+    """
+    if "!" in rangestring:
+        sheet = rangestring.split("!")[0].replace("'", "")
+        range = rangestring.split("!")[1]
+
+    return f"{sheet}!{range}"
+
+
 def stat_functions(cellvalue):
     """
     Extract the functions used in the formula and store them in a dictionary.
@@ -43,6 +61,15 @@ def stat_functions(cellvalue):
             functions_dict[function] = 1
 
 
+def add_node(graph, node, sheet):
+    """
+    Add a node to the graph with the specified sheet name.
+    """
+    log(f"Adding node: {node} in sheet: {sheet}")
+    sheet = sanitize_sheetname(sheet)
+    graph.add_node(node, sheet=sheet)
+
+
 def extract_formulas_and_build_dependencies(file_path):
     """
     Extract formulas from an Excel file and build a dependency graph.
@@ -57,8 +84,8 @@ def extract_formulas_and_build_dependencies(file_path):
     # Iterate over all sheets
     for sheet_name in wb.sheetnames:
         ws = wb[sheet_name]
-        log(f"-- Analyzing sheet: {sheet_name} --")
-
+        log(f"========== Analyzing sheet: {sheet_name} ==========")
+        sheet_name = sanitize_sheetname(sheet_name)
         # Iterate over all cells in the sheet and extract formulas
         for row in ws.iter_rows():
             for cell in row:
@@ -67,30 +94,46 @@ def extract_formulas_and_build_dependencies(file_path):
                     # collect functions usage statistics
                     stat_functions(cell.value)
 
-                    cell_name = f"{sheet_name}!{cell.coordinate}"
-                    log(f"Formula in {cell_name}: {cell.value}")
+                    current_cell = f"{sheet_name}!{cell.coordinate}"
+                    log(f"Formula in {current_cell}: {cell.value}")
 
-                    graph.add_node(cell_name, sheet=sheet_name)
+                    add_node(graph, current_cell, sheet_name)
 
                     # Extract all referenced cells and ranges from the formula
-                    referenced_cells, range_dependencies = extract_references(
-                        cell.value
+                    direct_references, range_references, range_dependencies = (
+                        extract_references(cell.value)
                     )
 
                     # all the referenced cells and cells from expanded ranges
                     # is added to the graph as nodes and edges
-                    for ref_cell in referenced_cells:
+                    for ref_cell in direct_references:
                         if "!" not in ref_cell:
                             # No sheet specified, assume current sheet
                             refc = f"{sheet_name}!{ref_cell}"
                         else:
+                            # remove ' from sheet name
+                            ref_cell = ref_cell.replace("'", "")
                             refc = ref_cell
 
-                        log(f"  Depends on: {refc}")
+                        log(f"  Cell: {refc}")
                         # add the node
-                        graph.add_node(refc, sheet=sheet_name)
+                        add_node(graph, refc, sheet_name)
                         # add the edge
-                        graph.add_edge(cell_name, refc)
+                        graph.add_edge(current_cell, refc)
+
+                    # If a range like A1:B3 is referenced, add the range definition as a node
+                    for rng in range_references:
+                        log(f"  Range: {rng}")
+
+                        if "!" not in rng:
+                            rng = f"{sheet_name}!{rng}"
+                            range_sheet = sheet_name
+                        else:
+                            rng = sanitize_range(rng)
+                            range_sheet = rng.split("!")[0]
+
+                        add_node(graph, rng, range_sheet)
+                        graph.add_edge(current_cell, rng)
 
                     # If a range like A1:B3 is referenced, add the
                     # edge between the cells within that range and
@@ -100,7 +143,7 @@ def extract_formulas_and_build_dependencies(file_path):
                             range_ref = f"{sheet_name}!{range_ref}"
                             range_sheet = sheet_name
                         else:
-                            range_ref = range_ref
+                            range_ref = sanitize_range(range_ref)
                             range_sheet = range_ref.split("!")[0]
 
                         if "!" not in single_cell:
@@ -111,11 +154,11 @@ def extract_formulas_and_build_dependencies(file_path):
                             cell_sheet = single_cell.split("!")[0]
 
                         # this is the single cell that points to the range it belongs to
-                        graph.add_node(f"{single_cell}", sheet=cell_sheet)  # noqa
-                        graph.add_node(f"{range_ref}", sheet=range_sheet)
+                        add_node(graph, single_cell, cell_sheet)
+                        add_node(graph, range_ref, range_sheet)
 
                         # Then add the edge between the single cell and the range
-                        graph.add_edge(f"{single_cell}", f"{range_ref}")
+                        graph.add_edge(range_ref, single_cell)
     return graph