pyredacc 0.11.1__tar.gz

pyredacc-0.11.1/.gitignore

@@ -0,0 +1,2 @@
+python/anabrid/redacc/configurations
+*.so

pyredacc-0.11.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: pyredacc
+Version: 0.11.1
+Summary: Python frontend for the redacc analog compiler pipeline
+Requires-Python: >=3.11
+Requires-Dist: docker>=7.0
+Requires-Dist: matplotlib>=3.10.8
+Requires-Dist: numpy>=2.4
+Requires-Dist: protobuf>=5.0
+Requires-Dist: pybrid-computing-native>=0.11.7
+Requires-Dist: pybrid-computing>=0.11.7
+Requires-Dist: sympy>=1.13
+Requires-Dist: typer>=0.24.1
+Requires-Dist: yaspin>=3.4.0

pyredacc-0.11.1/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "pyredacc"
+dynamic = ["version"]
+description = "Python frontend for the redacc analog compiler pipeline"
+requires-python = ">=3.11"
+dependencies = [
+    "docker>=7.0",
+    "protobuf>=5.0",
+    "sympy>=1.13",
+    "numpy>=2.4",
+    "matplotlib>=3.10.8",
+    "pybrid-computing>=0.11.7",
+    "pybrid-computing-native>=0.11.7",
+    "typer>=0.24.1",
+    "yaspin>=3.4.0"
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+]
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning"]
+build-backend = "hatchling.build"
+
+[project.scripts]
+redacc = "pyredacc.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["pyredacc"]
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+pattern = "^v(?P<base>\\d+\\.\\d+\\.\\d+)$"
+format-jinja = "{% if distance == 0 %}{{ base }}{% else %}{{ base }}.dev{{ distance }}+{{ commit }}{% endif %}"
+fallback-version = "0.1.0"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "requires_docker: test needs a running Docker daemon",
+]

pyredacc-0.11.1/pyredacc/__init__.py

@@ -0,0 +1,18 @@
+from .types import Backend, CompilerResult, SympyODE
+from .ode_adapter import ODEAdapter
+from .compiler import Compiler
+from .simulator import Simulator
+from .executor import DockerExecutor, LocalExecutor
+from .registry import DockerRegistry
+
+__all__ = [
+    "Backend",
+    "CompilerResult",
+    "ODEAdapter",
+    "Compiler",
+    "Simulator",
+    "DockerExecutor",
+    "LocalExecutor",
+    "DockerRegistry",
+    "SympyODE",
+]

pyredacc-0.11.1/pyredacc/cli.py

@@ -0,0 +1,164 @@
+"""
+Simple CLI forwarding all given arguments to Docker containers. Allows users
+to run both compiler and simulator from the CLI, freeing them from the burden
+of updating their installation.
+"""
+import sys
+import time
+
+import typer
+from typing import Annotated
+from yaspin import yaspin
+from yaspin.spinners import Spinners
+
+from .compiler import Backend
+from .registry import DockerRegistry
+
+app = typer.Typer(
+    help="Compile ODEs and run simulations for anabrid analog computers."
+)
+try:
+    DockerRegistry.from_env()
+except:
+    print("Make sure to set CI_REGISTRY_USER and CI_REGISTRY_PASSWORD variables " +
+        "for access to the Docker registry.")
+    exit(1)
+
+@app.command()
+def compile(
+    input: Annotated[
+        str,
+        typer.Argument(help="Path to an .ana analang source file")
+    ],
+    backend: Annotated[
+        Backend,
+        typer.Option(
+            case_sensitive=False,
+            help="LANE for LUCIDAC, NETWORK for REDAC"
+        )
+    ],
+    device: Annotated[
+        str,
+        typer.Option(
+            help="Path to a device specification in .apb format"
+        )
+    ],
+    output: Annotated[
+        str,
+        typer.Option(
+            help="Path to output artifact, format is .apb"
+        )
+    ],
+    plugins_dir: Annotated[
+        str,
+        typer.Option(
+            help="Paths to directories containing plugins"
+        )
+    ] = None,
+    pull: Annotated[
+        bool,
+        typer.Option(
+            help="Whether to always pull the most recent compiler image before using"
+        )
+    ] = True
+):
+    """Compile an ODE description to an analog hardware configuration."""
+    from .compiler import Compiler
+
+    compiler = Compiler(
+        backend=backend,
+        device=device,
+        plugins_dir=plugins_dir,
+        always_pull=pull
+    )
+
+    with yaspin(Spinners.dots, text="Compiling...") as sp:
+        try:
+            result = compiler.run(input=input)
+            if result.exit_code == 0:
+                sp.ok("✔")
+            else:
+                sp.fail("✘")
+        except Exception as e:
+            sp.fail("✘")
+            sys.stderr.write(f"{e}\n")
+            raise typer.Exit(code=1)
+
+    if result.stdout:
+        typer.echo(result.stdout.rstrip())
+
+    if result.exit_code != 0:
+        if result.stderr:
+            sys.stderr.write(result.stderr)
+        raise typer.Exit(code=result.exit_code)
+
+    with yaspin(Spinners.dots, text=f"Saving to {output}...") as sp:
+        try:
+            result.save(output)
+            sp.ok("✔")
+        except Exception as e:
+            sp.fail("✘")
+            sys.stderr.write(f"{e}\n")
+            raise typer.Exit(code=1)
+
+
+@app.command()
+def simulate(
+    port: Annotated[
+        int,
+        typer.Option(
+            help="Port to listen on"
+        )
+    ] = 5732,
+    token: Annotated[
+        str,
+        typer.Option(
+            help="If set, requires authentication by the client"
+        )
+    ] = None,
+    plugins_dir: Annotated[
+        str,
+        typer.Option(
+            help="Path to directory containing compiled plugins"
+        )
+    ] = None,
+    pull: Annotated[
+        bool,
+        typer.Option(
+            help="Whether to always pull the most recent simulator image before using"
+        )
+    ] = True
+):
+    """Run the simulator in the foreground until stopped with Ctrl+C."""
+    from .simulator import Simulator
+
+    sim = Simulator(
+        port=port,
+        plugins_dir=plugins_dir,
+        always_pull=pull
+    )
+
+    with yaspin(Spinners.dots, text="Starting simulator...") as sp:
+        try:
+            sim.start()
+            sp.ok("✔")
+        except Exception as e:
+            sp.fail("✘")
+            sys.stderr.write(f"{e}\n")
+            raise typer.Exit(code=1)
+
+    typer.echo(f"Simulator listening on port {port}. Press Ctrl+C to stop.")
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+
+    with yaspin(Spinners.dots, text="Stopping simulator...") as sp:
+        sim.stop()
+        sp.ok("✔")
+
+
+if __name__ == "__main__":
+    typer.run(app)

pyredacc-0.11.1/pyredacc/compiler.py

@@ -0,0 +1,189 @@
+import logging
+import os
+import shutil
+import tempfile
+from typing import List, Optional, Union
+
+from .executor import DockerExecutor, LocalExecutor
+from .ode_adapter import ODEAdapter
+import pybrid.base.proto.main_pb2 as pb
+from .types import Backend, CompilerResult, SympyODE
+from pybrid.base.proto.io import ProtoIO
+
+logger = logging.getLogger(__name__)
+
+
+class Compiler:
+    """Compile ODE systems to analog hardware configurations.
+
+    Accepts input as a file path, an analang text string, or a SympyODE
+    instance.  Execution happens either inside a Docker container (default)
+    or via a local ``redacc`` binary when *executable* is provided.
+    """
+
+    def __init__(
+        self,
+        backend: Backend,
+        device: Optional[str] = None,
+        executable: Optional[str] = None,
+        image_name: str = "redacc-compiler",
+        image_tag: str = "latest",
+        plugins_dir: Optional[str] = None,
+        always_pull: bool = True,
+    ):
+        self._backend = backend
+        self._device = device
+
+        if executable:
+            self._executor = LocalExecutor(executable=executable, plugins_dir=plugins_dir)
+            self._is_docker = False
+        else:
+            self._executor = DockerExecutor(
+                image_name=image_name,
+                image_tag=image_tag,
+                plugins_dir=plugins_dir,
+                always_pull=always_pull,
+            )
+            self._is_docker = True
+
+    def _build_args(
+        self,
+        input_path: str,
+        output_dir: str,
+        output_apb: bool = True,
+        container_output_dir: Optional[str] = None,
+        container_input_path: Optional[str] = None,
+        container_device_path: Optional[str] = None,
+    ) -> List[str]:
+        args: List[str] = []
+        effective_output = container_output_dir or output_dir
+        effective_input = container_input_path or input_path
+
+        args.extend(["--backend", self._backend.name])
+        
+        if self._device:
+            effective_device = container_device_path or self._device
+            args.extend(["--entity", effective_device])
+
+        if output_apb:
+            args.extend(["--output", os.path.join(effective_output, "config.apb")])
+
+        args.append(effective_input)
+
+        return args
+
+    def run(
+        self,
+        input: Union[str, SympyODE],
+    ) -> CompilerResult:
+        """Run the compiler on the given input.
+
+        *input* may be a file path (str), an analang text string, or a
+        ``SympyODE`` instance.  Strings that point to an existing file are
+        used directly; all other strings are treated as inline analang text.
+        """
+        temp_input = None
+        work_dir = None
+
+        try:
+            if isinstance(input, dict):
+                raise TypeError(
+                    "Dict input is no longer supported; "
+                    "use a file path, analang text, or a SympyODE instance."
+                )
+
+            if isinstance(input, SympyODE):
+                adapter = ODEAdapter()
+                input = adapter.translate_sympy(input)
+
+            if isinstance(input, str) and os.path.isfile(input):
+                input_path = input
+                if self._is_docker:
+                    work_dir = tempfile.mkdtemp()
+                    os.chmod(work_dir, 0o755)
+                    copied_input = os.path.join(
+                        work_dir, os.path.basename(input_path)
+                    )
+                    shutil.copy2(input_path, copied_input)
+                    os.chmod(copied_input, 0o644)
+                    input_path = copied_input
+            else:
+                analang_text = input
+                if self._is_docker:
+                    work_dir = tempfile.mkdtemp()
+                    os.chmod(work_dir, 0o755)
+                    import uuid
+                    tmp_filename = f"input_{uuid.uuid4().hex[:8]}.ana"
+                    tmp_path = os.path.join(work_dir, tmp_filename)
+                    with open(tmp_path, "w") as f:
+                        f.write(analang_text)
+                        f.flush()
+                        os.fsync(f.fileno())
+                    os.chmod(tmp_path, 0o644)
+                    input_path = tmp_path
+                    temp_input = tmp_path
+                else:
+                    tf = tempfile.NamedTemporaryFile(
+                        mode="w", suffix=".ana", delete=False
+                    )
+                    tf.write(analang_text)
+                    tf.close()
+                    input_path = tf.name
+                    temp_input = tf.name
+
+            container_output_dir = None
+            container_input_path = None
+            container_device_path = None
+            volumes = None
+            if self._is_docker:
+                # Mount work_dir read-write for both input and output
+                # This avoids issues with /tmp mounts in Docker
+                container_output_dir = "/work"
+                container_input_path = f"/work/{os.path.basename(input_path)}"
+                if work_dir is None:
+                    work_dir = tempfile.mkdtemp()
+                volumes = {work_dir: "/work"}
+                if self._device:
+                    device_dir = os.path.dirname(os.path.abspath(self._device))
+                    container_device_path = f"/device/{os.path.basename(self._device)}"
+                    volumes[device_dir] = "/device"
+
+            # For LocalExecutor, use output_dir directly (original behavior)
+            # For Docker, use work_dir as the output source
+            output_dir = work_dir or tempfile.mkdtemp()
+
+            args = self._build_args(
+                input_path=input_path,
+                output_dir=output_dir,
+                output_apb=True,
+                container_output_dir=container_output_dir,
+                container_input_path=container_input_path,
+                container_device_path=container_device_path,
+            )
+
+            self._executor.ensure_available()
+            exit_code, stdout, stderr = self._executor.run(
+                args, input_file=None, output_dir=output_dir, volumes=volumes
+            )
+
+            module = None
+
+            apb_path = os.path.join(output_dir, "config.apb")
+            if os.path.isfile(apb_path):
+                with open(apb_path, "rb") as f:
+                    file_msg = pb.File()
+                    file_msg.ParseFromString(f.read())
+                if file_msg.HasField("module"):
+                    module = file_msg.module
+
+            return CompilerResult(
+                exit_code=exit_code,
+                stdout=stdout,
+                stderr=stderr,
+                module=module,
+            )
+        finally:
+            if temp_input and os.path.isfile(temp_input):
+                os.unlink(temp_input)
+            if work_dir:
+                shutil.rmtree(work_dir, ignore_errors=True)