consync 2.0.0__tar.gz → 2.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: consync
-Version: 2.0.0
+Version: 2.2.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
@@ -70,10 +70,11 @@ Keep a single source of truth for hardware constants (resistor values, timing pa
      │    Parsers      │  │   State     │  │   Renderers    │
      │                 │  │  Tracker    │  │                │
      │ • xlsx          │  │             │  │ • c_header     │
-     │ • csv           │  │ MD5 hashes  │  │ • csharp       │
-     │ • json          │  │ per-mapping │  │ • python       │
-     │ • toml          │  │ in .json    │  │ • rust         │
-     │ • c_header      │  │             │  │ • verilog      │
+     │ • csv           │  │ MD5 hashes  │  │ • c_struct_table│
+     │ • json          │  │ per-mapping │  │ • csharp       │
+     │ • toml          │  │ in .json    │  │ • python       │
+     │ • c_header      │  │             │  │ • rust         │
+     │ • c_struct_table │  │             │  │ • verilog      │
      └────────┬────────┘  └──────┬──────┘  │ • vhdl         │
               │                  │          │ • json          │
               │                  │          │ • csv           │
@@ -200,17 +201,19 @@ consync install-hook
 
 | Format | Extension | Notes |
 |--------|-----------|-------|
-| Excel | `.xlsx` | Auto-detects column headers |
+| Excel | `.xlsx` | Auto-detects flat or table layout (multi-variant) |
 | CSV | `.csv`, `.tsv` | Auto-detects delimiter |
-| JSON | `.json` | Flat, array, or nested |
+| JSON | `.json` | Flat, array, nested, or structured (`_meta` + `constants`) |
 | TOML | `.toml` | Flat or table-with-metadata |
 | C Header | `.h` | Parses `const`, `#define`, hex/int/float |
+| C Struct Table | `.c` | Multi-variant `#if`/`#elif` struct arrays (Bosch-style) |
 
 ### Targets (output)
 
 | Format | Extension | Features |
 |--------|-----------|----------|
 | C Header | `.h` | `const` or `#define`, `static`, `stdint.h` types, hex |
+| C Struct Table | `.c` | In-place update of multi-variant struct arrays (minimal diffs) |
 | C# | `.cs` | `namespace`, `public static class`, XML doc comments |
 | Python | `.py` | Type annotations (`float`/`int`), inline comments |
 | Rust | `.rs` | `pub const`, `f64`/`i64`, doc comments |
@@ -218,6 +221,7 @@ consync install-hook
 | VHDL | `.vhd` | Package with `ieee.math_real`, typed constants |
 | JSON | `.json` | Structured with `_meta` header |
 | CSV | `.csv` | Round-trip back to spreadsheet |
+| Excel | `.xlsx` | Multi-sheet table layout (one sheet per variant) |
 
 ---
 
@@ -581,7 +585,7 @@ Each entry records: timestamp, user, direction, files, all constant names+values
 git clone https://github.com/naveenkumarbaskaran/consync.git
 cd consync
 pip install -e ".[dev]"
-pytest   # 151 tests
+pytest   # 261 tests
 ```
 
 ---

{consync-2.0.0 → consync-2.2.0}/README.md

@@ -35,10 +35,11 @@ Keep a single source of truth for hardware constants (resistor values, timing pa
      │    Parsers      │  │   State     │  │   Renderers    │
      │                 │  │  Tracker    │  │                │
      │ • xlsx          │  │             │  │ • c_header     │
-     │ • csv           │  │ MD5 hashes  │  │ • csharp       │
-     │ • json          │  │ per-mapping │  │ • python       │
-     │ • toml          │  │ in .json    │  │ • rust         │
-     │ • c_header      │  │             │  │ • verilog      │
+     │ • csv           │  │ MD5 hashes  │  │ • c_struct_table│
+     │ • json          │  │ per-mapping │  │ • csharp       │
+     │ • toml          │  │ in .json    │  │ • python       │
+     │ • c_header      │  │             │  │ • rust         │
+     │ • c_struct_table │  │             │  │ • verilog      │
      └────────┬────────┘  └──────┬──────┘  │ • vhdl         │
               │                  │          │ • json          │
               │                  │          │ • csv           │
@@ -165,17 +166,19 @@ consync install-hook
 
 | Format | Extension | Notes |
 |--------|-----------|-------|
-| Excel | `.xlsx` | Auto-detects column headers |
+| Excel | `.xlsx` | Auto-detects flat or table layout (multi-variant) |
 | CSV | `.csv`, `.tsv` | Auto-detects delimiter |
-| JSON | `.json` | Flat, array, or nested |
+| JSON | `.json` | Flat, array, nested, or structured (`_meta` + `constants`) |
 | TOML | `.toml` | Flat or table-with-metadata |
 | C Header | `.h` | Parses `const`, `#define`, hex/int/float |
+| C Struct Table | `.c` | Multi-variant `#if`/`#elif` struct arrays (Bosch-style) |
 
 ### Targets (output)
 
 | Format | Extension | Features |
 |--------|-----------|----------|
 | C Header | `.h` | `const` or `#define`, `static`, `stdint.h` types, hex |
+| C Struct Table | `.c` | In-place update of multi-variant struct arrays (minimal diffs) |
 | C# | `.cs` | `namespace`, `public static class`, XML doc comments |
 | Python | `.py` | Type annotations (`float`/`int`), inline comments |
 | Rust | `.rs` | `pub const`, `f64`/`i64`, doc comments |
@@ -183,6 +186,7 @@ consync install-hook
 | VHDL | `.vhd` | Package with `ieee.math_real`, typed constants |
 | JSON | `.json` | Structured with `_meta` header |
 | CSV | `.csv` | Round-trip back to spreadsheet |
+| Excel | `.xlsx` | Multi-sheet table layout (one sheet per variant) |
 
 ---
 
@@ -546,7 +550,7 @@ Each entry records: timestamp, user, direction, files, all constant names+values
 git clone https://github.com/naveenkumarbaskaran/consync.git
 cd consync
 pip install -e ".[dev]"
-pytest   # 151 tests
+pytest   # 261 tests
 ```
 
 ---

{consync-2.0.0 → consync-2.2.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.2.0}/consync/config.py

@@ -80,6 +80,26 @@ def _parse_direction(raw: str) -> SyncDirection:
     return mapping[normalized]
 
 
+def _format_matches_extension(format_name: str, filepath: str) -> bool:
+    """Check if a format name is compatible with a file's extension."""
+    ext = Path(filepath).suffix.lower()
+    # Map format names to compatible extensions
+    FORMAT_COMPATIBLE_EXTENSIONS: dict[str, set[str]] = {
+        "c_header": {".c", ".h", ".hpp", ".hh"},
+        "c_struct_table": {".c", ".h", ".hpp", ".hh"},
+        "xlsx": {".xlsx", ".xls"},
+        "csv": {".csv"},
+        "json": {".json"},
+        "verilog": {".v", ".sv"},
+        "vhdl": {".vhd", ".vhdl"},
+        "python": {".py"},
+        "rust": {".rs"},
+        "csharp": {".cs"},
+    }
+    compatible = FORMAT_COMPATIBLE_EXTENSIONS.get(format_name, set())
+    return ext in compatible
+
+
 def _parse_mapping(raw: dict[str, Any], config_dir: Path) -> MappingConfig:
     """Parse a single mapping entry from YAML."""
     source = raw.get("source", "")
@@ -90,8 +110,19 @@ def _parse_mapping(raw: dict[str, Any], config_dir: Path) -> MappingConfig:
     if not target:
         raise ValueError("Each mapping must have a 'target' field.")
 
+    generic_format = raw.get("format", "")
     source_format = raw.get("source_format", "") or raw.get("format_source", "")
-    target_format = raw.get("target_format", "") or raw.get("format_target", "") or raw.get("format", "")
+    target_format = raw.get("target_format", "") or raw.get("format_target", "")
+
+    # If generic 'format' is specified, assign it to the side whose extension matches
+    if generic_format:
+        if not source_format and _format_matches_extension(generic_format, source):
+            source_format = generic_format
+        elif not target_format and _format_matches_extension(generic_format, target):
+            target_format = generic_format
+        elif not target_format:
+            # Legacy fallback: assign to target_format (backward compat)
+            target_format = generic_format
 
     # Auto-detect formats if not specified
     if not source_format:

{consync-2.0.0 → consync-2.2.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.2.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.2.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.2.0}/pyproject.toml

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