consync 2.0.0__tar.gz → 2.1.0__tar.gz

{consync-2.0.0 → consync-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: consync
-Version: 2.0.0
+Version: 2.1.0
 Summary: Bidirectional sync between spreadsheets and source code constants — with full decimal precision.
 Project-URL: Homepage, https://github.com/naveenkumarbaskaran/consync
 Project-URL: Repository, https://github.com/naveenkumarbaskaran/consync

{consync-2.0.0 → consync-2.1.0}/consync/__init__.py

@@ -1,6 +1,6 @@
 """consync — Bidirectional sync between spreadsheets and source code constants."""
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"
 
 from consync.models import Constant, SyncDirection
 from consync.config import load_config

{consync-2.0.0 → consync-2.1.0}/consync/parsers/json_parser.py

@@ -49,6 +49,10 @@ def parse_json(filepath: str | Path, **kwargs) -> list[Constant]:
 
     # Format A or C: object
     if isinstance(data, dict):
+        # Format D: consync renderer output {"_meta": {...}, "constants": [...]}
+        if "constants" in data and isinstance(data["constants"], list):
+            return _parse_array(data["constants"])
+
         # Check first value to distinguish A vs C
         first_val = next(iter(data.values()), None) if data else None
         if isinstance(first_val, dict):

consync-2.1.0/consync/parsers/xlsx.py

@@ -0,0 +1,228 @@
+"""Excel (.xlsx) parser — reads constants from a spreadsheet.
+
+Supports two layouts:
+
+1. **Flat layout** (default for c_header, csv, etc.):
+   Row 1: Header row (Name, Value, Unit, Description)
+   Row 2+: Data rows
+
+2. **Table layout** (for c_struct_table):
+   Row 1: Motor Variant | field1 | field2 | field3 | ...
+   Row 2+: variant_name | val1   | val2   | val3   | ...
+   - Multiple sheets = multiple variants
+   - Auto-detected when first column header matches "Motor Variant"
+   - Reconstructs full metadata for bidirectional sync with C files
+
+Column mapping is flexible — auto-detects by header names.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from consync.models import Constant
+from consync.parsers import register
+
+
+# Column header aliases (case-insensitive matching)
+NAME_ALIASES = {"name", "constant", "parameter", "variable", "symbol", "id"}
+VALUE_ALIASES = {"value", "val", "data", "number", "amount"}
+UNIT_ALIASES = {"unit", "units", "uom", "dimension"}
+DESC_ALIASES = {"description", "desc", "comment", "note", "notes", "info"}
+
+# Table layout detection
+TABLE_FIRST_COL_ALIASES = {"motor variant", "variant", "row", "label", "name"}
+
+
+def _find_column(headers: list[str], aliases: set[str]) -> int | None:
+    """Find column index matching any alias (case-insensitive)."""
+    for i, h in enumerate(headers):
+        if h and h.strip().lower() in aliases:
+            return i
+    return None
+
+
+def _is_table_layout(ws) -> bool:
+    """Detect if a worksheet uses table layout (first col = Motor Variant)."""
+    first_header = ws.cell(1, 1).value
+    if first_header and str(first_header).strip().lower() in TABLE_FIRST_COL_ALIASES:
+        # Additional check: second column should NOT be "Value"
+        second_header = ws.cell(1, 2).value
+        if second_header and str(second_header).strip().lower() in VALUE_ALIASES:
+            return False
+        return True
+    return False
+
+
+def _sanitize_label(label: str) -> str:
+    """Convert a row label to a valid C-style identifier prefix."""
+    sanitized = re.sub(r"[^a-zA-Z0-9]+", "_", label.strip())
+    return sanitized.strip("_")
+
+
+@register("xlsx")
+def parse_xlsx(filepath: str | Path, **kwargs) -> list[Constant]:
+    """Parse constants from an Excel file.
+
+    Auto-detects layout:
+    - Table layout → reads all sheets, reconstructs row_label/field metadata
+    - Flat layout → reads active sheet as Name/Value/Unit/Description
+
+    Args:
+        filepath: Path to .xlsx file.
+        sheet: Sheet name or index (default: auto).
+
+    Returns:
+        List of Constant objects.
+    """
+    import openpyxl
+
+    filepath = Path(filepath)
+    if not filepath.exists():
+        raise FileNotFoundError(f"Excel file not found: {filepath}")
+
+    wb = openpyxl.load_workbook(filepath, data_only=True)
+
+    # Check if this is table layout by examining the first data sheet
+    data_sheets = [s for s in wb.sheetnames if s.lower() != "info"]
+    if data_sheets:
+        first_ws = wb[data_sheets[0]]
+        if _is_table_layout(first_ws):
+            return _parse_table_layout(wb, data_sheets, **kwargs)
+
+    # Fall back to flat layout
+    return _parse_flat_layout(wb, **kwargs)
+
+
+def _parse_table_layout(wb, data_sheets: list[str], **kwargs) -> list[Constant]:
+    """Parse table-layout Excel (one sheet per variant, rows=motors, cols=fields)."""
+    constants: list[Constant] = []
+
+    for sheet_name in data_sheets:
+        ws = wb[sheet_name]
+        variant = sheet_name  # Sheet name = variant name
+
+        # Read field names from header row (skip first column = "Motor Variant")
+        headers = []
+        for col in range(2, ws.max_column + 1):
+            h = ws.cell(1, col).value
+            headers.append(str(h).strip() if h else f"field_{col - 2}")
+
+        # Read data rows
+        for row in range(2, ws.max_row + 1):
+            row_label = ws.cell(row, 1).value
+            if not row_label:
+                continue
+            row_label = str(row_label).strip()
+            name_prefix = _sanitize_label(row_label)
+
+            for col_idx, field_name in enumerate(headers):
+                cell_value = ws.cell(row, col_idx + 2).value
+                if cell_value is None:
+                    continue
+
+                const_name = f"{name_prefix}__{field_name}"
+
+                # Determine value type
+                if isinstance(cell_value, (int, float)):
+                    value = cell_value
+                    is_expression = False
+                else:
+                    str_val = str(cell_value).strip()
+                    # Try numeric parse
+                    try:
+                        value = int(str_val)
+                        is_expression = False
+                    except ValueError:
+                        try:
+                            value = float(str_val)
+                            is_expression = False
+                        except ValueError:
+                            value = str_val
+                            is_expression = str_val.upper() not in ("TRUE", "FALSE")
+
+                constants.append(Constant(
+                    name=const_name,
+                    value=value,
+                    unit="",
+                    description=f"Row: {row_label}, Field: {field_name}",
+                    metadata={
+                        "row_label": row_label,
+                        "field": field_name,
+                        "field_index": col_idx,
+                        "variant": variant,
+                        "is_expression": is_expression,
+                    },
+                ))
+
+    return constants
+
+
+def _parse_flat_layout(wb, **kwargs) -> list[Constant]:
+    """Parse flat-layout Excel (Name/Value/Unit/Description columns)."""
+    sheet = kwargs.get("sheet")
+    if sheet is not None:
+        if isinstance(sheet, int):
+            ws = wb.worksheets[sheet]
+        else:
+            ws = wb[sheet]
+    else:
+        ws = wb.active
+
+    # Read header row
+    header_row = [str(cell.value or "").strip() for cell in ws[1]]
+
+    # Auto-detect columns
+    name_col = _find_column(header_row, NAME_ALIASES)
+    value_col = _find_column(header_row, VALUE_ALIASES)
+    unit_col = _find_column(header_row, UNIT_ALIASES)
+    desc_col = _find_column(header_row, DESC_ALIASES)
+
+    # Fallback to positional: A=Name, B=Value, C=Unit, D=Description
+    if name_col is None:
+        name_col = 0
+    if value_col is None:
+        value_col = 1
+    if unit_col is None:
+        unit_col = 2 if len(header_row) > 2 else None
+    if desc_col is None:
+        desc_col = 3 if len(header_row) > 3 else None
+
+    constants: list[Constant] = []
+    for row in ws.iter_rows(min_row=2, values_only=True):
+        if not row or row[name_col] is None:
+            continue
+
+        name = str(row[name_col]).strip()
+        if not name:
+            continue
+
+        raw_value = row[value_col] if value_col < len(row) else None
+        if raw_value is None:
+            continue
+
+        # Preserve numeric types
+        if isinstance(raw_value, (int, float)):
+            value = raw_value
+        else:
+            # Try to parse as number
+            try:
+                value = int(str(raw_value))
+            except ValueError:
+                try:
+                    value = float(str(raw_value))
+                except ValueError:
+                    value = str(raw_value)
+
+        unit = ""
+        if unit_col is not None and unit_col < len(row) and row[unit_col]:
+            unit = str(row[unit_col]).strip()
+
+        description = ""
+        if desc_col is not None and desc_col < len(row) and row[desc_col]:
+            description = str(row[desc_col]).strip()
+
+        constants.append(Constant(name=name, value=value, unit=unit, description=description))
+
+    return constants

{consync-2.0.0 → consync-2.1.0}/consync/renderers/c_struct_table.py

@@ -108,6 +108,10 @@ def render_c_struct_table(
     Only updates literal numeric values that match by row label and field index.
     Expression values and non-matching fields are left unchanged.
 
+    When constants lack "raw" metadata (e.g., coming from Excel), the renderer
+    first parses the existing C file to get current raw values, then uses those
+    for pattern-based replacement — only updating values that actually changed.
+
     Args:
         constants: List of Constant objects (as produced by the parser).
         filepath: Path to the existing .c/.h file to update in place.
@@ -120,8 +124,8 @@ def render_c_struct_table(
             f"This renderer only updates existing files in-place."
         )
 
-    # Build a lookup: (sanitized_label, field_index) → Constant
-    updates: dict[tuple[str, int], Constant] = {}
+    # Build a lookup: (variant, sanitized_label, field_index) → Constant
+    updates: dict[tuple[str, str, int], Constant] = {}
     for c in constants:
         meta = c.metadata
         if not meta:
@@ -130,26 +134,48 @@ def render_c_struct_table(
             continue  # Don't try to update expressions
         label = meta.get("row_label", "")
         field_idx = meta.get("field_index")
+        variant = meta.get("variant", "")
         if label is not None and field_idx is not None:
-            key = (_sanitize_label(label), field_idx)
+            key = (variant, _sanitize_label(label), field_idx)
             updates[key] = c
 
     if not updates:
         return  # Nothing to update
 
+    # If constants lack "raw" metadata, enrich them from the existing file
+    has_raw = any(c.metadata.get("raw") for c in updates.values())
+    if not has_raw:
+        updates = _enrich_with_raw(updates, filepath, config)
+
+    if not updates:
+        return
+
     text = filepath.read_text(encoding="utf-8")
     lines = text.splitlines(keepends=True)
     result_lines: list[str] = []
 
+    # Track current variant section as we scan lines
+    current_variant = ""
+    # Detect variant from #if/#elif lines using the same logic as the parser
+    variant_re = re.compile(r"#(?:if|elif)\s*\(.*?==\s*\w+?_(\w+)\s*\)")
+
     for line in lines:
+        # Track variant sections
+        variant_match = variant_re.search(line)
+        if variant_match:
+            current_variant = variant_match.group(1)
+
         # Check if this line has a row label and struct data
         label_match = _ROW_LABEL_RE.search(line)
         if label_match and ("{{" in line or ("{" in line and "}" in line)):
             label = label_match.group(1).strip()
             sanitized = _sanitize_label(label)
 
-            # Check if we have any updates for this row
-            row_updates = {idx: c for (lbl, idx), c in updates.items() if lbl == sanitized}
+            # Check if we have any updates for this row in the current variant
+            row_updates = {
+                idx: c for (v, lbl, idx), c in updates.items()
+                if lbl == sanitized and (v == current_variant or v == "")
+            }
             if row_updates:
                 line = _update_row_values(line, row_updates)
 
@@ -158,10 +184,91 @@ def render_c_struct_table(
     filepath.write_text("".join(result_lines), encoding="utf-8")
 
 
+def _enrich_with_raw(
+    updates: dict[tuple[str, str, int], Constant],
+    filepath: Path,
+    config=None,
+) -> dict[tuple[str, str, int], Constant]:
+    """Enrich update constants with 'raw' metadata from the existing C file.
+
+    Parses the current C file to get raw values, then only keeps updates
+    where the new value actually differs from the current value.
+    Returns a filtered dict with raw metadata populated.
+    """
+    from consync.parsers.c_struct_table import parse_c_struct_table
+
+    # Parse the file with parser options from config if available
+    parser_opts = {}
+    if config and hasattr(config, "parser_options"):
+        parser_opts = config.parser_options or {}
+
+    try:
+        current_constants = parse_c_struct_table(filepath, **parser_opts)
+    except Exception:
+        return {}  # Can't parse — skip updates
+
+    # Build lookup of current state: (variant, sanitized_label, field_index) → Constant
+    current_map: dict[tuple[str, str, int], Constant] = {}
+    for c in current_constants:
+        meta = c.metadata
+        if not meta:
+            continue
+        label = meta.get("row_label", "")
+        field_idx = meta.get("field_index")
+        variant = meta.get("variant", "")
+        if label is not None and field_idx is not None:
+            key = (variant, _sanitize_label(label), field_idx)
+            current_map[key] = c
+
+    # Filter: only keep updates where value actually changed
+    # Enrich with raw metadata from current file
+    enriched: dict[tuple[str, str, int], Constant] = {}
+    for key, new_const in updates.items():
+        current = current_map.get(key)
+        if current is None:
+            continue  # Not found in current file, skip
+
+        raw = current.metadata.get("raw", "")
+        if not raw:
+            continue  # No raw value to match against
+
+        # Check if value actually changed
+        if _values_equal(new_const.value, current.value):
+            continue  # Same value, no update needed
+
+        # Create enriched constant with raw metadata
+        enriched_meta = dict(new_const.metadata)
+        enriched_meta["raw"] = raw
+        enriched_const = Constant(
+            name=new_const.name,
+            value=new_const.value,
+            unit=new_const.unit,
+            description=new_const.description,
+            metadata=enriched_meta,
+        )
+        enriched[key] = enriched_const
+
+    return enriched
+
+
+def _values_equal(a, b) -> bool:
+    """Compare two values with tolerance for floating point."""
+    if isinstance(a, float) and isinstance(b, float):
+        if a == 0.0 and b == 0.0:
+            return True
+        if a == 0.0 or b == 0.0:
+            return abs(a - b) < 1e-15
+        return abs(a - b) / max(abs(a), abs(b)) < 1e-9
+    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+        return float(a) == float(b)
+    return a == b
+
+
 def _update_row_values(line: str, row_updates: dict[int, Constant]) -> str:
     """Update specific field values in a struct initializer row.
 
-    Finds the Nth numeric literal in the brace content and replaces it.
+    Uses raw-pattern matching: finds the original literal text in the line
+    and replaces with the new formatted value.
     """
     # Find where the data starts (first {{ after the label comment)
     brace_start = line.find("{{")
@@ -173,35 +280,14 @@ def _update_row_values(line: str, row_updates: dict[int, Constant]) -> str:
     prefix = line[:brace_start]
     data_part = line[brace_start:]
 
-    # Walk through data_part, finding all tokens (numeric literals + expressions)
-    # and tracking field indices
-    field_idx = 0
-    result = ""
-    i = 0
-    brace_depth = 0
-    in_value = False
-    current_value_start = -1
-
-    # We need a smarter approach: tokenize by commas at the correct brace depth
-    # But for replacement, we iterate through and find numeric literals at each position
-
-    # Strategy: find all numeric literal positions in the data portion,
-    # tracking which field index they correspond to
-    # This is approximate — we count comma-separated values at depth 1 or 2
-
-    # Alternative simpler approach: find and replace by matching the original raw value
     for field_idx, const in row_updates.items():
         raw_original = const.metadata.get("raw", "")
         if not raw_original or not isinstance(const.value, (int, float)):
             continue
 
-        # Build a regex pattern that matches the original value (with possible whitespace)
         escaped = re.escape(raw_original)
-        # Allow flexible whitespace around it
         pattern = re.compile(r"(?<![a-zA-Z0-9_.])" + escaped + r"(?![a-zA-Z0-9_.])")
-
         new_value = _format_numeric(const.value, raw_original)
-        # Replace only the first occurrence in the data part
         data_part, count = pattern.subn(new_value, data_part, count=1)
 
     return prefix + data_part

{consync-2.0.0 → consync-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "consync"
-version = "2.0.0"
+version = "2.1.0"
 description = "Bidirectional sync between spreadsheets and source code constants — with full decimal precision."
 readme = "README.md"
 license = {text = "MIT"}