Implemented basic tests

Author: connorferster

.gitignore

@@ -150,3 +150,4 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+tests/test_data/stored_results.xlsx

src/xl_engine/__init__.py

@@ -1,2 +1,8 @@
-def main() -> None:
-    print("Hello from xl-engine!")
+"""
+A Python package that provides convenience functions using XLWings to parametrize,
+execute, and save Excel workbooks.
+"""
+
+__version__ = "0.1.0"
+
+from xl_engine.excel_engine import create_condition_check, execute_workbook, excel_runner

src/xl_engine/excel_engine.py

@@ -1,6 +1,7 @@
 from typing import Optional
 import operator
 import pathlib
+import re
 import xlwings as xw
 from rich.text import Text
 from rich.progress import Progress, TextColumn, SpinnerColumn, BarColumn, MofNCompleteColumn, TaskProgressColumn, TimeRemainingColumn
@@ -13,13 +14,17 @@
 def excel_runner(
     xlsx_filepath,
     demand_input_cell_arrays: dict[str, list],
-    identifier_cell_arrays: dict[str, list],
     design_inputs: dict[str, dict[str, float]],
     result_cells: list[str],
     save_conditions: dict[str, callable],
+    identifier_keys: Optional[list[str]] = None,
     save_dir: Optional[str] = None,
     sheet_idx: int = 0,
 ) -> None:
+    """
+    Doc strign
+    """
+
     demand_cell_ids = list(demand_input_cell_arrays.keys())
     iterations = len(demand_input_cell_arrays[demand_cell_ids[0]])
 
@@ -43,35 +48,47 @@ def excel_runner(
     main_task = main_progress.add_task("Primary Iterations", total=iterations)
     with Live(panel) as live:
         for iteration in range(iterations):
-            demand_cells_to_change = {cell_id: demand_input_cell_arrays[cell_id][iteration] for cell_id in demand_cell_ids}
+            demand_cells_to_change = {
+                cell_id: demand_input_cell_arrays[cell_id][iteration] 
+                for cell_id in demand_cell_ids
+                if valid_excel_reference(cell_id)
+            }
+            identifier_values = {
+                cell_id: str(demand_input_cell_arrays[cell_id][iteration])
+                for cell_id in demand_cell_ids
+                if not valid_excel_reference(cell_id)
+            }
             variations_task = variations_progress.add_task("Sheet variations", total=len(design_inputs.items()))
             variations_progress.reset(variations_task)
             for design_tag, design_cells_to_change in design_inputs.items():
                 cells_to_change = demand_cells_to_change | design_cells_to_change
-                calculated_results = excel_engine(
+                calculated_results = execute_workbook(
                     xlsx_filepath, 
                     cells_to_change=cells_to_change,
                     cells_to_retrieve=result_cells,
                     sheet_idx=sheet_idx
                 )
 
                 save_condition_acc = []
-                for idx, result_cell_id in enumerate(result_cells):
-                    calculated_result = calculated_results[idx]
-                    save_condition_acc.append(save_conditions[result_cell_id](calculated_result))
+                for result_cell_id, save_condition in save_conditions.items():
+                    calculated_result = calculated_results[result_cell_id]
+                    save_condition_acc.append(save_condition(calculated_result))
                 variations_progress.update(variations_task, advance=1)
 
                 if all(save_condition_acc):
                     filepath = pathlib.Path(xlsx_filepath)
                     name = filepath.stem
                     suffix = filepath.suffix
-                    demand_ids = "-".join([str(id_array[iteration]) for id_array in identifier_cell_arrays.values()])
+                    if identifier_values:
+                        identifiers = "-".join([identifier_values[id_key] for id_key in identifier_values])
+                    else:
+                        identifiers = f"{iteration}"
 
-                    new_filename = f"{name}-{demand_ids}-{design_tag}{suffix}"
+                    new_filename = f"{name}-{identifiers}-{design_tag}{suffix}"
                     save_dir_path = pathlib.Path(save_dir)
                     if not save_dir_path.exists():
                         save_dir_path.mkdir(parents=True)
-                    calculated_results = excel_engine(
+                    calculated_results = execute_workbook(
                         xlsx_filepath, 
                         cells_to_change=cells_to_change,
                         cells_to_retrieve=result_cells,
@@ -86,7 +103,7 @@ def excel_runner(
             main_progress.update(main_task, advance=1)
 
 
-def excel_engine(
+def execute_workbook(
         xlsx_filepath: str | pathlib.Path, 
         cells_to_change: dict[str, str | float | int], 
         cells_to_retrieve: list[str], 
@@ -103,8 +120,12 @@ def excel_engine(
         of a filepath str on Windows, make sure they are escaped.
     'cells_to_change': A dictionary where the keys are Excel cell names (e.g. "E45")
         and the values are the values that should be set for each key.
-    'cells_to_retrieve': A list of str representing Excel cell names that should be
-        retrieved after computation (e.g. ['C1', 'E5'])
+    'cells_to_retrieve': Either a list or dict. If list, represents a list of str 
+        representing Excel cell names that should be retrieved after computation 
+        (e.g. ['C1', 'E5']).
+        If a dict, the keys are the cell references and the values are what the 
+        cell references represent. The values will be used as the keys in the 
+        returned dictionary. (e.g. {"C1": "Date", "E5": "Critical value"})
     'sheet_idx': The sheet in the workbook 
     'new_filepath': If not None, a copy of the altered workbook will be saved at this
         locations. Can be a str or pathlib.Path. Directories on
@@ -123,13 +144,16 @@ def excel_engine(
             except:
                 raise ValueError(f"Invalid input cell name: {cell_name}. Perhaps you made a typo?")
 
-        calculated_values = [] # Add afterwards
+        calculated_values = {} # Add afterwards
         for cell_to_retrieve in cells_to_retrieve:
             try:
                 retrieved_value = ws[cell_to_retrieve].value
             except:
                 raise ValueError(f"Invalid retrieval cell name: {cell_to_retrieve}. Perhaps you made a typo?")
-            calculated_values.append(retrieved_value)
+            label = cell_to_retrieve
+            if isinstance(cells_to_retrieve, dict):
+                label = cells_to_retrieve.get(cell_to_retrieve, cell_to_retrieve)
+            calculated_values.update({label: retrieved_value})
 
         if new_filepath:
             new_filepath = pathlib.Path(new_filepath)
@@ -168,7 +192,19 @@ def create_condition_check(check_against_value: float, op: str) -> callable:
         "ne": operator.ne,
     }
     def checker(test_value):
-        return operators[op](test_value, check_against_value)
+        return operators[op.lower()](test_value, check_against_value)
 
     return checker
-    
+    
+
+def valid_excel_reference(cell: str) -> bool:
+    """
+    Returns True if 'cell' is a value that represents a valid
+    MS Excel reference, e.g. "B4", "AAC93290"
+    """
+    pattern = re.compile("^[A-Z]{1,3}[0-9]+$")
+    match = pattern.match(cell)
+    if match is None:
+        return False
+    else:
+        return True

tests/test_data/example_wb.xlsx

@@ -0,0 +1,58 @@
+import xl_engine as xl
+import math
+import pathlib
+
+TEST_DATA_DIR = pathlib.Path(__file__).parent / "test_data"
+
+def test_create_condition_check():
+    func = xl.create_condition_check(1.0, "le")
+    assert func(2) == False
+    assert func(1) == True
+    assert func(0.9) == True
+
+    func2 = xl.create_condition_check(2393.90, "gt")
+    assert func2(3000) == True
+    assert func2(1) == False
+    assert func2(2393.90) == False
+
+def test_execute_workbook():
+    results = xl.execute_workbook(
+        TEST_DATA_DIR / "example_wb.xlsx",
+        cells_to_change = {"B1": 33, "B2": 44},
+        cells_to_retrieve=['B4', 'B5'],
+        sheet_idx=0,
+    )
+    assert results['B4'] == 22
+    assert results['B5'] == 11
+
+    results2 = xl.execute_workbook(
+        TEST_DATA_DIR / "example_wb.xlsx",
+        cells_to_change = {"B1": 33, "B2": 66},
+        cells_to_retrieve=['B4', 'B5'],
+        sheet_idx=1,
+        new_filepath=TEST_DATA_DIR / "stored_results.xlsx"
+    )
+    assert results2['B4'] == 44
+    assert math.isclose(results2['B5'], 39.6)
+
+    import xlwings as xw
+    with xw.Book(TEST_DATA_DIR / "stored_results.xlsx") as wb:
+        ws = wb.sheets[1]
+        assert ws["B1"].value == 33
+        assert ws["B2"].value == 66
+
+def test_excel_runner():
+    dcr2 = xl.create_condition_check(2, "ge")
+    xl.excel_runner(
+        TEST_DATA_DIR / "example_wb.xlsx",
+        demand_input_cell_arrays={"B1": [10, 20], "Labels": ["R", "S"]},
+        design_inputs={
+            "OptA": {"B2": 22},
+            "OptB": {"B2": 33},
+            "OptC": {"B2": 55},
+        },
+        result_cells=["B4", "B5", "B6"],
+        save_conditions={"B6": dcr2},
+        identifier_keys=["Labels"],
+        save_dir=TEST_DATA_DIR / "design"
+    )