tenncell 0.7.0__py3-none-any.whl

nnc/__init__.py

@@ -0,0 +1,3 @@
+from .model import Cell, NncSystem, Rule
+
+__all__ = ["Cell", "Rule", "NncSystem"]

nnc/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

nnc/_version.py

@@ -0,0 +1 @@
+__version__ = '0.7.0'

nnc/cli.py

@@ -0,0 +1,152 @@
+import argparse
+import csv
+import sys
+from contextlib import ExitStack
+from pathlib import Path
+
+from nnc.model.system import NncSystem
+
+from nnc._version import __version__
+
+
+def main() -> int:
+    """Run the TENNCell simulator CLI and return a process-style exit code."""
+    try:
+        return _run()
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def _run() -> int:
+    """Parse arguments, run the simulator, and return ``0`` on success."""
+    parser = argparse.ArgumentParser(
+        description=f"TENNCell simulator v{__version__}", prog="nnc-sim"
+    )
+    parser.add_argument(
+        "system_file",
+        type=Path,
+        help="The file containing the description of the TENNCell system",
+    )
+    parser.add_argument(
+        "input",
+        type=Path,
+        nargs="?",
+        default=None,
+        help="Input (CSV) file giving stimulus for each step (default: stdin)",
+    )
+    parser.add_argument(
+        "output",
+        type=Path,
+        nargs="?",
+        default=None,
+        help="Output (CSV) file giving the results of each step (default: stdout)",
+    )
+    parser.add_argument(
+        "-c",
+        "--compute_mode",
+        action="store_true",
+        help="Run in continuous compute mode (default: False)",
+    )
+    parser.add_argument(
+        "-s", "--steps", type=int, default=1, help="Number of steps to run (default: 1)"
+    )
+    parser.add_argument(
+        "--csv",
+        action="store_true",
+        help="Output in CSV format when in continuous compute mode",
+    )
+    args = parser.parse_args()
+
+    with ExitStack() as stack:
+        input_handle = (
+            sys.stdin
+            if args.input is None
+            else stack.enter_context(args.input.open("r", encoding="utf-8", newline=""))
+        )
+        output_handle = (
+            sys.stdout
+            if args.output is None
+            else stack.enter_context(
+                args.output.open("w", encoding="utf-8", newline="")
+            )
+        )
+        nnc = NncSystem.from_yaml(str(args.system_file))
+
+        if args.compute_mode:
+            if len(nnc.input_variables) > 0:
+                raise ValueError(
+                    "Cannot run in continuous compute mode with input variables"
+            )
+            if args.csv:
+                # CSV output mode
+                result = {
+                    name: str(variable.value)
+                    for name, variable in nnc.output_variables.items()
+                }
+                fieldnames = ["step"] + list(result.keys())
+                writer = csv.DictWriter(
+                    output_handle, fieldnames=fieldnames, lineterminator="\n"
+                )
+                writer.writeheader()
+                # Write initial state (step 0) with only output variables
+                row = {"step": 0}
+                row.update(result)
+                writer.writerow(row)
+                for i in range(args.steps):
+                    nnc.step()
+                    result = {
+                        name: str(variable.value)
+                        for name, variable in nnc.output_variables.items()
+                    }
+                    row = {"step": i + 1}
+                    row.update(result)
+                    writer.writerow(row)
+            else:
+                print(
+                    f"Running in continuous compute mode for {args.steps} steps",
+                    file=output_handle,
+                )
+                result = {
+                    name: str(variable.value)
+                    for name, variable in nnc.output_variables.items()
+                }
+                print(f"Step: 0: {result}", file=output_handle)
+                for i in range(args.steps):
+                    nnc.step()
+                    result = {
+                        name: str(variable.value)
+                        for name, variable in nnc.output_variables.items()
+                    }
+                    print(f"Step: {i + 1}: {result}", file=output_handle)
+        else:  # IO mode
+            reader = csv.DictReader(input_handle)
+            writer = None
+
+            for csv_row in reader:
+                inputs = {}
+                for input_var_name, input_var_value in csv_row.items():
+                    if input_var_name not in nnc.input_variables.keys():
+                        raise ValueError(f"Unknown input variable {input_var_name}")
+                    inputs[input_var_name] = float(input_var_value)
+
+                nnc.step(inputs)
+
+                result = {
+                    name: variable.value
+                    for name, variable in nnc.output_variables.items()
+                }
+
+                if writer is None:
+                    writer = csv.DictWriter(
+                        output_handle,
+                        fieldnames=result.keys(),
+                        lineterminator="\n",
+                    )
+                    writer.writeheader()
+                writer.writerow(result)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

nnc/cli_transform.py

@@ -0,0 +1,268 @@
+"""CLI tool for transforming TENNCell systems to various output formats."""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Type
+
+from nnc.inputs.yaml.sections import YamlSectionContext, parse_registered_sections
+from nnc.inputs.yaml.locations import YamlLocationIndex
+from nnc.model.system import NncSystem
+from nnc.transformers import (
+    BaseTransformer,
+    PythonTransformer,
+    VerilogTransformer,
+    WebotsTransformer,
+)
+from nnc.transformers.webots.webots_yaml_section_parser import parse_webots_section
+from nnc.transformers.verilog.verilog_yaml_section_parser import parse_verilog_section
+from nnc._version import __version__
+
+
+# Registry of available transformers
+TRANSFORMERS: Dict[str, Type[BaseTransformer]] = {
+    "python": PythonTransformer,
+    "verilog": VerilogTransformer,
+    "webots": WebotsTransformer,
+}
+
+
+def get_transformer(transform_type: str) -> BaseTransformer:
+    """Get a transformer instance by type name.
+
+    Args:
+        transform_type: The type of transformer to create
+
+    Returns:
+        Transformer instance
+
+    Raises:
+        ValueError: If transform_type is not supported
+    """
+    if transform_type not in TRANSFORMERS:
+        available = ", ".join(TRANSFORMERS.keys())
+        raise ValueError(
+            f"Unsupported transformation type '{transform_type}'. Available types: {available}"
+        )
+
+    return TRANSFORMERS[transform_type]()
+
+
+def main():
+    """Main entry point for the ``nnc-gen`` CLI."""
+    parser = argparse.ArgumentParser(
+        description=f"TENNCell Transformer v{__version__} - Convert TENNCell systems to various output formats",
+        prog="nnc-gen",
+    )
+
+    parser.add_argument(
+        "system_files", nargs="+", help="TENNCell system files (.yaml) to transform"
+    )
+
+    parser.add_argument(
+        "-t",
+        "--type",
+        dest="transform_type",
+        required=True,
+        choices=list(TRANSFORMERS.keys()),
+        help="Transformation type",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output-dir",
+        type=Path,
+        default=Path("."),
+        help="Output directory for transformed files (default: current directory)",
+    )
+
+    parser.add_argument(
+        "--output-suffix",
+        default="",
+        help="Suffix to add to output filenames (before extension)",
+    )
+
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable verbose output"
+    )
+    parser.add_argument(
+        "--import-path",
+        action="append",
+        default=[],
+        help="Additional directory to search for imported TENNCell files and external headers",
+    )
+    parser.add_argument(
+        "--import-paths",
+        default="",
+        help="Path-separated list of additional import directories",
+    )
+
+    args = parser.parse_args()
+
+    # Ensure output directory exists
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Get transformer
+    try:
+        transformer = get_transformer(args.transform_type)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    extra_import_paths = list(args.import_path)
+    if args.import_paths:
+        extra_import_paths.extend(
+            [path for path in args.import_paths.split(os.pathsep) if path]
+        )
+
+    # Process each file
+    had_error = False
+    for nnc_file_path in args.system_files:
+        nnc_file = Path(nnc_file_path)
+
+        if not nnc_file.exists():
+            print(f"Error: File '{nnc_file}' not found", file=sys.stderr)
+            had_error = True
+            continue
+
+        if args.verbose:
+            print(f"Processing: {nnc_file}")
+
+        try:
+            # Load TENNCell system
+            raw_data_cache = {}
+            nnc_system = NncSystem.from_yaml(
+                str(nnc_file),
+                import_paths=extra_import_paths,
+                _raw_data_cache=raw_data_cache,
+            )
+
+            # Verilog emits one file per module in the import closure.
+            # Python and Webots emit one composed file for the root system only.
+            if args.transform_type == "verilog":
+                systems_to_emit = _collect_import_closure(nnc_system)
+                assert isinstance(transformer, VerilogTransformer)
+                transformer.set_verilog_configs(
+                    _parse_verilog_configs(
+                        systems_to_emit, raw_data_cache, extra_import_paths
+                    )
+                )
+            elif args.transform_type == "webots":
+                assert isinstance(transformer, WebotsTransformer)
+                transformer.set_webots_configs(
+                    _parse_webots_configs([nnc_system], raw_data_cache)
+                )
+                systems_to_emit = [nnc_system]
+            else:
+                systems_to_emit = [nnc_system]
+            for system in systems_to_emit:
+                transformed_code = transformer.transform(system)
+                source_path = (
+                    getattr(system, "__dict__", {}).get("source_path") or nnc_file
+                )
+                base_name = source_path.stem
+                if args.output_suffix:
+                    base_name += args.output_suffix
+
+                output_file = args.output_dir / (
+                    base_name + transformer.get_file_extension()
+                )
+
+                with open(output_file, "w", encoding="utf-8") as f:
+                    f.write(transformed_code)
+
+                if args.verbose:
+                    print(f"  -> {output_file}")
+
+        except Exception as e:
+            print(f"Error processing '{nnc_file}': {e}", file=sys.stderr)
+            had_error = True
+            if args.verbose:
+                import traceback
+
+                traceback.print_exc()
+            continue
+
+    if args.verbose:
+        print("Transformation complete.")
+    if had_error:
+        return 1
+    return 0
+
+
+def _collect_import_closure(root: NncSystem) -> list[NncSystem]:
+    seen: set[str] = set()
+    ordered: list[NncSystem] = []
+
+    def visit(system: NncSystem):
+        source_key = str(getattr(system, "source_path", None) or id(system))
+        if source_key in seen:
+            return
+        seen.add(source_key)
+        imports = getattr(system, "__dict__", {}).get("imports", [])
+        for item in imports or []:
+            if getattr(item, "system", None) is not None:
+                visit(item.system)
+        ordered.append(system)
+
+    visit(root)
+    return ordered
+
+
+def _parse_verilog_configs(
+    systems: list[NncSystem],
+    raw_data_cache: dict[Path, dict],
+    import_paths: list[str],
+):
+    configs = {}
+    header_cache: dict[Path, object] = {}
+    import_paths_resolved = [Path(path).resolve() for path in import_paths]
+    for system in systems:
+        if system.source_path is None:
+            raise ValueError("Verilog export requires systems loaded from YAML files")
+        data = raw_data_cache[system.source_path]
+        context = YamlSectionContext(
+            source_path=system.source_path,
+            import_paths=import_paths_resolved,
+            header_cache=header_cache,
+            raw_data=data,
+            locations=system.source_locations
+            or YamlLocationIndex(system.source_path, {}),
+        )
+        parsed = parse_registered_sections(
+            data, context, {"verilog": parse_verilog_section}
+        )
+        configs[system.source_path] = parsed["verilog"]
+    return configs
+
+
+def _parse_webots_configs(
+    systems: list[NncSystem],
+    raw_data_cache: dict[Path, dict],
+):
+    configs = {}
+    for system in systems:
+        if system.source_path is None:
+            raise ValueError("Webots export requires systems loaded from YAML files")
+        data = raw_data_cache[system.source_path]
+        context = YamlSectionContext(
+            source_path=system.source_path,
+            import_paths=[],
+            header_cache={},
+            raw_data=data,
+            locations=system.source_locations
+            or YamlLocationIndex(system.source_path, {}),
+        )
+        parsed = parse_registered_sections(
+            data, context, {"webots": parse_webots_section}
+        )
+        configs[system.source_path] = parsed["webots"]
+    return configs
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:
+        print(f"Error: {e}")

nnc/inputs/__init__.py

@@ -0,0 +1 @@
+"""TENNCell input format loaders."""

nnc/inputs/yaml/__init__.py

@@ -0,0 +1 @@
+"""TENNCell YAML input loader package."""

nnc/inputs/yaml/errors.py

@@ -0,0 +1,61 @@
+"""YAML loader error helpers for TENNCell."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .locations import format_yaml_location
+
+
+class YamlLocatedError(ValueError):
+    """ValueError carrying YAML source location metadata."""
+
+    def __init__(
+        self,
+        message: str,
+        source_path: Path | None = None,
+        line: int | None = None,
+    ):
+        super().__init__(message)
+        self.message = message
+        self.source_path = source_path
+        self.line = line
+
+    def attach_location(
+        self, source_path: Path | None = None, line: int | None = None
+    ) -> "YamlLocatedError":
+        """Update the stored location and return the error itself."""
+        if source_path is not None:
+            self.source_path = source_path
+        if line is not None:
+            self.line = line
+        return self
+
+    @property
+    def location(self) -> str | None:
+        """Return the formatted location prefix, if available."""
+        if self.source_path is None:
+            return None
+        return format_yaml_location(self.source_path, self.line)
+
+    def __str__(self) -> str:
+        if self.location is None:
+            return self.message
+        return f"{self.location}: {self.message}"
+
+
+def as_yaml_located_error(
+    error: Exception,
+    source_path: Path | None = None,
+    line: int | None = None,
+) -> YamlLocatedError:
+    """Convert or annotate an exception with YAML location metadata."""
+    if isinstance(error, YamlLocatedError):
+        if error.source_path is None:
+            error.attach_location(source_path, line)
+        elif error.line is None and line is not None:
+            error.attach_location(line=line)
+        return error
+    located_error = YamlLocatedError(str(error), source_path, line)
+    located_error.__cause__ = error
+    return located_error

nnc/inputs/yaml/lexical.py

@@ -0,0 +1,60 @@
+"""Lexical preprocessing helpers for TENNCell YAML loading."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+
+
+def _split_comment(line: str) -> tuple[str, str]:
+    """Split a YAML line into content and an inline comment."""
+    line = line.rstrip("\r\n")
+    in_single = False
+    in_double = False
+    for index, char in enumerate(line):
+        if char == "'" and not in_double:
+            in_single = not in_single
+        elif char == '"' and not in_single:
+            in_double = not in_double
+        elif char == "#" and not in_single and not in_double:
+            if index == 0 or line[index - 1].isspace():
+                return line[:index], line[index:]
+    return line, ""
+
+
+def _quote_bang_scalar(content: str) -> str:
+    """Quote an unquoted scalar that starts with a bang."""
+    if not content:
+        return content
+    prefix = ""
+    value = content
+    if ":" in content:
+        prefix, value = content.split(":", 1)
+        if not value.startswith((" ", "\t")):
+            return content
+        prefix = f"{prefix}: "
+        value = value.lstrip()
+    elif content.lstrip().startswith("- "):
+        leading = len(content) - len(content.lstrip())
+        prefix = content[:leading] + "- "
+        value = content[leading + 2 :].lstrip()
+    else:
+        return content
+
+    if not value.startswith("!"):
+        return content
+    return f"{prefix}{json.dumps(value)}"
+
+
+def sanitize_bang_prefixed_scalars(lines: Iterable[str]) -> str:
+    """Quote plain YAML scalars that start with ``!``.
+
+    PyYAML interprets bare ``!name`` values as tags. TENNCell expressions use
+    ``!`` as a boolean operator, so plain scalars that start with ``!`` must be
+    converted to quoted strings before the YAML parser sees them.
+    """
+    sanitized_lines: list[str] = []
+    for line in lines:
+        content, comment = _split_comment(line)
+        sanitized_lines.append(_quote_bang_scalar(content) + comment)
+    return "\n".join(sanitized_lines)

nnc/inputs/yaml/locations.py

@@ -0,0 +1,89 @@
+"""Source-location helpers for TENNCell YAML documents."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+from yaml.nodes import MappingNode, Node, ScalarNode, SequenceNode
+
+from .lexical import sanitize_bang_prefixed_scalars
+
+
+@dataclass(slots=True)
+class YamlLocationIndex:
+    """Path-to-line index for one YAML source file."""
+
+    source_path: Path
+    paths: dict[tuple[object, ...], int]
+
+    def line_for(self, *path: object) -> int | None:
+        """Return the 1-based line number for a YAML path, if known."""
+        return self.paths.get(path)
+
+    def first_line_under(self, *prefix: object) -> int | None:
+        """Return the first known line number under a YAML path prefix."""
+        for path, line in self.paths.items():
+            if len(path) >= len(prefix) and path[: len(prefix)] == prefix:
+                return line
+        return None
+
+    def error(self, message: str, *path: object) -> YamlLocatedError:
+        """Build a located YAML error for this file and path."""
+        from .errors import YamlLocatedError
+
+        return YamlLocatedError(message, self.source_path, self.line_for(*path))
+
+
+def _node_key(node: Node) -> object:
+    """Convert a YAML node used as a mapping key into a hashable path element."""
+    if isinstance(node, ScalarNode):
+        return node.value
+    return yaml.safe_load(yaml.serialize(node))
+
+
+def collect_yaml_locations(node: Node | None) -> dict[tuple[object, ...], int]:
+    """Collect 1-based line numbers for YAML values reachable from a node tree."""
+    locations: dict[tuple[object, ...], int] = {}
+
+    def visit(current: Node, path: tuple[object, ...]) -> None:
+        if isinstance(current, MappingNode):
+            for key_node, value_node in current.value:
+                key = _node_key(key_node)
+                child_path = path + (key,)
+                locations[child_path] = value_node.start_mark.line + 1
+                if isinstance(value_node, (MappingNode, SequenceNode)):
+                    visit(value_node, child_path)
+            return
+
+        if isinstance(current, SequenceNode):
+            for index, item in enumerate(current.value):
+                child_path = path + (index,)
+                locations[child_path] = item.start_mark.line + 1
+                if isinstance(item, (MappingNode, SequenceNode)):
+                    visit(item, child_path)
+            return
+
+    if node is not None:
+        visit(node, ())
+    return locations
+
+
+def load_yaml_data_and_locations(
+    source_path: Path,
+) -> tuple[dict[str, Any], YamlLocationIndex]:
+    """Load YAML content and collect path-to-line metadata for the document."""
+    with source_path.open("r", encoding="utf-8") as file:
+        sanitized = sanitize_bang_prefixed_scalars(file)
+    node = yaml.compose(sanitized)
+    data = yaml.safe_load(sanitized) or {}
+    return data, YamlLocationIndex(source_path, collect_yaml_locations(node))
+
+
+def format_yaml_location(source_path: Path, line: int | None) -> str:
+    """Format a source location prefix for a YAML error message."""
+    if line is None:
+        return str(source_path)
+    return f"{source_path}:{line}"

nnc/inputs/yaml/lowering/__init__.py

@@ -0,0 +1,24 @@
+"""TENNCell YAML lowering helpers."""
+
+from .common import (
+    combine_guards,
+    guard_negation,
+    make_transition_rule,
+    normalize_rule_items,
+    parse_structured_rule,
+    with_guard,
+)
+from .fsm import build_state_constants, lower_fsm_rules
+from .rules import lower_rule_items
+
+__all__ = [
+    "build_state_constants",
+    "combine_guards",
+    "guard_negation",
+    "lower_fsm_rules",
+    "lower_rule_items",
+    "make_transition_rule",
+    "normalize_rule_items",
+    "parse_structured_rule",
+    "with_guard",
+]