Merge pull request #3 from dalager/Refactor

Refactoring, cleanup and test improvements

Author: dalager

.flake8

@@ -0,0 +1,2 @@
+[flake8]
+max-line-length = 100

README.md

@@ -79,24 +79,25 @@ In [graph_visualizer.py](graph_visualizer.py) you will find three configuration
 The following is the output of running the script on the provided `Book1.xlsx` file.
 
 ```bash
-=== Dependency Graph Summary ===
-Cell/Node count                50
-Dependency count               60
-
-=== Nodes with the highest degree ===
-Range!F1                       10
-Base!B5                         4
-Base!B12                        3
-Base!B17                        3
-Base!I21                        3
-Base!G22                        3
-Base!B22                        3
-Base!B28                        3
-Range!B2                        3
-Range!B3                        3
-
-=== Formula functions by count ===
-SUM                             3
+===  Dependency Graph Summary ===
+Cell/Node count                70
+Dependency count              100
+
+
+===  Most connected nodes     ===
+Range Madness!A2:A11           22
+Range Madness!B2:B11           11
+Range Madness!F1               10
+Main Sheet!B5                   4
+Main Sheet!B22                  4
+Detached !A2:A4                 4
+Range Madness!B2                4
+Range Madness!B3                4
+Range Madness!B4                4
+Range Madness!B5                4
+
+===  Most used functions      ===
+SUM                             4
 POWER                           1
 
 Visualizing the graph of dependencies.

excel_parser.py

@@ -1,63 +1,75 @@
 from openpyxl.utils import get_column_letter, range_boundaries
 import re
-
+from typing import List, Tuple, Dict
 
 # Regex to detect cell references like A1, B2, or ranges like A1:B2
 CELL_REF_REGEX = r"('?[A-Za-z0-9_\-\[\] ]+'?![A-Z]{1,3}[0-9]+(:[A-Z]{1,3}[0-9]+)?)|([A-Z]{1,3}[0-9]+(:[A-Z]{1,3}[0-9]+)?)"  # noqa
 
 
-def expand_range(range_ref):
+def expand_range(range_reference: str) -> List[str]:
     """
     Expand a range reference (e.g., 'A1:A3') into a list of individual cell references.
-    """
 
+    Args:
+        range_ref (str): The range reference to expand.
+
+    Returns:
+        List[str]: A list of individual cell references.
+    """
     # if there is a sheet name in the range reference, put it away for now
-    if "!" in range_ref:
-        sheet_name, range_ref = range_ref.split("!")
+    if "!" in range_reference:
+        sheet_name, range_reference = range_reference.split("!")
     else:
         sheet_name = None
 
-    min_col, min_row, max_col, max_row = range_boundaries(range_ref)
+    min_col, min_row, max_col, max_row = range_boundaries(range_reference)
     expanded_cells = []
 
     # Loop over rows and columns in the range
     for row in range(min_row, max_row + 1):
         for col in range(min_col, max_col + 1):
-            # if sheetname is set
+            cell_ref = f"{get_column_letter(col)}{row}"
             if sheet_name:
-                expanded_cells.append(f"{sheet_name}!{get_column_letter(col)}{row}")
+                expanded_cells.append(f"{sheet_name}!{cell_ref}")
             else:
-                expanded_cells.append(f"{get_column_letter(col)}{row}")
+                expanded_cells.append(cell_ref)
 
     return expanded_cells
 
 
-def extract_references(formula):
+def extract_references(formula: str) -> Tuple[List[str], List[str], Dict[str, str]]:
     """
     Extract all referenced cells and ranges from a formula using regular expressions.
     This returns a list of both individual cells and range references.
+
+    Args:
+        formula (str): The formula to extract references from.
+
+    Returns:
+        Tuple[List[str], List[str], Dict[str, str]]: A tuple containing lists of direct references,
+                                                     range references, and a dictionary of dependencies.
     """
     formula = formula.replace("$", "")
     matches = re.findall(CELL_REF_REGEX, formula)
     references = [match[0] if match[0] else match[2] for match in matches]
 
-    # trim the extracted references
+    # Trim the extracted references
     references = [ref.strip() for ref in references]
 
     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)
+    for reference in references:
+        if ":" in reference:  # it's a range like A1:A3
+            expanded_cells = expand_range(reference)
             expanded_references.extend(expanded_cells)
-            range_references.append(ref)
+            range_references.append(reference)
             # Store the range-to-cells relationship
             for cell in expanded_cells:
-                dependencies[cell] = ref
+                dependencies[cell] = reference
         else:  # single cell
-            direct_references.append(ref)
+            direct_references.append(reference)
 
     return direct_references, range_references, dependencies

graph_summarizer.py

@@ -0,0 +1,46 @@
+from collections import Counter
+
+
+def print_summary(graph, functionsdict):
+    """
+    Summarize a networkx DiGraph representing a dependency graph and print the most used functions in the formulas.
+    """
+    strpadsize = 28
+    numpadsize = 5
+
+    print_basic_info(graph, strpadsize, numpadsize)
+    print_highest_degree_nodes(graph, strpadsize, numpadsize)
+    print_most_used_functions(functionsdict, strpadsize, numpadsize)
+
+
+def print_basic_info(graph, strpadsize, numpadsize):
+    print("===  Dependency Graph Summary ===")
+    print(
+        "Cell/Node count".ljust(strpadsize, " ")
+        + str(graph.number_of_nodes()).rjust(numpadsize, " ")
+    )
+    print(
+        "Dependency count".ljust(strpadsize, " ")
+        + str(graph.number_of_edges()).rjust(numpadsize, " ")
+    )
+    print()
+
+
+def print_highest_degree_nodes(graph, strpadsize, numpadsize):
+    print("\n===  Most connected nodes     ===")
+    degree_view = graph.degree()
+    degree_counts = Counter(dict(degree_view))
+    max_degree_node = degree_counts.most_common(10)
+
+    for node, degree in max_degree_node:
+        print(f"{node.ljust(strpadsize)}{str(degree).rjust(numpadsize, ' ')} ")
+
+
+def print_most_used_functions(functionsdict, strpadsize, numpadsize):
+    print("\n===  Most used functions      ===")
+    sorted_functions = dict(
+        sorted(functionsdict.items(), key=lambda item: item[1], reverse=True)
+    )
+
+    for function, count in sorted_functions.items():
+        print(f"{function.ljust(strpadsize, ' ')}{str(count).rjust(numpadsize, ' ')}")

graphbuilder.py

@@ -2,66 +2,59 @@
 This script extracts formulas from an Excel file and builds a dependency graph.
 """
 
+from typing import List, Dict
 from openpyxl import load_workbook
-from collections import Counter
 import networkx as nx
 import re
 import sys
 from graph_visualizer import visualize_dependency_graph
+from graph_summarizer import print_summary
 from excel_parser import extract_references
 
-# dictionary that stores the uniqe functions used in the formulas
-# the key will be the funciton name and the value will be the number of times it was used
-functions_dict = {}
+# Dictionary that stores the unique functions used in the formulas
+# The key will be the function name and the value will be the number of times it was used
+functions_dict: Dict[str, int] = {}
 
 
-def log(msg):
+def log(msg: str) -> None:
     """
     Log a message to the console if verbosity is enabled using the --verbose flag.
     """
-    # if verbosity is enabled
-
     if "--verbose" in sys.argv:
         print(msg)
 
 
-def sanitize_sheetname(sheetname):
+def sanitize_sheetname(sheetname: str) -> str:
     """
     Remove any special characters from the sheet name.
     """
     return sheetname.replace("'", "")
 
 
-def sanitize_range(rangestring):
+def sanitize_range(rangestring: str) -> str:
     """
     Remove any special characters from the range.
     """
     if "!" in rangestring:
-        sheet = rangestring.split("!")[0].replace("'", "")
-        range = rangestring.split("!")[1]
-
-    return f"{sheet}!{range}"
+        sheet, range_ = rangestring.split("!")
+        sheet = sheet.replace("'", "")
+        return f"{sheet}!{range_}"
+    return rangestring
 
 
-def stat_functions(cellvalue):
+def stat_functions(cellvalue: str) -> None:
     """
     Extract the functions used in the formula and store them in a dictionary.
     This will be used to print the most used functions in the formulas.
     """
-
-    # functions used in the formula
     cellfuncs = re.findall(r"[A-Z]+\(", cellvalue)
     log(f"  Functions used: {functions_dict}")
     for function in cellfuncs:
-        # remove the "(" from the function name
-        function = function[:-1]
-        if function in functions_dict:
-            functions_dict[function] += 1
-        else:
-            functions_dict[function] = 1
+        function = function[:-1]  # Remove the "(" from the function name
+        functions_dict[function] = functions_dict.get(function, 0) + 1
 
 
-def add_node(graph, node, sheet):
+def add_node(graph: nx.DiGraph, node: str, sheet: str) -> None:
     """
     Add a node to the graph with the specified sheet name.
     """
@@ -70,135 +63,114 @@ def add_node(graph, node, sheet):
     graph.add_node(node, sheet=sheet)
 
 
-def extract_formulas_and_build_dependencies(file_path):
+def extract_formulas_and_build_dependencies(file_path: str) -> nx.DiGraph:
     """
     Extract formulas from an Excel file and build a dependency graph.
     """
+    try:
+        wb = load_workbook(file_path, data_only=False)
+    except Exception as e:
+        log(f"Error loading workbook: {e}")
+        sys.exit(1)
 
-    # Load the workbook
-    wb = load_workbook(file_path, data_only=False)
-
-    # Create a directed graph for dependencies
     graph = nx.DiGraph()
 
-    # Iterate over all sheets
     for sheet_name in wb.sheetnames:
         ws = wb[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:
-                # only interested in cells with formulas
-                if isinstance(cell.value, str) and cell.value.startswith("="):
-                    # collect functions usage statistics
-                    stat_functions(cell.value)
-
-                    current_cell = f"{sheet_name}!{cell.coordinate}"
-                    log(f"Formula in {current_cell}: {cell.value}")
-
-                    add_node(graph, current_cell, sheet_name)
-
-                    # Extract all referenced cells and ranges from the formula
-                    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 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"  Cell: {refc}")
-                        # add the node
-                        add_node(graph, refc, sheet_name)
-                        # add the edge
-                        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
-                    # the range istself
-                    for single_cell, range_ref in range_dependencies.items():
-                        if "!" not in range_ref:
-                            range_ref = f"{sheet_name}!{range_ref}"
-                            range_sheet = sheet_name
-                        else:
-                            range_ref = sanitize_range(range_ref)
-                            range_sheet = range_ref.split("!")[0]
-
-                        if "!" not in single_cell:
-                            single_cell = f"{sheet_name}!{single_cell}"
-                            cell_sheet = sheet_name
-                        else:
-                            single_cell = single_cell
-                            cell_sheet = single_cell.split("!")[0]
-
-                        # this is the single cell that points to the range it belongs to
-                        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(range_ref, single_cell)
+        sanitized_sheet_name = sanitize_sheetname(sheet_name)
+        process_sheet(ws, sanitized_sheet_name, graph)
+
     return graph
 
 
-def print_summary(graph, functionsdict):
+def process_sheet(ws, sheet_name: str, graph: nx.DiGraph) -> None:
     """
-    Summarize a networkx DiGraph representing a dependency graph. And print the most used functions in the formulas
+    Process a sheet and add references to the graph.
     """
+    for row in ws.iter_rows():
+        for cell in row:
+            if isinstance(cell.value, str) and cell.value.startswith("="):
+                process_formula_cell(cell, sheet_name, graph)
 
-    strpadsize = 28
-    numpadsize = 5
-    # 1. Print basic information about the graph
 
-    print("=== Dependency Graph Summary ===")
-    print(
-        "Cell/Node count".ljust(strpadsize, " ")
-        + str(graph.number_of_nodes()).rjust(numpadsize, " ")
-    )
-    print(
-        "Dependency count".ljust(strpadsize, " ")
-        + str(graph.number_of_edges()).rjust(numpadsize, " ")
+def process_formula_cell(cell, sheet_name: str, graph: nx.DiGraph) -> None:
+    """
+    Process a cell containing a formula.
+    """
+    stat_functions(cell.value)
+    cell_reference = f"{sheet_name}!{cell.coordinate}"
+    log(f"Formula in {cell_reference}: {cell.value}")
+    add_node(graph, cell_reference, sheet_name)
+
+    direct_references, range_references, range_dependencies = extract_references(
+        cell.value
     )
-    print()
+    add_references_to_graph(direct_references, cell_reference, sheet_name, graph)
+    add_ranges_to_graph(range_references, cell_reference, sheet_name, graph)
+    add_range_dependencies_to_graph(range_dependencies, sheet_name, graph)
+
+
+def add_references_to_graph(
+    references: List[str], current_cell: str, sheet_name: str, graph: nx.DiGraph
+) -> None:
+    """
+    Add direct cell references to the graph.
+    """
+    for cell_reference in references:
+        cell_reference = format_reference(cell_reference, sheet_name)
+        log(f"  Cell: {cell_reference}")
+        add_node(graph, cell_reference, sheet_name)
+        graph.add_edge(current_cell, cell_reference)
 
-    # 2. Print the nodes with the highest degree
-    degree_view = graph.degree()
 
-    degree_counts = Counter(dict(degree_view))
-    max_degree_node = degree_counts.most_common(10)
-    print("=== Nodes with the highest degree ===")
-    for node, degree in max_degree_node:
-        print(f"{node.ljust(strpadsize)}{str(degree).rjust(numpadsize, ' ')} ")
+def add_ranges_to_graph(
+    ranges: List[str], current_cell: str, sheet_name: str, graph: nx.DiGraph
+) -> None:
+    """
+    Add range references to the graph.
+    """
+    for range_reference in ranges:
+        range_sheet_name = get_range_sheet_name(range_reference, sheet_name)
+        range_reference = format_reference(range_reference, sheet_name)
+        log(f"  Range: {range_reference}")
+        add_node(graph, range_reference, range_sheet_name)
+        graph.add_edge(current_cell, range_reference)
+
+
+def add_range_dependencies_to_graph(
+    range_dependencies: Dict[str, str], sheet_name: str, graph: nx.DiGraph
+) -> None:
+    """
+    Add dependencies between ranges and cells.
+    """
+    for cell_reference, range_reference in range_dependencies.items():
+        range_reference = format_reference(range_reference, sheet_name)
+        cell_reference = format_reference(cell_reference, sheet_name)
+        range_sheet_name = range_reference.split("!")[0]
+        cell_sheet_name = cell_reference.split("!")[0]
+
+        add_node(graph, cell_reference, cell_sheet_name)
+        add_node(graph, range_reference, range_sheet_name)
+        graph.add_edge(range_reference, cell_reference)
 
-    # 3. Print the most used functions
-    print("\n=== Formula functions by count ===")
-    sorted_functions = dict(
-        sorted(functionsdict.items(), key=lambda item: item[1], reverse=True)
+
+def format_reference(reference: str, sheet_name: str) -> str:
+    """
+    Format a cell or range reference to include the sheet name if not already present.
+    """
+    return (
+        f"{sheet_name}!{reference}"
+        if "!" not in reference
+        else reference.replace("'", "")
     )
 
-    for function, count in sorted_functions.items():
-        print(f"{function.ljust(strpadsize, ' ')}{str(count).rjust(numpadsize, ' ')}")
+
+def get_range_sheet_name(range_reference: str, sheet_name: str) -> str:
+    """
+    Get the sheet name for a range reference.
+    """
+    return sheet_name if "!" not in range_reference else range_reference.split("!")[0]
 
 
 if __name__ == "__main__":

test_cell_reference_extraction.py

@@ -1,161 +1,146 @@
-from excel_parser import (
-    extract_references,
-    expand_range,
-)  # Ensure you replace this with the actual name of your module
-
-
-# def test_expand_range():
-#     formula = "=Sum(A1:A3)"
-#     expected_references = ["A1", "A2", "A3"]
-#     direct_references, deps = extract_references(formula)
-#     assert (
-#         direct_references == expected_references
-#     ), f"Expected {expected_references}, but got {direct_references}"
-
-
-# def test_expand_range_other_sheet():
-#     formula = "=Sum(Other!A1:A3)"
-#     expected_references = ["Other!A1", "Other!A2", "Other!A3"]
-#     direct_references, deps = extract_references(formula)
-#     assert (
-#         direct_references == expected_references
-#     ), f"Expected {expected_references}, but got {direct_references}"
-
-
-# # Test for simple references like B4, A5
-def test_simple_references():
-    formula = "=B4+A5"
-    expected_references = ["B4", "A5"]
-    direct_references, range_references, deps = extract_references(formula)
-    assert (
-        direct_references == expected_references
-    ), f"Expected {expected_references}, but got {direct_references}"
-
-
-# # Test for local range references like A2:A11
-def test_local_range_references():
-    formula = "=SUM(A2:A4)"
-    expected_references = ["A2:A4"]
-    direct_references, range_refs, deps = extract_references(formula)
-    assert (
-        range_refs == expected_references
-    ), f"Expected {expected_references}, but got {direct_references}"
+import pytest
+from excel_parser import extract_references
 
 
-# Test for simple absolute references like $A$1, $B$2
-def test_absolute_references():
-    formula = "=$A$1+$B$2"
-    expected_references = ["A1", "B2"]
-    direct_references, range_refs, deps = extract_references(formula)
+# Helper function to assert references
+def assert_references(formula, expected_direct, expected_range, expected_deps):
+    direct_references, range_references, deps = extract_references(formula)
     assert (
-        direct_references == expected_references
-    ), f"Expected {expected_references}, but got {direct_references}"
-
-
-# Test for sheet qualified absolute references like Sheet2!$A$1, Sheet2!$B$2
-def test_sheet_qualified_absolute_references():
-    formula = "=Sheet2!$A$1+Sheet2!$B$2"
-    expected_references = ["Sheet2!A1", "Sheet2!B2"]
-    direct_references, range_refs, deps = extract_references(formula)
+        direct_references == expected_direct
+    ), f"Expected {expected_direct}, but got {direct_references}"
     assert (
-        direct_references == expected_references
-    ), f"Expected {expected_references}, but got {direct_references}"
+        range_references == expected_range
+    ), f"Expected {expected_range}, but got {range_references}"
+    assert deps == expected_deps, f"Expected {expected_deps}, but got {deps}"
+
+
+@pytest.mark.parametrize(
+    "formula, expected_direct, expected_range, expected_deps",
+    [
+        # Test for simple references like B4, A5
+        ("=B4+A5", ["B4", "A5"], [], {}),
+        # Test for local range references like A2:A11
+        ("=SUM(A2:A4)", [], ["A2:A4"], {"A2": "A2:A4", "A3": "A2:A4", "A4": "A2:A4"}),
+        # Test for simple absolute references like $A$1, $B$2
+        ("=$A$1+$B$2", ["A1", "B2"], [], {}),
+        # Test for sheet qualified absolute references like Sheet2!$A$1, Sheet2!$B$2
+        ("=Sheet2!$A$1+Sheet2!$B$2", ["Sheet2!A1", "Sheet2!B2"], [], {}),
+    ],
+)
+def test_references(formula, expected_direct, expected_range, expected_deps):
+    """
+    Test various cell and range references.
+    """
+    assert_references(formula, expected_direct, expected_range, expected_deps)
 
 
 # Test for sheet-qualified absolute range references like Sheet2!$A$1:$A$10
 def test_sheet_qualified_absolute_range_references():
+    """
+    Test for sheet-qualified absolute range references like Sheet2!$A$2:$A$5.
+    """
     formula = "=SUM(Sheet2!$A$2:$A$5)"
-    expected_references = [
-        "Sheet2!A2:A5",
-    ]
-    direct_references, range_refs, deps = extract_references(formula)
-    assert (
-        range_refs == expected_references
-    ), f"Expected {expected_references}, but got {direct_references}"
+    expected_direct = []
+    expected_range = ["Sheet2!A2:A5"]
+    expected_deps = {
+        "Sheet2!A2": "Sheet2!A2:A5",
+        "Sheet2!A3": "Sheet2!A2:A5",
+        "Sheet2!A4": "Sheet2!A2:A5",
+        "Sheet2!A5": "Sheet2!A2:A5",
+    }
+    assert_references(formula, expected_direct, expected_range, expected_deps)
 
 
 # Test for sheet-qualified cell like Sheet2!C5
 def test_sheet_qualified_reference():
+    """
+    Test for sheet-qualified cell like Sheet2!C5.
+    """
     formula = "=Sheet2!C5"
-    expected_references = ["Sheet2!C5"]
-    direct_references, rr, deps = extract_references(formula)
-    assert (
-        direct_references == expected_references
-    ), f"Expected {expected_references}, but got {direct_references}"
+    expected_direct = ["Sheet2!C5"]
+    expected_range = []
+    expected_deps = {}
+    assert_references(formula, expected_direct, expected_range, expected_deps)
 
 
+# Test for expanded range in dependencies
 def test_expanded_range_in_dependencies():
+    """
+    Test for expanded range in dependencies like A1:A3.
+    """
     formula = "=SUM(A1:A3)"
-    expected_references = ["A1", "A2", "A3"]
-    direct_references, range_refs, deps = extract_references(formula)
-    assert deps == {
-        "A1": "A1:A3",
-        "A2": "A1:A3",
-        "A3": "A1:A3",
-    }, f"Expected {expected_references}, but got {deps}"
+    expected_direct = []
+    expected_range = ["A1:A3"]
+    expected_deps = {"A1": "A1:A3", "A2": "A1:A3", "A3": "A1:A3"}
+    assert_references(formula, expected_direct, expected_range, expected_deps)
 
 
+# Test for no direct but only range references
 def test_no_direct_but_only_range_references():
+    """
+    Test for no direct references but only range references like A1:A3.
+    """
     formula = "=SUM(A1:A3)"
-    direct_references, range_refs, deps = extract_references(formula)
-    assert (
-        direct_references == []
-    ), f"Expected no direct references, but got {direct_references}"
+    expected_direct = []
+    expected_range = ["A1:A3"]
+    expected_deps = {"A1": "A1:A3", "A2": "A1:A3", "A3": "A1:A3"}
+    assert_references(formula, expected_direct, expected_range, expected_deps)
 
 
+# Test for two ranges
 def test_two_ranges():
+    """
+    Test for two ranges like A1:A3 and B1:B3.
+    """
     formula = "=SUM(A1:A3) + SUM(B1:B3)"
-    direct_references, range_refs, deps = extract_references(formula)
-    assert range_refs == [
-        "A1:A3",
-        "B1:B3",
-    ], f"Expected ['A1:A3', 'B1:B3'], but got {range_refs}"
+    expected_direct = []
+    expected_range = ["A1:A3", "B1:B3"]
+    expected_deps = {
+        "A1": "A1:A3",
+        "A2": "A1:A3",
+        "A3": "A1:A3",
+        "B1": "B1:B3",
+        "B2": "B1:B3",
+        "B3": "B1:B3",
+    }
+    assert_references(formula, expected_direct, expected_range, expected_deps)
 
 
 # Test for sheet-qualified range like Sheet2!A1:B10
 def test_sheet_qualified_range():
+    """
+    Test for sheet-qualified range like Sheet2!A1:B3.
+    """
     formula = "=SUM(Sheet2!A1:B3)"
-    expected_references = [
-        "Sheet2!A1:B3",
-    ]
-    direct_references, rr, deps = extract_references(formula)
-    assert (
-        rr == expected_references
-    ), f"Expected {expected_references}, but got {direct_references}"
-
-
-# # Test for mixed references with both local and sheet-qualified cells
-# def test_mixed_references():
-#     formula = "=SUM(Sheet2!A1:B3, A5) + Sheet2!C5 + B6"
-#     expected_references = [
-#         "Sheet2!A1",
-#         "Sheet2!B1",
-#         "Sheet2!A2",
-#         "Sheet2!B2",
-#         "Sheet2!A3",
-#         "Sheet2!B3",
-#         "A5",
-#         "Sheet2!C5",
-#         "B6",
-#     ]
-#     direct_references, deps = extract_references(formula)
-#     assert (
-#         direct_references == expected_references
-#     ), f"Expected {expected_references}, but got {direct_references}"
-
-
-# # Test for sheet-qualified ranges and mix of cell references
-# def test_mixed_ranges_and_cells():
-#     formula = "=A1+Sheet1!B1+B10+SUM(Sheet2!A1:A3)"
-#     expected_references = [
-#         "A1",
-#         "Sheet1!B1",
-#         "B10",
-#         "Sheet2!A1",
-#         "Sheet2!A2",
-#         "Sheet2!A3",
-#     ]
-#     direct_references, deps = extract_references(formula)
-#     assert (
-#         direct_references == expected_references
-#     ), f"Expected {expected_references}, but got {direct_references}"
+    expected_direct = []
+    expected_range = ["Sheet2!A1:B3"]
+
+    expected_deps = {
+        "Sheet2!A1": "Sheet2!A1:B3",
+        "Sheet2!A2": "Sheet2!A1:B3",
+        "Sheet2!A3": "Sheet2!A1:B3",
+        "Sheet2!B1": "Sheet2!A1:B3",
+        "Sheet2!B2": "Sheet2!A1:B3",
+        "Sheet2!B3": "Sheet2!A1:B3",
+    }
+
+    assert_references(formula, expected_direct, expected_range, expected_deps)
+
+
+# Test for mixed references with both local and sheet-qualified cells
+def test_mixed_references():
+    """
+    Test for mixed references with both local and sheet-qualified cells.
+    """
+    formula = "=SUM(Sheet2!A1:B3, A5) + Sheet2!C5 + B6"
+    expected_direct = ["A5", "Sheet2!C5", "B6"]
+    expected_range = ["Sheet2!A1:B3"]
+    expected_deps = {
+        "Sheet2!A1": "Sheet2!A1:B3",
+        "Sheet2!A2": "Sheet2!A1:B3",
+        "Sheet2!A3": "Sheet2!A1:B3",
+        "Sheet2!B1": "Sheet2!A1:B3",
+        "Sheet2!B2": "Sheet2!A1:B3",
+        "Sheet2!B3": "Sheet2!A1:B3",
+    }
+    assert_references(formula, expected_direct, expected_range, expected_deps)