shortcutxl 0.2.19 → 0.2.21

package/xll/modules/shortcut_xl/api/range_formatter.py

@@ -31,8 +31,13 @@ MAX_STYLE_ENTRIES = 10
 # Style analysis
 # ---------------------------------------------------------------------------
 
+
 def _analyze_styles(
-    ws, sr: int, sc: int, rows: int, cols: int,
+    ws,
+    sr: int,
+    sc: int,
+    rows: int,
+    cols: int,
     values: list[list] | None = None,
 ) -> list[str]:
     """Analyze styles and return documentation lines.
@@ -100,8 +105,12 @@ def _analyze_styles(
 # Left context
 # ---------------------------------------------------------------------------
 
+
 def _build_left_context(
-    ws, sr: int, sc: int, rows: int,
+    ws,
+    sr: int,
+    sc: int,
+    rows: int,
 ) -> list[str] | None:
     """Scan leftward for row labels.
 
@@ -152,10 +161,7 @@ def _build_left_context(
         any_found = True
         # Render left-to-right (ascending col)
         found.sort(key=lambda x: x[0])
-        tokens = [
-            f'{"→" * max(0, indent)}{index_to_address(sr + r, col)}:{text}'
-            for col, text, indent in found
-        ]
+        tokens = [f'{"→" * max(0, indent)}{index_to_address(sr + r, col)}:{text}' for col, text, indent in found]
         lines.append(' | '.join(tokens))
 
     return lines if any_found else None
@@ -165,8 +171,12 @@ def _build_left_context(
 # Above context (header row voting)
 # ---------------------------------------------------------------------------
 
+
 def _build_above_context(
-    ws, sr: int, sc: int, ec: int,
+    ws,
+    sr: int,
+    sc: int,
+    ec: int,
 ) -> str | None:
     """Find the best header row above the range using voting, then build chain."""
     if sr == 0:
@@ -251,8 +261,11 @@ def _build_header_chain(ws, row: int, sc: int, ec: int) -> str | None:
 # Formula alias helpers
 # ---------------------------------------------------------------------------
 
+
 def _build_formula_aliases(
-    formulas_r1c1: list[list], rows: int, cols: int,
+    formulas_r1c1: list[list],
+    rows: int,
+    cols: int,
 ) -> tuple[dict[str, str], dict[str, list[str]], list[list[str]]]:
     """Build R1C1 frequency map and alias map for frequent formulas.
 
@@ -283,8 +296,13 @@ def _build_formula_aliases(
 
 
 def _build_data_lines(
-    ws, sr: int, sc: int, rows: int, cols: int,
-    values: list[list], formulas_a1: list[list],
+    ws,
+    sr: int,
+    sc: int,
+    rows: int,
+    cols: int,
+    values: list[list],
+    formulas_a1: list[list],
     r1c1_grid: list[list[str]],
     alias_map: dict[str, str],
     alias_examples: dict[str, list[str]],
@@ -357,9 +375,7 @@ def format_cell_range(
     cols = ec - sc + 1
 
     if rows * cols > _MAX_RANGE_CELLS:
-        raise ValueError(
-            f'Range {range_addr} has {rows * cols} cells; limit is {_MAX_RANGE_CELLS}.'
-        )
+        raise ValueError(f'Range {range_addr} has {rows * cols} cells; limit is {_MAX_RANGE_CELLS}.')
 
     rng = make_range(ws, sr, sc, er, ec)
     values = normalize_2d(rng.Value, rows, cols)
@@ -367,20 +383,28 @@ def format_cell_range(
     formulas_r1c1 = normalize_2d(rng.FormulaR1C1, rows, cols)
 
     alias_map, alias_examples, r1c1_grid = _build_formula_aliases(
-        formulas_r1c1, rows, cols,
+        formulas_r1c1,
+        rows,
+        cols,
     )
     data_lines = _build_data_lines(
-        ws, sr, sc, rows, cols, values, formulas_a1,
-        r1c1_grid, alias_map, alias_examples,
+        ws,
+        sr,
+        sc,
+        rows,
+        cols,
+        values,
+        formulas_a1,
+        r1c1_grid,
+        alias_map,
+        alias_examples,
     )
 
     # Assemble output
     output_parts: list[str] = []
 
     if alias_map:
-        output_parts.append(
-            'Common formulas are abbreviated like F1, F2, etc. and the definitions are below'
-        )
+        output_parts.append('Common formulas are abbreviated like F1, F2, etc. and the definitions are below')
         output_parts.append('')
 
     output_parts.extend(data_lines)
@@ -390,9 +414,7 @@ def format_cell_range(
         for r1c1_pattern, alias in alias_map.items():
             examples = alias_examples.get(r1c1_pattern, [])
             if examples:
-                output_parts.append(
-                    f'{alias} -> {r1c1_pattern}  (e.g. {", ".join(examples)})'
-                )
+                output_parts.append(f'{alias} -> {r1c1_pattern}  (e.g. {", ".join(examples)})')
             else:
                 output_parts.append(f'{alias} -> {r1c1_pattern}')
 

package/xll/modules/shortcut_xl/api/style.py

@@ -9,8 +9,8 @@ from shortcut_xl._log import xl_log
 
 # Border edge indices (used by clear_formatting)
 _BORDER_EDGES = {
-    'borderLeft': 7,    # xlEdgeLeft
-    'borderTop': 8,     # xlEdgeTop
+    'borderLeft': 7,  # xlEdgeLeft
+    'borderTop': 8,  # xlEdgeTop
     'borderBottom': 9,  # xlEdgeBottom
     'borderRight': 10,  # xlEdgeRight
 }
@@ -88,6 +88,6 @@ def read_style(cell) -> dict:
                 pass
 
     except Exception as e:
-        xl_log(f"read_style failed: {e}")
+        xl_log(f'read_style failed: {e}')
 
     return s

package/xll/modules/shortcut_xl/api/utils/helpers.py

@@ -7,13 +7,13 @@ Mirrors client/shared/src/lib/spreadsheet/utils/excel-address-utils.ts.
 import re
 
 _CELL_RE = re.compile(r'^([A-Z]+)(\d+)$')
-_ERROR_VALUES = frozenset(('#REF!', '#NAME?', '#VALUE!', '#DIV/0!', '#N/A', '#NULL!', '#NUM!'))
 
 
 # ---------------------------------------------------------------------------
 # Column letter <-> 0-based index
 # ---------------------------------------------------------------------------
 
+
 def col_letter(index: int) -> str:
     """Convert 0-based column index to Excel column letters (0->A, 25->Z, 26->AA)."""
     name = ''
@@ -37,11 +37,12 @@ def col_index(letter: str) -> int:
 # Address / range conversion (all 0-based)
 # ---------------------------------------------------------------------------
 
+
 def index_to_address(row: int, col: int) -> str:
     """Convert 0-based (row, col) to Excel address like 'A1'."""
     if row < 0 or col < 0:
-        raise ValueError(f"Row and col must be >= 0, got ({row}, {col})")
-    return f"{col_letter(col)}{row + 1}"
+        raise ValueError(f'Row and col must be >= 0, got ({row}, {col})')
+    return f'{col_letter(col)}{row + 1}'
 
 
 def address_to_index(address: str) -> tuple[int, int]:
@@ -51,7 +52,7 @@ def address_to_index(address: str) -> tuple[int, int]:
     """
     m = _CELL_RE.match(address.upper().strip().replace('$', ''))
     if not m:
-        raise ValueError(f"Invalid cell address: {address}")
+        raise ValueError(f'Invalid cell address: {address}')
     return int(m.group(2)) - 1, col_index(m.group(1))
 
 
@@ -69,13 +70,13 @@ def parse_range(range_str: str) -> tuple[int, int, int, int]:
     else:
         er, ec = sr, sc
     if sr > er or sc > ec:
-        raise ValueError(f"Invalid range: {range_str}")
+        raise ValueError(f'Invalid range: {range_str}')
     return sr, sc, er, ec
 
 
 def range_to_excel(start_row: int, start_col: int, end_row: int, end_col: int) -> str:
     """Convert 0-based coords to Excel range like 'A1:C10'."""
-    return f"{index_to_address(start_row, start_col)}:{index_to_address(end_row, end_col)}"
+    return f'{index_to_address(start_row, start_col)}:{index_to_address(end_row, end_col)}'
 
 
 def _strip_sheet(ref: str) -> str:
@@ -89,8 +90,8 @@ def build_cell_ref(workbook: str | None, sheet: str, address: str) -> str:
 
     This is the inverse of parse_cell_ref().
     """
-    prefix = f"[{workbook}]" if workbook else ''
-    return f"{prefix}{sheet}!{address}"
+    prefix = f'[{workbook}]' if workbook else ''
+    return f'{prefix}{sheet}!{address}'
 
 
 def parse_cell_ref(cell_ref: str) -> tuple[str | None, str | None, str | None]:
@@ -108,10 +109,10 @@ def parse_cell_ref(cell_ref: str) -> tuple[str | None, str | None, str | None]:
 
     if rest.startswith('['):
         close = rest.find(']')
-        if close <= 1:          # missing or empty workbook name
+        if close <= 1:  # missing or empty workbook name
             return None, None, None
         workbook = rest[1:close]
-        rest = rest[close + 1:]
+        rest = rest[close + 1 :]
 
     sheet, address = extract_sheet_and_range(rest)
     if not sheet or not address:
@@ -132,20 +133,21 @@ def extract_sheet_and_range(ref: str) -> tuple[str | None, str]:
                     i += 2
                 elif i + 1 < len(ref) and ref[i + 1] == '!':
                     sheet = ref[1:i].replace("''", "'")
-                    return sheet, ref[i + 2:]
+                    return sheet, ref[i + 2 :]
                 else:
                     break
             else:
                 i += 1
         return None, ref
     bang = ref.index('!')
-    return ref[:bang], ref[bang + 1:]
+    return ref[:bang], ref[bang + 1 :]
 
 
 # ---------------------------------------------------------------------------
 # Color helpers
 # ---------------------------------------------------------------------------
 
+
 def rgb_to_bgr(r: int, g: int, b: int) -> int:
     """Convert RGB components to BGR integer for Excel COM."""
     return r + (g << 8) + (b << 16)
@@ -155,7 +157,7 @@ def hex_to_bgr(hex_str: str) -> int:
     """Convert '#FF0000' (red) to BGR integer for Excel COM."""
     h = hex_str.lstrip('#')
     if len(h) != 6:
-        raise ValueError(f"Invalid hex color: {hex_str}")
+        raise ValueError(f'Invalid hex color: {hex_str}')
     r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
     return rgb_to_bgr(r, g, b)
 
@@ -166,16 +168,4 @@ def bgr_to_hex(bgr: int) -> str:
     r = bgr & 0xFF
     g = (bgr >> 8) & 0xFF
     b = (bgr >> 16) & 0xFF
-    return f"#{r:02X}{g:02X}{b:02X}"
-
-
-# ---------------------------------------------------------------------------
-# Error detection
-# ---------------------------------------------------------------------------
-
-def is_error_value(val) -> bool:
-    """Check if a cell value is an Excel error string."""
-    return isinstance(val, str) and val in _ERROR_VALUES
-
-
-ERROR_VALUES = _ERROR_VALUES
+    return f'#{r:02X}{g:02X}{b:02X}'

package/xll/modules/shortcut_xl/api/utils/numerical.py

@@ -1,4 +1,4 @@
-"""Numerical value detection."""
+"""Numerical value detection and shared numeric constants."""
 
 from __future__ import annotations
 
@@ -9,6 +9,11 @@ from typing import Any
 # COM/win32com may return Decimal for currency or high-precision cells.
 NUMERIC_TYPES = (int, float, Decimal)
 
+# Canonical currency symbol list — shared between categorize.py (detection)
+# and format.py (display).  Keep as tuple for categorize and as regex for format.
+CURRENCY_CHARS = ('$', '£', '€', '¥', '₹', '₩', '₪', '₱', '฿', 'kr')
+CURRENCY_RE = r'[$\xa3\u20ac\xa5\u20b9\u20a9\u20aa\u20b1\u0e3f]|kr'
+
 
 def is_numerical(value: Any) -> bool:
     """Return True if *value* looks like a number (for context filtering)."""

package/xll/modules/shortcut_xl/api/utils/ranges.py

@@ -60,16 +60,17 @@ def consolidate_ranges(cells: list[tuple[int, int]]) -> list[str]:
         if r == er and c == ec:
             ranges.append(index_to_address(r, c))
         else:
-            ranges.append(
-                f'{index_to_address(r, c)}:{index_to_address(er, ec)}'
-            )
+            ranges.append(f'{index_to_address(r, c)}:{index_to_address(er, ec)}')
 
     return ranges
 
 
 def _can_expand_col(
-    start_row: int, end_row: int, end_col: int,
-    cell_set: set[str], covered: set[str],
+    start_row: int,
+    end_row: int,
+    end_col: int,
+    cell_set: set[str],
+    covered: set[str],
 ) -> bool:
     """Check if adding the next column to the right is valid."""
     nc = end_col + 1
@@ -81,8 +82,12 @@ def _can_expand_col(
 
 
 def _can_expand_row(
-    start_row: int, start_col: int, end_row: int, end_col: int,
-    cell_set: set[str], covered: set[str],
+    start_row: int,
+    start_col: int,
+    end_row: int,
+    end_col: int,
+    cell_set: set[str],
+    covered: set[str],
 ) -> bool:
     """Check if adding the next row below is valid."""
     nr = end_row + 1

package/xll/modules/shortcut_xl/api/workbook.py

@@ -5,12 +5,12 @@ Output formats match the SpreadJS equivalents.
 
 from __future__ import annotations
 
-from shortcut_xl.api.categorize import com_error_to_str, is_com_error
+from shortcut_xl.api.categorize import com_error_to_str, is_com_error, is_error_value
 from shortcut_xl.api.named_ranges import get_named_range_info
+from shortcut_xl.api.utils.com_utils import normalize_2d
 from shortcut_xl.api.utils.helpers import (
     extract_sheet_and_range,
     index_to_address,
-    is_error_value,
     parse_range,
 )
 from shortcut_xl.api.worksheet import Worksheet
@@ -36,8 +36,7 @@ class Workbook:
     # ------------------------------------------------------------------
 
     def getSheetNames(self) -> list[str]:
-        return [self._wb.Worksheets(i).Name
-                for i in range(1, self._wb.Worksheets.Count + 1)]
+        return [self._wb.Worksheets(i).Name for i in range(1, self._wb.Worksheets.Count + 1)]
 
     def getSheet(self, name: str) -> Worksheet:
         """Get a sheet by name, returned as a wrapped Worksheet."""
@@ -127,8 +126,7 @@ class Workbook:
     ) -> list[tuple[str, tuple[int, int, int, int] | None]]:
         """Resolve range specs into (sheet_name, optional_bounds) pairs."""
         if ranges is None:
-            return [(self._wb.Worksheets(i).Name, None)
-                    for i in range(1, self._wb.Worksheets.Count + 1)]
+            return [(self._wb.Worksheets(i).Name, None) for i in range(1, self._wb.Worksheets.Count + 1)]
 
         targets = []
         for spec in ranges:
@@ -143,7 +141,8 @@ class Workbook:
 
     @staticmethod
     def _scan_sheet_errors(
-        ws, sheet_name: str,
+        ws,
+        sheet_name: str,
         bounds: tuple[int, int, int, int] | None = None,
     ) -> list[str]:
         """Scan a worksheet for error values. Returns formatted strings."""
@@ -167,22 +166,10 @@ class Workbook:
             ws.Cells(sr + 1, sc + 1),
             ws.Cells(er + 1, ec + 1),
         )
-        data = rng.Value
-
-        # Normalize
-        if data is None:
-            return []
-        if not isinstance(data, tuple):
-            data = ((data,),)
-        elif rows == 1:
-            # Single row returns flat tuple
-            if not isinstance(data[0], tuple):
-                data = (data,)
+        data = normalize_2d(rng.Value, rows, cols)
 
         errors = []
         for r_idx, row in enumerate(data):
-            if not isinstance(row, tuple):
-                row = (row,)
             for c_idx, val in enumerate(row):
                 # COM .Value returns error strings for text-entered errors
                 # and integer CVErr codes for formula-produced errors
@@ -194,7 +181,7 @@ class Workbook:
 
                 if error_str:
                     addr = index_to_address(sr + r_idx, sc + c_idx)
-                    errors.append(f"{sheet_name}!{addr}: {error_str}")
+                    errors.append(f'{sheet_name}!{addr}: {error_str}')
 
         return errors
 
@@ -213,8 +200,7 @@ class Workbook:
             return self._wb.Sheets(sheet_name).Range(cell_addr)
         return self._wb.Application.Range(address)
 
-    def copyPasteRange(self, from_range: str, to_address: str,
-                       paste_type: str = 'all') -> None:
+    def copyPasteRange(self, from_range: str, to_address: str, paste_type: str = 'all') -> None:
         """Copy a range to another location within the same workbook.
 
         Uses range.Copy (NOT Sheet.Copy which is broken via pywin32).
@@ -265,18 +251,18 @@ class Workbook:
                 row = (row,)
             for c_idx, val in enumerate(row):
                 if is_com_error(val):
-                    rng.Cells(r_idx + 1, c_idx + 1).Value = \
-                        com_error_to_str(val)
+                    rng.Cells(r_idx + 1, c_idx + 1).Value = com_error_to_str(val)
 
 
 # ---------------------------------------------------------------------------
 # Error formatting — matches SpreadJS error-checker.ts formatCategory
 # ---------------------------------------------------------------------------
 
+
 def _format_error_category(title: str, items: list[str]) -> str:
     shown = items[:_MAX_PER_CATEGORY]
-    lines = [f"{title} ({len(items)}):"]
-    lines.extend(f"  {s}" for s in shown)
+    lines = [f'{title} ({len(items)}):']
+    lines.extend(f'  {s}' for s in shown)
     if len(items) > _MAX_PER_CATEGORY:
-        lines.append(f"  ... and {len(items) - _MAX_PER_CATEGORY} more")
+        lines.append(f'  ... and {len(items) - _MAX_PER_CATEGORY} more')
     return '\n'.join(lines)