consync 2.2.3__tar.gz → 2.3.1__tar.gz

{consync-2.2.3 → consync-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: consync
-Version: 2.2.3
+Version: 2.3.1
 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.2.3 → consync-2.3.1}/consync/__init__.py

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

{consync-2.2.3 → consync-2.3.1}/consync/renderers/c_struct_table.py

@@ -41,7 +41,12 @@ def _sanitize_label(label: str) -> str:
 def _format_numeric(value: float | int, original_raw: str = "") -> str:
     """Format a numeric value back to C literal, preserving style of original.
 
-    Tries to maintain scientific notation, F suffix, etc. from the original.
+    Preserves:
+      1. Original exponent for scientific notation (E-3 stays E-3)
+      2. Lowercase/uppercase 'e'/'E'
+      3. Mantissa format (with/without decimal point)
+      4. Precision (number of decimal digits)
+      5. Exponent digit count (E-03 vs E-3)
     """
     if isinstance(value, int):
         if original_raw and original_raw.strip().startswith(("0x", "0X")):
@@ -55,42 +60,88 @@ def _format_numeric(value: float | int, original_raw: str = "") -> str:
         return f"{value}{suffix}"
 
     # Float value
-    suffix = "F"
+    suffix = "F"  # default
     if original_raw:
-        stripped = original_raw.strip().rstrip("fFlL")
-        if original_raw.strip().endswith("f") or original_raw.strip().endswith("F"):
-            suffix = original_raw.strip()[-1]
+        stripped = original_raw.strip()
+        if stripped.endswith("f"):
+            suffix = "f"
+        elif stripped.endswith("F"):
+            suffix = "F"
+        elif stripped.endswith("L") or stripped.endswith("l"):
+            suffix = stripped[-1]
         else:
             suffix = ""
 
     # Check if original used scientific notation
-    if original_raw and ("e" in original_raw.lower() or "E" in original_raw):
-        # Format in scientific notation
-        # Detect the exponent style from original
-        formatted = f"{value:E}"
-        # Simplify: use same number of significant digits as original
-        orig_stripped = original_raw.strip().rstrip("fFlL")
-        if "." in orig_stripped:
-            # Count digits after decimal before E
-            parts = orig_stripped.upper().split("E")
-            if "." in parts[0]:
-                decimal_digits = len(parts[0].split(".")[1])
+    if original_raw and ("e" in original_raw or "E" in original_raw):
+        # Determine case of exponent character
+        use_lowercase = "e" in original_raw and "E" not in original_raw
+        exp_char = "e" if use_lowercase else "E"
+
+        # Extract original exponent value
+        orig_no_suffix = original_raw.strip().rstrip("fFlLuU")
+        exp_match = re.search(r"[eE]([+-]?\d+)", orig_no_suffix)
+        if exp_match:
+            orig_exponent = int(exp_match.group(1))
+
+            # Handle negative values
+            sign = ""
+            abs_value = value
+            if value < 0:
+                sign = "-"
+                abs_value = abs(value)
+
+            # Calculate new mantissa preserving the original exponent
+            # value = mantissa * 10^exponent  =>  mantissa = value / 10^exponent
+            if abs_value == 0:
+                new_mantissa = 0.0
             else:
-                decimal_digits = 2
-        else:
-            decimal_digits = 2
+                new_mantissa = abs_value / (10 ** orig_exponent)
 
-        formatted = f"{value:.{decimal_digits}E}"
-        return f"{formatted}{suffix}"
+            # Determine mantissa format from original
+            mantissa_part = orig_no_suffix.split("e")[0].split("E")[0]
+            mantissa_part = mantissa_part.lstrip("+-")
+
+            if "." in mantissa_part:
+                decimal_digits = len(mantissa_part.split(".")[1])
+                mantissa_str = f"{new_mantissa:.{decimal_digits}f}"
+            else:
+                # No decimal in original (like "1E-2")
+                mantissa_str = f"{int(round(new_mantissa))}"
+
+            # Preserve exponent format (E-03 vs E-3, leading zeros)
+            exp_match_full = re.search(r"[eE]([+-]?)(\d+)", orig_no_suffix)
+            if exp_match_full:
+                exp_sign_char = exp_match_full.group(1)
+                exp_digit_count = len(exp_match_full.group(2))
+                if orig_exponent < 0:
+                    exp_sign_str = "-"
+                elif exp_sign_char == "+":
+                    exp_sign_str = "+"
+                else:
+                    exp_sign_str = ""
+                exp_abs = abs(orig_exponent)
+                exp_str = f"{exp_sign_str}{exp_abs:0{exp_digit_count}d}"
+            else:
+                exp_str = f"{orig_exponent:+d}"
+
+            formatted = f"{sign}{mantissa_str}{exp_char}{exp_str}"
+            return f"{formatted}{suffix}"
+        else:
+            # Fallback (shouldn't happen if we got here)
+            formatted = f"{value:E}"
+            return f"{formatted}{suffix}"
     else:
-        # Regular float notation
+        # Regular float notation (no scientific notation in original)
         if original_raw:
             orig_stripped = original_raw.strip().rstrip("fFlL")
             if "." in orig_stripped:
                 decimal_digits = len(orig_stripped.split(".")[1])
                 formatted = f"{value:.{decimal_digits}f}"
             else:
-                formatted = str(value)
+                formatted = (
+                    str(int(round(value))) if value == int(value) else str(value)
+                )
         else:
             formatted = str(value)
         return f"{formatted}{suffix}"

{consync-2.2.3 → consync-2.3.1}/consync/state.py

@@ -18,17 +18,45 @@ from pathlib import Path
 from consync.models import Constant
 
 
+def _normalize_value(v):
+    """Normalize a constant value for stable hashing.
+
+    Ensures int/float equivalence: C produces 1.0 (float) for ``1.0F``,
+    but Excel stores it as integer 1.  Without normalization these hash
+    differently, causing perpetual "out of sync" after every round-trip.
+
+    Rules:
+      - int/float that are whole numbers → canonical float (``1.0``)
+      - list values → each element normalized recursively
+      - strings → unchanged
+    """
+    if isinstance(v, list):
+        return [_normalize_value(x) for x in v]
+    if isinstance(v, (int, float)) and not isinstance(v, bool):
+        return float(v)
+    return v
+
+
 def compute_hash(constants: list[Constant]) -> str:
     """Compute a stable hash of constant name+value pairs.
 
     Only hashes names and values (not unit/description) since those
     are the semantically meaningful content for sync detection.
+
+    Uses a sorted list of (name, value) tuples instead of a dict to
+    correctly handle duplicate constant names (e.g., multi-variant
+    struct tables where Motor_X__R_Phase appears once per variant).
+    A dict would silently discard all but the last duplicate, making
+    edits to earlier variants invisible to change detection.
+
+    Numeric values are normalized to float so that ``int 1`` and
+    ``float 1.0`` hash identically — this is critical for xlsx
+    round-trips where Excel drops the ``.0`` from whole numbers.
     """
-    key = json.dumps(
-        {c.name: c.value for c in constants},
-        sort_keys=True,
-        default=str,
+    pairs = sorted(
+        (c.name, _normalize_value(c.value)) for c in constants
     )
+    key = json.dumps(pairs, default=str)
     return hashlib.md5(key.encode()).hexdigest()
 
 

{consync-2.2.3 → consync-2.3.1}/consync/watcher.py

@@ -6,6 +6,11 @@ No `brew install` required — pure Python.
 Event handling:
   - Changes during debounce are QUEUED, not dropped
   - After debounce expires, all queued events are coalesced into one sync
+  - Write suppression prevents ping-pong loops (sync-written files are
+    ignored for a short window so they don't re-trigger sync)
+  - Direction is NEVER forced — the state engine auto-detects which side
+    changed using stored hashes, which correctly returns "already in sync"
+    for files that were just written by the sync itself
   - Lock conflicts trigger automatic retry after a short delay
   - Errors are logged but the watcher continues (resilient)
   - On startup, a full sync is run to recover from any drift
@@ -29,6 +34,10 @@ logger = logging.getLogger(__name__)
 LOCK_RETRY_ATTEMPTS = 3
 LOCK_RETRY_DELAY = 2.0  # seconds between retries
 
+# Write suppression: ignore events on files we just wrote for this duration (seconds).
+# Must be longer than filesystem event propagation but shorter than user interaction.
+WRITE_SUPPRESSION_WINDOW = 2.0
+
 
 def start_watcher(
     config_path: str | Path | None = None,
@@ -84,10 +93,14 @@ def start_watcher(
         click.echo(f"[startup] ⚠️  Startup sync failed: {e} — continuing in watch mode.\n")
 
     # ── Event queue (thread-safe) — changes are QUEUED, never dropped ──
-    pending_changes: dict[Path, str] = {}  # path → forced direction
+    pending_changes: dict[Path, str] = {}  # path → info about what changed
     pending_lock = threading.Lock()
     last_sync_time: float = 0
 
+    # ── Write suppression — tracks files recently written by sync ──
+    recently_written: dict[Path, float] = {}  # path → timestamp of sync write
+    written_lock = threading.Lock()
+
     class SyncHandler(FileSystemEventHandler):
         def on_modified(self, event):
             if event.is_directory:
@@ -97,22 +110,22 @@ def start_watcher(
             if changed_path not in watch_files:
                 return
 
-            # Determine direction based on which file changed
-            force = None
-            for m in cfg.mappings:
-                source_resolved = (config_dir / m.source).resolve()
-                target_resolved = (config_dir / m.target).resolve()
-                if changed_path == source_resolved:
-                    force = "source"
-                    break
-                elif changed_path == target_resolved:
-                    force = "target"
-                    break
-
-            # Queue the event (never drop)
+            # Write suppression: skip events caused by sync's own writes
+            with written_lock:
+                written_time = recently_written.get(changed_path)
+                if written_time and (time.time() - written_time) < WRITE_SUPPRESSION_WINDOW:
+                    logger.debug(
+                        "Suppressed event for %s (written %.1fs ago by sync)",
+                        changed_path.name,
+                        time.time() - written_time,
+                    )
+                    return
+
+            # Queue the event (never drop). Don't force direction — let
+            # the state engine auto-detect using stored hashes.
             with pending_lock:
-                pending_changes[changed_path] = force
-                logger.debug("Queued: %s (direction=%s)", changed_path.name, force)
+                pending_changes[changed_path] = changed_path.name
+                logger.debug("Queued: %s", changed_path.name)
 
     def _process_queue():
         """Process all pending changes in one coalesced sync."""
@@ -125,24 +138,25 @@ def start_watcher(
             queued = dict(pending_changes)
             pending_changes.clear()
 
-        # Determine overall force direction (if all queued point same way)
-        directions = set(queued.values())
-        if len(directions) == 1:
-            force = directions.pop()
-        else:
-            force = None  # mixed — let engine auto-detect
-
         rel_names = [p.name for p in queued.keys()]
         timestamp = time.strftime("%H:%M:%S")
         click.echo(f"[{timestamp}] 📝 {', '.join(rel_names)} changed — syncing...")
 
+        # Never force direction — let the state engine auto-detect which
+        # side changed using stored hashes.  This prevents ping-pong:
+        # after sync writes file B, B's hash matches the stored hash,
+        # so the next cycle correctly detects "already in sync".
+
         # Retry on lock conflict
         for attempt in range(LOCK_RETRY_ATTEMPTS):
             try:
-                reports = sync(config_path=config_path, force_direction=force)
+                reports = sync(config_path=config_path)
                 for r in reports:
                     if r.result in (SyncResult.SYNCED_SOURCE_TO_TARGET, SyncResult.SYNCED_TARGET_TO_SOURCE):
                         click.echo(f"         ✅ {r.message}")
+                        # Register written files for suppression so their
+                        # filesystem events don't re-trigger another sync.
+                        _suppress_written_files(r, config_dir)
                     elif r.result == SyncResult.ALREADY_IN_SYNC:
                         pass  # silent
                     elif r.result == SyncResult.ERROR:
@@ -158,6 +172,27 @@ def start_watcher(
                     logger.error("Watch sync failed: %s", e)
                     return
 
+    def _suppress_written_files(report, conf_dir):
+        """Mark files written by sync for suppression so their events are ignored."""
+        now = time.time()
+        with written_lock:
+            # Determine which file was written based on sync direction
+            if report.result == SyncResult.SYNCED_SOURCE_TO_TARGET:
+                # source → target: target was written
+                written_path = (conf_dir / report.target).resolve()
+                recently_written[written_path] = now
+            elif report.result == SyncResult.SYNCED_TARGET_TO_SOURCE:
+                # target → source: source was written
+                written_path = (conf_dir / report.source).resolve()
+                recently_written[written_path] = now
+
+        # Prune old entries to prevent memory leak
+        with written_lock:
+            cutoff = now - WRITE_SUPPRESSION_WINDOW * 3
+            stale = [p for p, t in recently_written.items() if t < cutoff]
+            for p in stale:
+                del recently_written[p]
+
     observer = Observer()
     handler = SyncHandler()
 

{consync-2.2.3 → consync-2.3.1}/pyproject.toml

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