consync 0.1.0__py3-none-any.whl

consync/renderers/json_renderer.py

@@ -0,0 +1,71 @@
+"""JSON renderer — writes constants to a structured JSON file.
+
+Output format:
+    {
+        "_meta": {
+            "generator": "consync",
+            "source": "constants.xlsx",
+            "synced": "2026-05-05T14:30:00"
+        },
+        "constants": [
+            {
+                "name": "R_SENSE",
+                "value": 1.9999999999910001,
+                "unit": "Ohm",
+                "description": "Current sense resistor"
+            },
+            ...
+        ]
+    }
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from consync.models import Constant, MappingConfig
+from consync.renderers import register
+
+
+@register("json")
+def render_json(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as a JSON file with metadata."""
+    filepath = Path(filepath)
+    source_name = config.source if config else kwargs.get("source", "unknown")
+    prefix = config.prefix if config else kwargs.get("prefix", "")
+
+    output = {
+        "_meta": {
+            "generator": "consync",
+            "source": source_name,
+            "synced": datetime.now().isoformat(timespec="seconds"),
+        },
+        "constants": [],
+    }
+
+    for c in constants:
+        name = prefix + c.name
+        if config and config.uppercase_names:
+            name = name.upper()
+
+        entry: dict = {"name": name, "value": c.value}
+        if c.unit:
+            entry["unit"] = c.unit
+        if c.description:
+            entry["description"] = c.description
+
+        output["constants"].append(entry)
+
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text(
+        json.dumps(output, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )

consync/renderers/python_const.py

@@ -0,0 +1,84 @@
+"""Python constants renderer — generates a Python module with typed constants.
+
+Output format:
+    # AUTO-GENERATED by consync — do not edit by hand.
+    # Source: constants.xlsx | Synced: 2026-05-05 14:30:00
+
+    R_SENSE: float = 1.9999999999910001          # Ohm — Current sense resistor
+    R_PULLUP: int = 4706                         # Ohm — I2C pull-up resistor
+    C_FILTER: float = 4.7832940000000000e-07     # F — Input filter capacitor
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from consync.models import Constant, MappingConfig
+from consync.precision import format_float
+from consync.renderers import register
+
+
+@register("python")
+def render_python(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as a Python module with type annotations."""
+    filepath = Path(filepath)
+    precision = config.precision if config else kwargs.get("precision", 17)
+    source_name = config.source if config else kwargs.get("source", "unknown")
+    prefix = config.prefix if config else kwargs.get("prefix", "")
+
+    lines = [
+        f'"""AUTO-GENERATED by consync — do not edit by hand."""',
+        f"# Source: {source_name} | Synced: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        f"# Regenerate: consync sync",
+        f"",
+    ]
+
+    # Calculate alignment
+    names = [prefix + c.name for c in constants]
+    max_name = max((len(n) for n in names), default=10)
+
+    for c in constants:
+        name = prefix + c.name
+        if config and config.uppercase_names:
+            name = name.upper()
+
+        # Build inline comment
+        parts = [p for p in (c.unit, c.description) if p]
+        comment = f"  # {' — '.join(parts)}" if parts else ""
+
+        # Format value with type annotation
+        if isinstance(c.value, list):
+            # Array → list[int] / list[float] / list[str]
+            if c.value and isinstance(c.value[0], int):
+                type_hint = "list[int]"
+                val_str = repr(c.value)
+            elif c.value and isinstance(c.value[0], float):
+                type_hint = "list[float]"
+                val_str = "[" + ", ".join(format_float(v, precision) for v in c.value) + "]"
+            else:
+                type_hint = "list[str]"
+                val_str = repr(c.value)
+        elif isinstance(c.value, int):
+            type_hint = "int"
+            val_str = str(c.value)
+        elif isinstance(c.value, float):
+            type_hint = "float"
+            val_str = format_float(c.value, precision)
+        else:
+            type_hint = "str"
+            val_str = repr(c.value)
+
+        decl = f"{name}: {type_hint}"
+        lines.append(f"{decl:<{max_name + 8}} = {val_str}{comment}")
+
+    lines.append("")  # trailing newline
+
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text("\n".join(lines), encoding="utf-8")

consync/renderers/rust_const.py

@@ -0,0 +1,90 @@
+"""Rust constants renderer — generates const declarations.
+
+Output format:
+    //! AUTO-GENERATED by consync — do not edit by hand.
+    //! Source: constants.xlsx | Synced: 2026-05-05 14:30:00
+
+    /// Current sense resistor (Ohm)
+    pub const R_SENSE: f64 = 1.9999999999910001;
+
+    /// I2C pull-up resistor (Ohm)
+    pub const R_PULLUP: f64 = 4706.0;
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from consync.models import Constant, MappingConfig
+from consync.precision import format_float
+from consync.renderers import register
+
+
+@register("rust")
+def render_rust(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as Rust const declarations."""
+    filepath = Path(filepath)
+    precision = config.precision if config else kwargs.get("precision", 17)
+    source_name = config.source if config else kwargs.get("source", "unknown")
+    prefix = config.prefix if config else kwargs.get("prefix", "")
+
+    lines = [
+        f"//! AUTO-GENERATED by consync — do not edit by hand.",
+        f"//! Source: {source_name} | Synced: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        f"//! Regenerate: consync sync",
+        f"",
+    ]
+
+    for c in constants:
+        name = prefix + c.name
+        if config and config.uppercase_names:
+            name = name.upper()
+
+        # Doc comment
+        parts = [p for p in (c.description, f"({c.unit})" if c.unit else "") if p]
+        if parts:
+            lines.append(f"/// {' '.join(parts)}")
+
+        # Type and value
+        if isinstance(c.value, list):
+            # Array → pub const X: [i64; N] = [1, 2, 3];
+            if c.value and isinstance(c.value[0], int):
+                type_name = "i64"
+                vals = ", ".join(str(v) for v in c.value)
+            elif c.value and isinstance(c.value[0], float):
+                type_name = "f64"
+                formatted = []
+                for v in c.value:
+                    s = format_float(v, precision)
+                    if "." not in s and "e" not in s and "E" not in s:
+                        s += ".0"
+                    formatted.append(s)
+                vals = ", ".join(formatted)
+            else:
+                # String arrays — use &str
+                type_name = "&str"
+                vals = ", ".join(f'"{v}"' for v in c.value)
+            lines.append(f"pub const {name}: [{type_name}; {len(c.value)}] = [{vals}];")
+        elif isinstance(c.value, int):
+            type_name = "i64"
+            val_str = str(c.value)
+            lines.append(f"pub const {name}: {type_name} = {val_str};")
+        else:
+            type_name = "f64"
+            val_str = format_float(c.value, precision)
+            # Rust requires decimal point or scientific notation for f64 literals
+            if "." not in val_str and "e" not in val_str and "E" not in val_str:
+                val_str += ".0"
+            lines.append(f"pub const {name}: {type_name} = {val_str};")
+
+        lines.append("")
+
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text("\n".join(lines), encoding="utf-8")

consync/renderers/verilog.py

@@ -0,0 +1,89 @@
+"""Verilog/SystemVerilog renderer — generates parameter declarations.
+
+Output format (Verilog):
+    // AUTO-GENERATED by consync — do not edit by hand.
+    // Source: constants.xlsx | Synced: 2026-05-05 14:30:00
+
+    parameter real R_SENSE         = 1.9999999999910001;  // Ohm — Current sense resistor
+    parameter real R_PULLUP        = 4706.0;              // Ohm — I2C pull-up resistor
+    parameter real FREQ_SWITCH     = 299872.93847293;     // Hz — Switching frequency
+
+Output format (module wrapper):
+    module design_params;
+        parameter real R_SENSE = 1.9999999999910001;
+        ...
+    endmodule
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from consync.models import Constant, MappingConfig
+from consync.precision import format_float
+from consync.renderers import register
+
+
+@register("verilog")
+def render_verilog(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as Verilog/SystemVerilog parameters."""
+    filepath = Path(filepath)
+    precision = config.precision if config else kwargs.get("precision", 17)
+    source_name = config.source if config else kwargs.get("source", "unknown")
+    prefix = config.prefix if config else kwargs.get("prefix", "")
+    module_name = config.module_name if config else kwargs.get("module_name", "")
+
+    lines = [
+        f"// AUTO-GENERATED by consync — do not edit by hand.",
+        f"// Source: {source_name} | Synced: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        f"// Regenerate: consync sync",
+        f"",
+    ]
+
+    indent = ""
+    if module_name:
+        lines.append(f"module {module_name};")
+        lines.append("")
+        indent = "    "
+
+    # Calculate alignment
+    names = [prefix + c.name for c in constants]
+    name_width = max((len(n) for n in names), default=20) + 2
+
+    for c in constants:
+        name = prefix + c.name
+        if config and config.uppercase_names:
+            name = name.upper()
+
+        # Verilog types
+        if isinstance(c.value, int):
+            type_kw = "integer"
+            val_str = str(c.value)
+        else:
+            type_kw = "real"
+            val_str = format_float(c.value, precision)
+            # Verilog real literals need a decimal point
+            if "." not in val_str and "e" not in val_str and "E" not in val_str:
+                val_str += ".0"
+
+        # Comment
+        parts = [p for p in (c.unit, c.description) if p]
+        comment = f"  // {' — '.join(parts)}" if parts else ""
+
+        lines.append(f"{indent}parameter {type_kw} {name:<{name_width}} = {val_str};{comment}")
+
+    if module_name:
+        lines.append("")
+        lines.append("endmodule")
+
+    lines.append("")
+
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text("\n".join(lines), encoding="utf-8")

consync/renderers/vhdl.py

@@ -0,0 +1,94 @@
+"""VHDL renderer — generates constant declarations in a package.
+
+Output format:
+    -- AUTO-GENERATED by consync — do not edit by hand.
+    -- Source: constants.xlsx | Synced: 2026-05-05 14:30:00
+
+    library ieee;
+    use ieee.std_logic_1164.all;
+    use ieee.math_real.all;
+
+    package hw_constants is
+        constant R_SENSE       : real := 1.9999999999910001;  -- Ohm | Current sense resistor
+        constant R_PULLUP      : real := 4706.0;              -- Ohm | I2C pull-up resistor
+        constant FREQ_SWITCH   : real := 299872.93847293;     -- Hz | Switching frequency
+    end package hw_constants;
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from consync.models import Constant, MappingConfig
+from consync.precision import format_float
+from consync.renderers import register
+
+
+@register("vhdl")
+def render_vhdl(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as a VHDL package."""
+    filepath = Path(filepath)
+    precision = config.precision if config else kwargs.get("precision", 17)
+    source_name = config.source if config else kwargs.get("source", "unknown")
+    prefix = config.prefix if config else kwargs.get("prefix", "")
+    module_name = config.module_name if config else kwargs.get("module_name", "")
+
+    # Package name: from module_name or derive from filename
+    pkg_name = module_name or filepath.stem.replace("-", "_").replace(".", "_")
+
+    lines = [
+        f"-- AUTO-GENERATED by consync — do not edit by hand.",
+        f"-- Source: {source_name} | Synced: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        f"-- Regenerate: consync sync",
+        f"",
+        f"library ieee;",
+        f"use ieee.std_logic_1164.all;",
+        f"use ieee.math_real.all;",
+        f"",
+        f"package {pkg_name} is",
+        f"",
+    ]
+
+    # Calculate alignment
+    names = [prefix + c.name for c in constants]
+    name_width = max((len(n) for n in names), default=20) + 2
+
+    for c in constants:
+        name = prefix + c.name
+        if config and config.uppercase_names:
+            name = name.upper()
+
+        # VHDL types
+        if isinstance(c.value, int):
+            type_name = "integer"
+            val_str = str(c.value)
+        else:
+            type_name = "real"
+            val_str = format_float(c.value, precision)
+            # VHDL real literals need a decimal point
+            if "." not in val_str and "e" not in val_str and "E" not in val_str:
+                val_str += ".0"
+
+        # Comment
+        parts = [p for p in (c.unit, c.description) if p]
+        comment = f"  -- {' | '.join(parts)}" if parts else ""
+
+        lines.append(
+            f"    constant {name:<{name_width}} : {type_name} := {val_str};{comment}"
+        )
+
+    lines += [
+        f"",
+        f"end package {pkg_name};",
+        f"",
+    ]
+
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text("\n".join(lines), encoding="utf-8")

consync/state.py

@@ -0,0 +1,76 @@
+"""State management — hash-based change detection for sync.
+
+Tracks MD5 hashes of constant data (name+value pairs) to detect which
+side changed since last sync. This enables smart bidirectional sync:
+
+    - If only source changed → sync source → target
+    - If only target changed → sync target → source
+    - If both changed → conflict (resolve per on_conflict setting)
+    - If neither changed → skip (already in sync)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+from consync.models import Constant
+
+
+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.
+    """
+    key = json.dumps(
+        {c.name: c.value for c in constants},
+        sort_keys=True,
+        default=str,
+    )
+    return hashlib.md5(key.encode()).hexdigest()
+
+
+class SyncState:
+    """Persistent sync state stored in .consync.state.json."""
+
+    def __init__(self, state_file: Path):
+        self.state_file = state_file
+        self._data: dict = {}
+        self._load()
+
+    def _load(self):
+        if self.state_file.exists():
+            try:
+                self._data = json.loads(self.state_file.read_text())
+            except (json.JSONDecodeError, OSError):
+                self._data = {}
+        else:
+            self._data = {}
+
+    def _save(self):
+        self.state_file.write_text(json.dumps(self._data, indent=2) + "\n")
+
+    def get_hash(self, mapping_key: str, side: str) -> str | None:
+        """Get the stored hash for a mapping side ('source' or 'target')."""
+        entry = self._data.get(mapping_key, {})
+        return entry.get(side)
+
+    def set_hash(self, mapping_key: str, source_hash: str, target_hash: str):
+        """Update stored hashes after a successful sync."""
+        self._data[mapping_key] = {
+            "source": source_hash,
+            "target": target_hash,
+        }
+        self._save()
+
+    def mapping_key(self, source: str, target: str) -> str:
+        """Generate a stable key for a source/target pair."""
+        return f"{source}::{target}"
+
+    def clear(self):
+        """Reset all state."""
+        self._data = {}
+        if self.state_file.exists():
+            self.state_file.unlink()