pyredacc 0.11.1__py3-none-any.whl

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/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/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)

pyredacc/executor.py

@@ -0,0 +1,275 @@
+import os
+import subprocess
+import sys
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Tuple
+
+from .registry import DockerRegistry
+
+
+def _path_in_volumes(path: str, volumes: Optional[Dict[str, str]]) -> bool:
+    """Check if a path is covered by any volume mount."""
+    if not volumes:
+        return False
+    abs_path = os.path.abspath(path)
+    for host_path in volumes:
+        abs_host = os.path.abspath(host_path)
+        # Check if path is inside the host mount point
+        if abs_path.startswith(abs_host + os.sep) or abs_path == abs_host:
+            return True
+    return False
+
+
+class BaseExecutor(ABC):
+    """Interface for running the redacc binary (Docker or local)."""
+
+    @abstractmethod
+    def ensure_available(self) -> None:
+        """Verify the execution backend is ready (image pulled / binary exists)."""
+        ...
+
+    @abstractmethod
+    def run(
+        self,
+        args: List[str],
+        input_file: Optional[str],
+        output_dir: Optional[str],
+        volumes: Optional[Dict[str, str]],
+    ) -> Tuple[int, str, str]:
+        ...
+
+    @abstractmethod
+    def run_detached(
+        self,
+        args: List[str],
+        ports: Optional[Dict[str, int]] = None,
+    ) -> str:
+        ...
+
+
+class DockerExecutor(BaseExecutor):
+    """Run redacc inside a Docker container pulled from the configured registry."""
+
+    def __init__(
+        self,
+        image_name: str,
+        image_tag: str = "latest",
+        plugins_dir: Optional[str] = None,
+        always_pull: bool = True,
+    ):
+        self._image_name = image_name
+        self._image_tag = image_tag
+        self._plugins_dir = plugins_dir
+        self._always_pull = always_pull
+
+        import docker
+        self._docker = docker
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                self._client = self._docker.from_env()
+            except self._docker.errors.DockerException as e:
+                raise ConnectionError(
+                    f"Cannot connect to Docker daemon. Is Docker running? "
+                    f"Original error: {e}"
+                ) from e
+        return self._client
+
+    @property
+    def full_image_name(self) -> str:
+        registry_url = DockerRegistry._get().url
+        if registry_url:
+            return f"{registry_url}/{self._image_name}:{self._image_tag}"
+        return f"{self._image_name}:{self._image_tag}"
+
+    def _format_bytes(self, num_bytes: int) -> str:
+        """Format bytes as human-readable string."""
+        for unit in ["B", "KB", "MB", "GB", "TB"]:
+            if abs(num_bytes) < 1024.0:
+                return f"{num_bytes:.1f} {unit}"
+            num_bytes /= 1024.0
+        return f"{num_bytes:.1f} PB"
+
+    def _pull_with_progress(self, image_name: str) -> None:
+        """Pull an image with progress feedback to stderr."""
+        repo, tag = image_name.rsplit(":", 1)
+
+        is_tty = sys.stderr.isatty()
+        layer_totals: Dict[str, int] = {}
+        layer_current: Dict[str, int] = {}
+        layers_complete = set()
+
+        events = self._get_client().api.pull(repo, tag=tag, stream=True, decode=True)
+
+        for event in events:
+            status = event.get("status", "")
+            layer_id = event.get("id", "")
+
+            if status.startswith("Status: Image is up to date"):
+                return
+
+            if status.startswith("Status: Downloaded newer image"):
+                if is_tty:
+                    sys.stderr.write("\n")
+                sys.stderr.write(f"Image {image_name}: {status}\n")
+                return
+
+            if status == "Already exists":
+                if layer_id:
+                    layers_complete.add(layer_id)
+                continue
+
+            # Track layer totals from progressDetail
+            progress_detail = event.get("progressDetail", {})
+            if progress_detail:
+                current = progress_detail.get("current", 0)
+                total = progress_detail.get("total", 0)
+                if layer_id:
+                    layer_totals[layer_id] = total
+                    layer_current[layer_id] = current
+
+            # Calculate total progress
+            total_bytes = sum(layer_totals.values())
+            current_bytes = sum(layer_current[lid] for lid in layer_totals if lid not in layers_complete)
+
+            if is_tty and total_bytes > 0:
+                # Update progress on same line
+                sys.stderr.write(f"\rPulling {image_name}: {self._format_bytes(current_bytes)}/{self._format_bytes(total_bytes)}")
+                sys.stderr.flush()
+            elif not is_tty and total_bytes > 0:
+                # Non-TTY: print status updates
+                if status in ("Downloading", "Extracting"):
+                    sys.stderr.write(f"Pulling {image_name}: {self._format_bytes(current_bytes)}/{self._format_bytes(total_bytes)}\n")
+                    sys.stderr.flush()
+
+            # Mark layer as complete
+            if status == "Pull complete" and layer_id:
+                layers_complete.add(layer_id)
+
+        if is_tty and total_bytes > 0:
+            sys.stderr.write("\n")
+        sys.stderr.write(f"Image {image_name} pulled successfully\n")
+
+    def ensure_available(self) -> None:
+        DockerRegistry._get().login(self._get_client())
+        # Only check if image exists locally when not always pulling
+        if not self._always_pull:
+            try:
+                self._get_client().images.get(self.full_image_name)
+                # Image exists and we're not set to always pull
+                return
+            except self._docker.errors.ImageNotFound:
+                pass  # Image doesn't exist, will pull below
+
+        # Pull the image with progress
+        self._pull_with_progress(self.full_image_name)
+
+    def run(
+        self,
+        args: List[str],
+        input_file: Optional[str],
+        output_dir: Optional[str],
+        volumes: Optional[Dict[str, str]],
+    ) -> Tuple[int, str, str]:
+        bind_volumes = {}
+        if volumes:
+            for host_path, container_path in volumes.items():
+                bind_volumes[host_path] = {"bind": container_path, "mode": "rw"}
+        # Only mount input_file separately if not already covered by custom volumes
+        if input_file and not _path_in_volumes(input_file, volumes):
+            bind_volumes[input_file] = {"bind": f"/work/{os.path.basename(input_file)}", "mode": "ro"}
+        # Only mount output_dir to /output if it's not already covered by a custom volume
+        if output_dir and output_dir not in volumes:
+            bind_volumes[output_dir] = {"bind": "/output", "mode": "rw"}
+        if self._plugins_dir:
+            bind_volumes[self._plugins_dir] = {"bind": "/plugins", "mode": "ro"}
+
+        container = self._get_client().containers.run(
+            self.full_image_name,
+            command=args,
+            volumes=bind_volumes,
+            detach=True,
+            user="root",  # Run as root to ensure write permissions on mounted volumes
+        )
+
+        try:
+            result = container.wait()
+            exit_code = result.get("StatusCode", -1)
+            stdout = container.logs(stdout=True, stderr=False).decode("utf-8", errors="replace")
+            stderr = container.logs(stdout=False, stderr=True).decode("utf-8", errors="replace")
+        finally:
+            container.remove(force=True)
+
+        return exit_code, stdout, stderr
+
+    def run_detached(
+        self,
+        args: List[str],
+        ports: Optional[Dict[str, int]] = None,
+    ) -> str:
+        bind_volumes = {}
+        if self._plugins_dir:
+            bind_volumes[self._plugins_dir] = {"bind": "/plugins", "mode": "ro"}
+
+        container = self._get_client().containers.run(
+            self.full_image_name,
+            command=args,
+            volumes=bind_volumes,
+            ports=ports or {},
+            detach=True,
+            environment={
+                "REDACC_SIM_PLUGINS_PATH": "/plugins"
+            }
+        )
+
+        return container.id
+
+
+class LocalExecutor(BaseExecutor):
+    """Run redacc as a local subprocess."""
+
+    def __init__(
+        self,
+        executable: str,
+        plugins_dir: Optional[str] = None,
+    ):
+        self._executable = executable
+        self._plugins_dir = plugins_dir
+
+    def ensure_available(self) -> None:
+        if not os.path.isfile(self._executable):
+            raise FileNotFoundError(f"Executable not found: {self._executable}")
+        if not os.access(self._executable, os.X_OK):
+            raise PermissionError(f"Not executable: {self._executable}")
+
+    def run(
+        self,
+        args: List[str],
+        input_file: Optional[str],
+        output_dir: Optional[str],
+        volumes: Optional[Dict[str, str]],
+    ) -> Tuple[int, str, str]:
+        cmd = [self._executable] + args
+        if input_file:
+            cmd.append(input_file)
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=output_dir,
+            env={
+                "REDACC_SIM_PLUGINS_PATH": self._plugins_dir
+            } if self._plugins_dir else {}
+        )
+
+        return result.returncode, result.stdout, result.stderr
+
+    def run_detached(
+        self,
+        args: List[str],
+        ports: Optional[Dict[str, int]] = None,
+    ) -> str:
+        raise NotImplementedError("Background mode not supported for local execution")

pyredacc/ode_adapter.py

@@ -0,0 +1,171 @@
+import uuid
+
+import sympy as sp
+from sympy import Function, Derivative, Symbol, Eq, solve
+from typing import Dict, List, Union
+
+from .types import SympyODE
+
+
+class ODEAdapter:
+    """Translate SymPy ODE expressions to the analang format used by redacc."""
+
+    class _CustomPrinter(sp.StrPrinter):
+        """Format SymPy expressions using analang syntax."""
+
+        def __init__(self, implicit_variable: str = "t"):
+            super().__init__()
+            self.implicit_variable = implicit_variable
+
+        def _print_Function(self, expr):
+            return f"{expr.func.__name__}({self.implicit_variable})"
+
+        def _print_Derivative(self, expr):
+            function = expr.args[0]
+            variables = expr.args[1:]
+            order = 0
+            t_sym = Symbol(self.implicit_variable)
+            for v in variables:
+                if isinstance(v, sp.core.containers.Tuple):
+                    var, count = v
+                    if var == t_sym:
+                        order += count
+                else:
+                    if v == t_sym:
+                        order += 1
+            func_name = function.func.__name__
+            return (
+                "diff["
+                + func_name
+                + ", "
+                + ", ".join([self.implicit_variable] * order)
+                + "]("
+                + self.implicit_variable
+                + ")"
+            )
+
+        def _print_Abs(self, expr):
+            return "abs(%s)" % self._print(expr.args[0])
+
+    def __init__(self, implicit_variable: str = "t"):
+        self.implicit_variable = implicit_variable
+
+    def translate_sympy(self, sympy_ode: SympyODE) -> str:
+        """Translate a SympyODE instance to analang text."""
+        ic_str = {
+            f.func.__name__ if hasattr(f, "func") else str(f): v
+            for f, v in sympy_ode.initial_conditions.items()
+        }
+        printer = ODEAdapter._CustomPrinter(self.implicit_variable)
+        probes_str = []
+        for p in sympy_ode.probes:
+            if isinstance(p, Derivative):
+                probes_str.append(printer.doprint(p))
+            elif hasattr(p, "func"):
+                probes_str.append(p.func.__name__)
+            else:
+                probes_str.append(str(p))
+        return self.translate(
+            odes=sympy_ode.odes,
+            initial_conditions=ic_str,
+            probes=probes_str,
+            name=sympy_ode.name or str(uuid.uuid4()),
+        )
+
+    def translate(
+        self,
+        odes: Union[List[sp.Eq], sp.Eq],
+        initial_conditions: Dict[str, float],
+        probes: List[str],
+        name: str = "unnamed",
+    ) -> str:
+        """Build analang text from SymPy equations.
+
+        Raises ``TypeError`` if *odes* is a dict (no longer supported).
+        Raises ``ValueError`` if initial conditions or probes are incomplete.
+        """
+        if isinstance(odes, dict):
+            raise TypeError(
+                "Dict input is no longer supported; "
+                "use SymPy equations or analang files."
+            )
+
+        if isinstance(odes, Eq):
+            odes = [odes]
+
+        functions = self._extract_functions(odes)
+        equations = self._build_equations(odes)
+
+        for f in functions:
+            if f not in initial_conditions:
+                raise ValueError(
+                    f"Initial condition missing for function '{f}'"
+                )
+
+        func_set = set(functions)
+        for p in probes:
+            if p.startswith("diff["):
+                base = p[5:p.index(",")].strip()
+            else:
+                base = p
+            if base not in func_set:
+                raise ValueError(
+                    f"Probe '{p}' does not match any known function"
+                )
+
+        lines = ["use display;", "use math;"]
+
+        for lhs, rhs in equations.items():
+            lines.append(f"let {lhs} = {rhs};")
+
+        for f, v in initial_conditions.items():
+            lines.append(
+                f"let {f}({self.implicit_variable}: 0) = {v};"
+            )
+
+        for p in probes:
+            if p.startswith("diff["):
+                lines.append(f"probe {p};")
+            else:
+                lines.append(f"probe {p}({self.implicit_variable});")
+
+        return "\n".join(lines) + "\n"
+
+    def _extract_functions(self, odes: List[sp.Eq]) -> List[str]:
+        """Extract the names of all undefined functions from the ODEs."""
+        functions = set()
+        for ode in odes:
+            for atom in ode.atoms(Function):
+                if not isinstance(atom, Derivative):
+                    if isinstance(
+                        atom.func, sp.core.function.UndefinedFunction
+                    ):
+                        functions.add(atom.func.__name__)
+        return sorted(functions)
+
+    def _build_equations(self, odes: List[sp.Eq]) -> Dict[str, str]:
+        """Solve each ODE for its highest derivative and return as string pairs."""
+        printer = ODEAdapter._CustomPrinter(self.implicit_variable)
+        eqs = {}
+
+        for ode in odes:
+            derivatives = list(ode.atoms(Derivative))
+            if not derivatives:
+                raise ValueError("No derivatives found in the ODE")
+
+            highest = max(derivatives, key=lambda d: d.derivative_count)
+
+            if isinstance(ode, Eq):
+                expr = ode.lhs - ode.rhs
+            else:
+                expr = ode
+
+            solution = solve(expr, highest, simplify=False)
+            if not solution:
+                raise ValueError("Could not solve for the highest derivative")
+
+            lhs_str = printer.doprint(highest)
+            rhs_str = printer.doprint(solution[0])
+            eqs[lhs_str] = rhs_str
+
+        return eqs

pyredacc/registry.py

@@ -0,0 +1,55 @@
+import os
+
+
+class DockerRegistry:
+    _instance = None
+
+    def __init__(self):
+        self._url: str = "lab.analogparadigm.com:5050/lucidac/software/softthat"
+        self._username: str | None = None
+        self._password: str | None = None
+        self._logged_in = False
+
+    @classmethod
+    def configure(cls, username=None, password=None):
+        """Set registry credentials. Call once before using Compiler/Simulator."""
+        inst = cls._get()
+        inst._username = username
+        inst._password = password
+        inst._logged_in = False
+
+    @classmethod
+    def _get(cls):
+        """Return the singleton instance, creating it if needed."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    @classmethod
+    def from_env(cls):
+        """Configure from REDACC_REGISTRY_URL, CI_REGISTRY_USER, CI_REGISTRY_PASSWORD."""
+        cls.configure(
+            username=os.environ.get("CI_REGISTRY_USER"),
+            password=os.environ.get("CI_REGISTRY_PASSWORD"),
+        )
+
+    @property
+    def url(self) -> str | None:
+        return self._url
+
+    def login(self, client) -> None:
+        """Login to registry via the docker client. No-op if already logged in or no URL."""
+        if self._logged_in or not self._url:
+            return
+        kwargs = {"registry": self._url}
+        if self._username:
+            kwargs["username"] = self._username
+        if self._password:
+            kwargs["password"] = self._password
+        client.login(**kwargs)
+        self._logged_in = True
+
+    @classmethod
+    def _reset(cls):
+        """Reset singleton state. For testing only."""
+        cls._instance = None

pyredacc/simulator.py

@@ -0,0 +1,121 @@
+import subprocess
+import sys
+import time
+from typing import Optional
+
+from .executor import DockerExecutor, LocalExecutor
+
+
+class Simulator:
+    """Lifecycle manager for the pybrid-compatible simulation server.
+
+    Launches the simulator as a background Docker container (default) or local
+    subprocess, exposing ``host`` and ``port`` for client connections.  Use as
+    a context manager for automatic cleanup.
+    """
+
+    def __init__(
+        self,
+        executable: Optional[str] = None,
+        image_name: str = "redacc-simulator",
+        image_tag: str = "latest",
+        port: int = 5732,
+        plugins_dir: Optional[str] = None,
+        always_pull: bool = True,
+        debug: bool = False,
+    ):
+        self._port = port
+        self._executable = executable
+        self._debug = debug
+        self._container_id: Optional[str] = None
+        self._process: Optional[subprocess.Popen] = None
+
+        if executable:
+            self._executor = LocalExecutor(executable=executable, plugins_dir=plugins_dir)
+        else:
+            self._executor = DockerExecutor(
+                image_name=image_name,
+                image_tag=image_tag,
+                plugins_dir=plugins_dir,
+                always_pull=always_pull,
+            )
+
+    @property
+    def host(self) -> str:
+        return "127.0.0.1"
+
+    @property
+    def port(self) -> int:
+        return self._port
+
+    def start(self) -> None:
+        """Launch the simulator as a background process."""
+        self._executor.ensure_available()
+        args = ["--port", str(self._port)]
+
+        if self._executable:
+            self._process = subprocess.Popen(
+                [self._executable] + args,
+                stdout=subprocess.PIPE if self._debug else subprocess.DEVNULL,
+                stderr=subprocess.PIPE if self._debug else subprocess.DEVNULL,
+            )
+        else:
+            self._container_id = self._executor.run_detached(
+                args,
+                ports={f"{self._port}/tcp": self._port},
+            )
+
+        time.sleep(2)  # allow the server to bind its listening socket
+
+    def _print_debug_output(self, stdout: str, stderr: str) -> None:
+        """Print captured stdout/stderr to sys.stderr for debugging."""
+        if stdout:
+            sys.stderr.write(f"--- simulator stdout ---\n{stdout}\n")
+        if stderr:
+            sys.stderr.write(f"--- simulator stderr ---\n{stderr}\n")
+
+    def stop(self) -> None:
+        """Stop the background simulator."""
+        if self._container_id is not None:
+            import docker
+
+            client = docker.from_env()
+            try:
+                container = client.containers.get(self._container_id)
+                if self._debug:
+                    stdout = container.logs(stdout=True, stderr=False).decode(
+                        "utf-8", errors="replace"
+                    )
+                    stderr = container.logs(stdout=False, stderr=True).decode(
+                        "utf-8", errors="replace"
+                    )
+                    self._print_debug_output(stdout, stderr)
+                container.stop(timeout=5)
+                container.remove(force=True)
+            except docker.errors.NotFound:
+                pass
+            self._container_id = None
+
+        if self._process is not None:
+            self._process.terminate()
+            try:
+                self._process.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                self._process.wait()
+            if self._debug:
+                stdout = self._process.stdout.read().decode(
+                    "utf-8", errors="replace"
+                )
+                stderr = self._process.stderr.read().decode(
+                    "utf-8", errors="replace"
+                )
+                self._print_debug_output(stdout, stderr)
+            self._process = None
+
+    def __enter__(self) -> "Simulator":
+        self.start()
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.stop()

pyredacc/types.py

@@ -0,0 +1,108 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Optional
+
+import pybrid.base.proto.main_pb2 as pb
+
+try:
+    import sympy as sp
+
+    _HAS_SYMPY = True
+except ImportError:
+    _HAS_SYMPY = False
+
+
+class Backend(Enum):
+    LANE = "lane"
+    NETWORK = "network"
+
+
+@dataclass
+class SympyODE:
+    """Represents an ODE system defined via SymPy expressions."""
+
+    odes: list
+    initial_conditions: dict
+    probes: list
+    name: Optional[str] = None
+
+
+@dataclass
+class CompilerResult:
+    """Result of a redacc compilation run.
+
+    After a successful compilation, ``module`` contains the compiled protobuf
+    ``Module`` directly.  Use the ``configuration`` and ``specification``
+    properties for convenient access to the most commonly needed fields.
+
+    Instances can be persisted via ``save()`` and restored via ``from_file()``;
+    the resulting ``.apb`` files are compatible with pybrid's ``ProtoIO``.
+    """
+
+    exit_code: int
+    stdout: str
+    stderr: str
+    module: pb.Module | None = None
+
+    @property
+    def configuration(self) -> list[pb.Item]:
+        """Hardware configuration list, ready for pybrid's deserializer.
+
+        Filters out ``EntitySpecification`` entries from the module — those
+        represent device specifications, not hardware configuration.
+        """
+        if self.module is None:
+            return []
+        return [c for c in self.module.items
+                if not c.HasField("entity_specification")]
+
+    @property
+    def specification(self) -> list[pb.Entity]:
+        """Device specification entities for pybrid's ``add_device()``.
+
+        Extracts the ``Entity`` from each ``EntitySpecification`` entry in
+        the module.
+        """
+        if self.module is None:
+            return []
+        return [c.entity_specification.entity for c in self.module.items
+                if c.HasField("entity_specification")]
+
+    def save(self, path: str) -> None:
+        """Save the compiled output to an ``.apb`` protobuf file.
+
+        Wraps the ``Module`` in a ``pb.File`` envelope for compatibility
+        with pybrid's ``ProtoIO.open_pb_file()``.
+
+        Args:
+            path: Destination file path (should end in ``.apb``).
+
+        Raises:
+            ValueError: If no compiled output is available.
+        """
+        if self.module is None:
+            raise ValueError("No compiled output to save.")
+        file_msg = pb.File(module=self.module)
+        with open(path, "wb") as f:
+            f.write(file_msg.SerializeToString())
+
+    @classmethod
+    def from_file(cls, path: str) -> "CompilerResult":
+        """Load a ``CompilerResult`` from a previously saved ``.apb`` file.
+
+        Process metadata (``exit_code``, ``stdout``, ``stderr``) is not
+        stored in the protobuf format; they default to neutral values.
+
+        Args:
+            path: Path to an ``.apb`` file containing a serialised ``pb.File``.
+
+        Returns:
+            A ``CompilerResult`` with the loaded protobuf data.
+        """
+        file_msg = pb.File()
+        with open(path, "rb") as f:
+            file_msg.ParseFromString(f.read())
+        module = file_msg.module if file_msg.HasField("module") else None
+        return cls(exit_code=0, stdout="", stderr="", module=module)
+
+

pyredacc-0.11.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyredacc/__init__.py,sha256=HMoKxT_I5d3fbvBPv2l9JbLoFFujBftR0pdr8J9dJNQ,426
+pyredacc/cli.py,sha256=A5K3VWozqoe1VdbMagp7k5ajM7JpqXu4uNXA5L1ah10,4105
+pyredacc/compiler.py,sha256=v0wPCAvmt7EMR1vtC2JYcU1YFNeGa-0q66LEFyAYfm0,6887
+pyredacc/executor.py,sha256=nzxgHNc23yd29CGz_CT_CC5LeZnZD-UKCuvp-le5nkg,9457
+pyredacc/ode_adapter.py,sha256=uWToKfs3lWceB7AbiVeEBL328He2M_QXwQXFWNJqkRQ,5722
+pyredacc/registry.py,sha256=W1QstaTFoeexrWiPEbev29yhOiIn46oDulP0Ou3YTsY,1686
+pyredacc/simulator.py,sha256=L3CKZSjx4VXOizenVU-31kPQP2AQKNNqIfQCledy-G8,4050
+pyredacc/types.py,sha256=HhwQdgQtFxxz5ck_7sDRbbmT6xqOEG4-5yWs1CGKY1Y,3289
+pyredacc-0.11.1.dist-info/METADATA,sha256=AWgf-0xLyf3RbOD1Rzo4FyUdbvfJKUB2Pxx46-0zW4A,430
+pyredacc-0.11.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pyredacc-0.11.1.dist-info/entry_points.txt,sha256=v0mBhIfTLp-d3cr-Q8M_Iw9nOgqwuE-pHDkwic1y9eg,44
+pyredacc-0.11.1.dist-info/RECORD,,

pyredacc-0.11.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyredacc-0.11.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+redacc = pyredacc.cli:app