consync 0.1.0__py3-none-any.whl

consync/precision.py

@@ -0,0 +1,148 @@
+"""Precision-preserving number formatting for IEEE 754 doubles.
+
+The core problem: hardware constants have 15-17 significant digits.
+Excel stores them as IEEE 754 doubles. When writing to C/Verilog/Python,
+we must preserve ALL significant digits to guarantee round-trip fidelity:
+
+    parse(format(x)) == x
+
+Default: 17 significant digits (maximum for double precision).
+"""
+
+from __future__ import annotations
+
+import math
+from decimal import Decimal
+
+
+def format_float(value: float, precision: int = 17) -> str:
+    """Format a float preserving significant digits.
+
+    Uses Python's `g` format which automatically chooses between
+    fixed-point and scientific notation for best readability.
+
+    Args:
+        value: The float to format.
+        precision: Number of significant digits (1-21). Default 17.
+
+    Returns:
+        String representation with full precision.
+
+    Examples:
+        >>> format_float(1.20029384729384)
+        '1.20029384729384'
+        >>> format_float(0.00000047832940)
+        '4.783294e-07'
+        >>> format_float(100029.4829183)
+        '100029.4829183'
+        >>> format_float(4700.0)
+        '4700'
+    """
+    if precision < 1:
+        precision = 1
+    if precision > 21:
+        precision = 21
+
+    if math.isnan(value):
+        return "NAN"
+    if math.isinf(value):
+        return "INF" if value > 0 else "-INF"
+
+    formatted = f"{value:.{precision}g}"
+
+    # Ensure no trailing zeros that add false precision,
+    # but keep at least one digit after decimal for floats
+    return formatted
+
+
+def format_c_double(value: float, precision: int = 17) -> str:
+    """Format a float for C/C++ const double declaration.
+
+    Always produces a string that, when parsed by a C compiler,
+    yields the exact same IEEE 754 bit pattern.
+
+    Examples:
+        >>> format_c_double(4.7832940e-07)
+        '4.7832940000000000e-07'
+        >>> format_c_double(4700.0)
+        '4700'
+        >>> format_c_double(1.20029384729384)
+        '1.20029384729384'
+    """
+    return format_float(value, precision)
+
+
+def format_scientific(value: float, precision: int = 17) -> str:
+    """Always use scientific notation (for Verilog/VHDL real parameters).
+
+    Examples:
+        >>> format_scientific(4700.0)
+        '4.7e+03'
+        >>> format_scientific(0.00000047832940)
+        '4.783294e-07'
+    """
+    if precision < 1:
+        precision = 1
+    return f"{value:.{precision}e}"
+
+
+def format_fixed(value: float, decimal_places: int = 14) -> str:
+    """Fixed-point notation with explicit decimal places.
+
+    Examples:
+        >>> format_fixed(1.20029384729384, 14)
+        '1.20029384729384'
+    """
+    return f"{value:.{decimal_places}f}".rstrip("0").rstrip(".")
+
+
+def parse_number(text: str) -> float | int:
+    """Parse a numeric string, preserving int vs float distinction.
+
+    Handles scientific notation, underscores (Rust/Verilog style),
+    and common suffixes.
+
+    Examples:
+        >>> parse_number("4.7832940e-07")
+        4.783294e-07
+        >>> parse_number("4700")
+        4700
+        >>> parse_number("1_000_000")
+        1000000
+        >>> parse_number("0xFF")
+        255
+    """
+    text = text.strip().replace("_", "")
+
+    # Hex literals
+    if text.lower().startswith("0x"):
+        return int(text, 16)
+
+    # Binary literals
+    if text.lower().startswith("0b"):
+        return int(text, 2)
+
+    # Try int first
+    try:
+        val = int(text)
+        return val
+    except ValueError:
+        pass
+
+    # Then float
+    return float(text)
+
+
+def significant_digits(value: float) -> int:
+    """Count the significant digits in a float's representation.
+
+    Uses Decimal to get the shortest representation that round-trips.
+    """
+    if value == 0:
+        return 1
+    d = Decimal(str(value))
+    # sign, digits, exponent
+    _, digits, _ = d.as_tuple()
+    # Strip trailing zeros
+    stripped = str(int("".join(str(d) for d in digits))).rstrip("0")
+    return len(stripped) if stripped else 1

consync/renderers/__init__.py

@@ -0,0 +1,49 @@
+"""Renderer registry — maps format names to renderer functions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+from consync.models import Constant
+
+# Type for renderer functions: (constants, filepath, **kwargs) -> None
+RendererFunc = Callable[..., None]
+
+_REGISTRY: dict[str, RendererFunc] = {}
+
+
+def register(name: str):
+    """Decorator to register a renderer function."""
+    def decorator(func: RendererFunc) -> RendererFunc:
+        _REGISTRY[name] = func
+        return func
+    return decorator
+
+
+def get_renderer(format_name: str) -> RendererFunc:
+    """Get a renderer by format name."""
+    if format_name not in _REGISTRY:
+        available = ", ".join(sorted(_REGISTRY.keys()))
+        raise ValueError(
+            f"Unknown renderer format '{format_name}'. Available: {available}"
+        )
+    return _REGISTRY[format_name]
+
+
+def list_renderers() -> list[str]:
+    """List all registered renderer format names."""
+    return sorted(_REGISTRY.keys())
+
+
+# Import all renderer modules to trigger registration
+from consync.renderers import (  # noqa: E402, F401
+    c_header,
+    csharp,
+    csv_renderer,
+    python_const,
+    rust_const,
+    verilog,
+    vhdl,
+    json_renderer,
+)

consync/renderers/c_header.py

@@ -0,0 +1,222 @@
+"""C/C++ header renderer — generates const declarations or #define macros.
+
+Supports:
+    - `const double` (default) or `#define` output style
+    - `static const` for multi-TU safety
+    - Typed integers: uint32_t / int32_t / uint16_t / int16_t / uint8_t / int8_t
+    - Array constants: static const int X[] = {1, 2, 3};
+    - Configurable precision for doubles/floats
+
+Output examples:
+
+    Style "const" (default):
+        static const uint32_t R_PULLUP = 4706U;  /* Ohm | I2C pull-up */
+        static const double   R_SENSE  = 1.9999999999910001;  /* Ohm | Sense R */
+        static const int THRESHOLDS[] = {50, 100, 150, 200, 250};  /* bar | Brake thresholds */
+
+    Style "define":
+        #define R_PULLUP  (4706U)   /* Ohm | I2C pull-up */
+        #define R_SENSE   (1.9999999999910001)  /* Ohm | Sense R */
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from consync.models import Constant, MappingConfig
+from consync.precision import format_c_double
+from consync.renderers import register
+
+
+def _c_type_for_int(value: int, typed_ints: bool) -> tuple[str, str]:
+    """Determine C type and suffix for an integer value.
+
+    Returns (type_name, literal_suffix).
+    """
+    if not typed_ints:
+        return ("int", "")
+
+    if value < 0:
+        if -128 <= value <= 127:
+            return ("int8_t", "")
+        elif -32768 <= value <= 32767:
+            return ("int16_t", "")
+        elif -2147483648 <= value <= 2147483647:
+            return ("int32_t", "")
+        else:
+            return ("int64_t", "LL")
+    else:
+        if value <= 255:
+            return ("uint8_t", "U")
+        elif value <= 65535:
+            return ("uint16_t", "U")
+        elif value <= 4294967295:
+            return ("uint32_t", "U")
+        else:
+            return ("uint64_t", "ULL")
+
+
+def _c_type_for_float(value: float) -> str:
+    """Determine C float type — always double for full precision."""
+    return "double"
+
+
+@register("c_header")
+def render_c_header(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as a C/C++ header file.
+
+    Args:
+        constants: Constants to write.
+        filepath: Output .h file path.
+        config: Mapping config (for precision, header_guard, output_style, etc.)
+    """
+    filepath = Path(filepath)
+    precision = config.precision if config else kwargs.get("precision", 17)
+    source_name = config.source if config else kwargs.get("source", "unknown")
+    output_style = (config.output_style if config else kwargs.get("output_style", "const")).lower()
+    static = config.static_const if config else kwargs.get("static_const", False)
+    typed_ints = config.typed_ints if config else kwargs.get("typed_ints", True)
+
+    # Determine header guard
+    guard = ""
+    if config and config.header_guard:
+        guard = config.header_guard
+    else:
+        guard = filepath.stem.upper().replace("-", "_").replace(".", "_") + "_H"
+
+    # Prefix handling
+    prefix = config.prefix if config else kwargs.get("prefix", "")
+
+    # Calculate alignment
+    names = [prefix + c.name for c in constants]
+    name_width = max((len(n) for n in names), default=20) + 2
+
+    # Qualifier for const style
+    qualifier = "static const" if static else "const"
+
+    # Include for stdint types
+    needs_stdint = typed_ints and any(
+        isinstance(c.value, int) or
+        (isinstance(c.value, list) and c.value and isinstance(c.value[0], int))
+        for c in constants
+    )
+
+    # Build header
+    lines = [
+        f"/* AUTO-GENERATED by consync — do not edit by hand.",
+        f" * Source: {source_name}",
+        f" * Synced: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        f" * Regenerate: consync sync",
+        f" */",
+        f"",
+        f"#ifndef {guard}",
+        f"#define {guard}",
+        f"",
+    ]
+
+    if needs_stdint and output_style == "const":
+        lines.append("#include <stdint.h>")
+        lines.append("")
+
+    # Build constant declarations
+    for c in constants:
+        name = prefix + c.name
+        if config and config.uppercase_names:
+            name = name.upper()
+
+        # Build comment
+        parts = [p for p in (c.unit, c.description) if p]
+        comment = f"  /* {' | '.join(parts)} */" if parts else ""
+
+        # === Array values ===
+        if isinstance(c.value, list):
+            _render_array_const(lines, c, name, qualifier, typed_ints, precision, comment)
+            continue
+
+        # === Scalar values ===
+        # Format value and determine type
+        if isinstance(c.value, int):
+            c_type, suffix = _c_type_for_int(c.value, typed_ints)
+            val_str = str(c.value) + suffix
+        else:
+            c_type = _c_type_for_float(c.value)
+            val_str = format_c_double(c.value, precision)
+            suffix = ""
+
+        # Emit line based on output style
+        if output_style == "define":
+            lines.append(f"#define {name:<{name_width}} ({val_str}){comment}")
+        else:
+            type_width = max(len(_get_c_type(c2, typed_ints)) for c2 in constants
+                            if not isinstance(c2.value, list))  if any(
+                                not isinstance(c2.value, list) for c2 in constants) else len(c_type)
+            lines.append(
+                f"{qualifier} {c_type:<{type_width}} {name:<{name_width}} = {val_str};{comment}"
+            )
+
+    lines += ["", f"#endif /* {guard} */", ""]
+
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text("\n".join(lines), encoding="utf-8")
+
+
+def _get_c_type(c: "Constant", typed_ints: bool) -> str:
+    """Get the C type string for a scalar constant."""
+    if isinstance(c.value, int):
+        return _c_type_for_int(c.value, typed_ints)[0]
+    return _c_type_for_float(c.value)
+
+
+def _render_array_const(
+    lines: list[str],
+    c: "Constant",
+    name: str,
+    qualifier: str,
+    typed_ints: bool,
+    precision: int,
+    comment: str,
+) -> None:
+    """Render an array constant as: static const int X[] = {1, 2, 3};"""
+    from consync.models import ConstantType
+
+    arr = c.value
+    if not arr:
+        return
+
+    first = arr[0]
+    if isinstance(first, int):
+        # Use typed ints based on max value in array
+        max_val = max(arr)
+        min_val = min(arr)
+        if min_val < 0:
+            c_type = _c_type_for_int(min_val, typed_ints)[0]
+            # Ensure type fits max too
+            if typed_ints:
+                c_type2 = _c_type_for_int(max_val, typed_ints)[0]
+                # Pick the wider signed type
+                if "64" in c_type or "64" in c_type2:
+                    c_type = "int64_t"
+                elif "32" in c_type or "32" in c_type2:
+                    c_type = "int32_t"
+                elif "16" in c_type or "16" in c_type2:
+                    c_type = "int16_t"
+        else:
+            c_type = _c_type_for_int(max_val, typed_ints)[0]
+        vals = ", ".join(str(v) for v in arr)
+    elif isinstance(first, float):
+        c_type = "double"
+        vals = ", ".join(format_c_double(v, precision) for v in arr)
+    else:
+        # String arrays → not directly supported in C, skip
+        return
+
+    lines.append(
+        f"{qualifier} {c_type} {name}[] = {{{vals}}};{comment}"
+    )

consync/renderers/csharp.py

@@ -0,0 +1,174 @@
+"""C# renderer — generates a static class with typed constants.
+
+Output example:
+    // AUTO-GENERATED by consync — do not edit by hand.
+    namespace HardwareConstants
+    {
+        public static class Constants
+        {
+            /// <summary>Current sense resistor (Ohm)</summary>
+            public const double R_SENSE = 1.9999999999910001;
+
+            /// <summary>I2C pull-up resistor (Ohm)</summary>
+            public const uint R_PULLUP = 4706;
+        }
+    }
+"""
+
+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
+
+
+def _csharp_type(value: int | float | str, typed_ints: bool = True) -> tuple[str, str]:
+    """Determine C# type and optional suffix for a value.
+
+    Returns (type_name, literal_suffix).
+    """
+    if isinstance(value, int):
+        if not typed_ints:
+            return ("int", "")
+        if value < 0:
+            if -2147483648 <= value <= 2147483647:
+                return ("int", "")
+            else:
+                return ("long", "L")
+        else:
+            if value <= 2147483647:
+                return ("int", "")
+            elif value <= 4294967295:
+                return ("uint", "U")
+            else:
+                return ("ulong", "UL")
+    elif isinstance(value, float):
+        return ("double", "")
+    else:
+        return ("string", "")
+
+
+@register("csharp")
+def render_csharp(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as a C# static class.
+
+    Args:
+        constants: Constants to write.
+        filepath: Output .cs file path.
+        config: Mapping config (for precision, namespace, etc.)
+    """
+    filepath = Path(filepath)
+    precision = config.precision if config else kwargs.get("precision", 17)
+    source_name = config.source if config else kwargs.get("source", "unknown")
+    namespace = (config.namespace if config else kwargs.get("namespace", "")) or "Constants"
+    class_name = (config.module_name if config else kwargs.get("module_name", "")) or "HwConstants"
+    typed_ints = config.typed_ints if config else kwargs.get("typed_ints", True)
+    prefix = config.prefix if config else kwargs.get("prefix", "")
+
+    lines = [
+        f"// AUTO-GENERATED by consync — do not edit by hand.",
+        f"// Source: {source_name}",
+        f"// Synced: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        f"// Regenerate: consync sync",
+        f"",
+        f"namespace {namespace}",
+        f"{{",
+        f"    public static class {class_name}",
+        f"    {{",
+    ]
+
+    for c in constants:
+        name = prefix + c.name
+        if config and config.uppercase_names:
+            name = name.upper()
+
+        # XML doc comment
+        doc_parts = [p for p in (c.description, f"({c.unit})" if c.unit else "") if p]
+        if doc_parts:
+            doc = " ".join(doc_parts)
+            lines.append(f"        /// <summary>{doc}</summary>")
+
+        # === Array values ===
+        if isinstance(c.value, list):
+            _render_csharp_array(lines, c, name, typed_ints, precision)
+            lines.append("")
+            continue
+
+        # === Scalar values ===
+        cs_type, suffix = _csharp_type(c.value, typed_ints)
+
+        # Format value
+        if isinstance(c.value, int):
+            val_str = str(c.value) + suffix
+        elif isinstance(c.value, float):
+            val_str = format_float(c.value, precision)
+        else:
+            val_str = f'"{c.value}"'
+
+        lines.append(f"        public const {cs_type} {name} = {val_str};")
+        lines.append("")
+
+    # Remove trailing blank line before closing braces
+    if lines and lines[-1] == "":
+        lines.pop()
+
+    lines += [
+        f"    }}",
+        f"}}",
+        "",
+    ]
+
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    filepath.write_text("\n".join(lines), encoding="utf-8")
+
+
+def _render_csharp_array(
+    lines: list[str],
+    c: "Constant",
+    name: str,
+    typed_ints: bool,
+    precision: int,
+) -> None:
+    """Render an array constant as: public static readonly int[] X = { 1, 2, 3 };"""
+    arr = c.value
+    if not arr:
+        return
+
+    first = arr[0]
+    if isinstance(first, int):
+        cs_type = "int"
+        if typed_ints:
+            max_val = max(arr)
+            min_val = min(arr)
+            if min_val < 0:
+                if min_val >= -2147483648 and max_val <= 2147483647:
+                    cs_type = "int"
+                else:
+                    cs_type = "long"
+            else:
+                if max_val <= 2147483647:
+                    cs_type = "int"
+                elif max_val <= 4294967295:
+                    cs_type = "uint"
+                else:
+                    cs_type = "ulong"
+        vals = ", ".join(str(v) for v in arr)
+    elif isinstance(first, float):
+        cs_type = "double"
+        vals = ", ".join(format_float(v, precision) for v in arr)
+    else:
+        cs_type = "string"
+        vals = ", ".join(f'"{v}"' for v in arr)
+
+    lines.append(
+        f"        public static readonly {cs_type}[] {name} = {{ {vals} }};"
+    )

consync/renderers/csv_renderer.py

@@ -0,0 +1,46 @@
+"""CSV renderer — writes constants to a CSV file."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+from consync.models import Constant, MappingConfig
+from consync.renderers import register
+
+
+@register("csv")
+def render_csv(
+    constants: list[Constant],
+    filepath: str | Path,
+    *,
+    config: MappingConfig | None = None,
+    **kwargs,
+) -> None:
+    """Render constants as a CSV file with headers Name, Value, Unit, Description."""
+    filepath = Path(filepath)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    delimiter = ","
+    if filepath.suffix.lower() == ".tsv":
+        delimiter = "\t"
+
+    with filepath.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f, delimiter=delimiter)
+        writer.writerow(["Name", "Value", "Unit", "Description"])
+        for c in constants:
+            # Format value: arrays use pipe separator, floats get precision
+            if isinstance(c.value, list):
+                if c.value and isinstance(c.value[0], float):
+                    from consync.precision import format_float
+                    precision = config.precision if config else 17
+                    val_str = "|".join(format_float(v, precision) for v in c.value)
+                else:
+                    val_str = "|".join(str(v) for v in c.value)
+            elif isinstance(c.value, float):
+                from consync.precision import format_float
+                precision = config.precision if config else 17
+                val_str = format_float(c.value, precision)
+            else:
+                val_str = str(c.value)
+            writer.writerow([c.name, val_str, c.unit or "", c.description or ""])