pybrid-computing 0.12.0__tar.gz → 0.12.3__tar.gz

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/.gitignore

@@ -125,6 +125,7 @@ __pycache__/
 .Python
 build/
 build-temp/
+build_tests/
 develop-eggs/
 dist/
 downloads/
@@ -394,4 +395,10 @@ objects
 refs
 
 # Generated documentation
-public/
+public/
+
+# Talks developed here for code anchoring
+talks/
+node_modules/
+package.json
+package-lock.json

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybrid-computing
-Version: 0.12.0
+Version: 0.12.3
 Summary: Library to interact with analog computers and analog-digital hybrid computers, in particular the LUCIDAC and REDAC computers made by anabrid
 Project-URL: Homepage, https://anabrid.com/
 Project-URL: Documentation, https://anabrid.dev/docs/pybrid/
@@ -28,6 +28,7 @@ Requires-Dist: pybrid-computing-native<1.0.0,>=0.1.0
 Requires-Dist: pydantic>=2.11.9
 Requires-Dist: pyi>=0.1.0
 Requires-Dist: pyserial-asyncio>=0.6
+Requires-Dist: reportlab>=4.4.10
 Requires-Dist: zeroconf>=0.147.2
 Description-Content-Type: text/markdown
 

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/pyproject.toml

@@ -33,6 +33,7 @@ dependencies = [
   "prompt-toolkit>=3.0.52",
   "pyserial-asyncio>=0.6",
   "pybrid-computing-native>=0.1.0,<1.0.0",
+  "reportlab>=4.4.10",
 ]
 
 [project.urls]

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/cli/dac/__init__.py

@@ -606,7 +606,6 @@ async def proxy(listen: str, port: int, backend: tuple[str, ...], session_timeou
     for spec in specs:
         click.echo(f"Connecting to backend {spec.host}:{spec.port}...")
         proxy_server.add_backend(spec.host, spec.port, stack=spec.stack, carrier=spec.carrier)
-    proxy_server.map_backends()
 
     proxy_server.set_session_timeout(session_timeout)
     proxy_server.start(listen, port)

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/lucipy/computer.py

@@ -94,6 +94,9 @@ class LucipyWrapper:
         self._num_devices = len(endpoints)
         self._device_indices = list(range(self._num_devices))
 
+    def controller(self):
+        return self._controller
+
     def create_circuit(self, device_index: int | None = None) -> Circuit:
         """Create a Circuit scoped to a specific carrier's MAC address.
 

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/mock/dummy_dac.py

@@ -89,7 +89,6 @@ class DummyDAC:
             ExtractHandler,
             UDPStreamingHandler,
             StartRunHandler,
-            RegisterExternalEntitiesHandler,
             CalibrationHandler,
         )
 
@@ -103,7 +102,6 @@ class DummyDAC:
             pb.MessageV1.EXTRACT_COMMAND_FIELD_NUMBER: ExtractHandler(self),
             pb.MessageV1.UDP_DATA_STREAMING_COMMAND_FIELD_NUMBER: UDPStreamingHandler(self),
             pb.MessageV1.START_RUN_COMMAND_FIELD_NUMBER: StartRunHandler(self),
-            pb.MessageV1.REGISTER_EXTERNAL_ENTITIES_COMMAND_FIELD_NUMBER: RegisterExternalEntitiesHandler(self),
             calibration_field: CalibrationHandler(self),
         }
 

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/mock/handler/__init__.py

@@ -10,7 +10,6 @@ from pybrid.mock.handler.config import ConfigHandler
 from pybrid.mock.handler.extract import ExtractHandler
 from pybrid.mock.handler.udp_streaming import UDPStreamingHandler
 from pybrid.mock.handler.start_run import StartRunHandler
-from pybrid.mock.handler.register_external_entities import RegisterExternalEntitiesHandler
 from pybrid.mock.handler.calibration import CalibrationHandler
 
 __all__ = [
@@ -20,6 +19,5 @@ __all__ = [
     "ExtractHandler",
     "UDPStreamingHandler",
     "StartRunHandler",
-    "RegisterExternalEntitiesHandler",
     "CalibrationHandler",
 ]

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/redac/blocks/backplane_tblock.py

@@ -12,20 +12,16 @@ from pybrid.redac.entities import EntityClass, EntityType, Loc
 @EntityType.register(EntityClass.T_BLOCK_BPL)
 @dataclass
 class BackplaneTBlock(FunctionBlock):
-    muxes: list[int | None] = field(default_factory=lambda: [None] * 8 * 9)
-
-    @staticmethod
-    def index(dst_sector: int, sector_lane: int) -> int:
-        assert 0 <= sector_lane < 8
-        assert 0 <= dst_sector < 9
-        return dst_sector + sector_lane * 9
+    sectors: list[list[int | None]] = field(default_factory=lambda: [[None] * 8 for _ in range(9)])
 
     def connect(self, src_sector: int, dst_sector: int, sector_lane: int):
         assert 0 <= src_sector < 9
-        self.muxes[BackplaneTBlock.index(dst_sector, sector_lane)] = src_sector
+        assert 0 <= dst_sector < 9
+        assert 0 <= sector_lane < 8
+        self.sectors[dst_sector][sector_lane] = src_sector
 
     def source(self, dst_sector: int, sector_lane: int) -> int:
-        return self.muxes[BackplaneTBlock.index(dst_sector, sector_lane)]
+        return self.sectors[dst_sector][sector_lane]
 
     def reset(self):
-        self.muxes = [None] * 8 * 9
+        self.sectors = [[None] * 8 for _ in range(9)]

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/redac/carrier.py

@@ -8,6 +8,7 @@ import logging
 import warnings
 from dataclasses import dataclass, field
 from typing import Optional, TYPE_CHECKING
+from enum import Enum
 
 from pybrid.base.hybrid import EntityDoesNotExist
 from pybrid.redac.blocks import TBlock
@@ -32,6 +33,12 @@ class ADCChannel:
     #: Probe: relates this ADC channel to an input function (e.g. a problem description, such as an ODE)
     probe: int = -1
 
+class FrontPanelIOMode(int, Enum):
+    ANALOG_OUT = 0
+    ANALOG_IN = 1
+    DIGITAL_OUT = 2
+    DIGITAL_IN = 3
+
 @dataclass(kw_only=True)
 class Carrier(Entity):
     """
@@ -48,8 +55,12 @@ class Carrier(Entity):
     adc_config: list[Optional[ADCChannel]] = field(default_factory=list)
 
     #: ACL Select for analog I/O - note that while not supported in HW, the firmware ignores this.
+    #: This is the LUCIDAC implementation.
     acl_select: Optional[list[str]] = None
 
+    #: Current implementation of the FrontPlane on REDACs (no specific entity)
+    front_panel_io: Optional[list[FrontPanelIOMode]] = None
+
     #: List of clusters on the carrier board.
     clusters: list[Cluster]
 

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/redac/control.py

@@ -15,10 +15,8 @@ executor when multiple channels run concurrently.
 
 import asyncio
 import logging
-import time
 from concurrent.futures import ThreadPoolExecutor
 from typing import Callable
-from uuid import uuid4
 
 import pybrid.base.proto.main_pb2 as pb
 from pybrid.base.result import Result
@@ -52,16 +50,12 @@ class AsyncControlChannel:
     def __init__(
         self,
         native: "NativeControlChannel",
-        max_busy_wait: float = 30.0,
     ):
         """
         Args:
-            native:        A connected ``NativeControlChannel`` instance.
-            max_busy_wait: Maximum time in seconds to wait when a ``busy_response``
-                           is received before raising :class:`TimeoutError`.
+            native: A connected ``NativeControlChannel`` instance.
         """
         self._native = native
-        self._max_busy_wait = max_busy_wait
         self._executor = ThreadPoolExecutor(
             max_workers=1,
             thread_name_prefix="ctrl-channel",
@@ -159,71 +153,6 @@ class AsyncControlChannel:
         """``True`` if the C++ recv thread is active."""
         return self._native.is_running()
 
-    async def send(self, msg: pb.MessageV1) -> None:
-        """Fire-and-forget send — queues the serialized message for async TCP transmission."""
-        self._native.send(msg.SerializeToString())
-
-    async def _raw_send_and_recv(
-        self,
-        msg: pb.MessageV1,
-        timeout: float = 5.0,
-    ) -> pb.MessageV1:
-        """Low-level send + receive without busy-wait retry logic.
-
-        Factored out from :meth:`send_and_recv` so the busy-wait loop can
-        call it without infinite recursion.
-        """
-        data = msg.SerializeToString()
-        loop = asyncio.get_running_loop()
-        response_bytes = await loop.run_in_executor(
-            self._executor,
-            self._native.send_and_recv,
-            data,
-            timeout,
-        )
-        response = pb.MessageV1()
-        response.ParseFromString(response_bytes)
-        return response
-
-    async def send_and_recv(
-        self,
-        msg: pb.MessageV1,
-        timeout: float = 5.0,
-    ) -> pb.MessageV1:
-        """Send a request and await the matching response.
-
-        If the proxy returns a ``busy_response``, polls with
-        :class:`pb.PingCommand` every second until the session becomes active,
-        then re-sends the original message.
-
-        :raises TimeoutError: If the device remains busy longer than
-            ``max_busy_wait`` seconds.
-        """
-        response = await self._raw_send_and_recv(msg, timeout)
-
-        if response.HasField("busy_response"):
-            logger.info("Device busy, waiting for session to become active...")
-            start_time = time.monotonic()
-            while True:
-                elapsed = time.monotonic() - start_time
-                if elapsed >= self._max_busy_wait:
-                    logger.warning("Device busy timeout after %.1fs (max_busy_wait=%.1fs)", elapsed, self._max_busy_wait)
-                    raise TimeoutError(
-                        f"Device busy for {elapsed:.1f}s, exceeded max wait "
-                        f"of {self._max_busy_wait}s"
-                    )
-                await asyncio.sleep(1.0)
-                ping_msg = self._new_message(pb.PingCommand())
-                ping_response = await self._raw_send_and_recv(ping_msg, timeout)
-                if ping_response.HasField("busy_response"):
-                    logger.info("Still waiting... (%.0fs elapsed)", time.monotonic() - start_time)
-                else:
-                    logger.info("Session active, proceeding.")
-                    break
-            response = await self._raw_send_and_recv(msg, timeout)
-
-        return response
-
     def register_callback(self, field_number: int, callback: Callable) -> None:
         """Register a callback for a specific message field number.
 
@@ -255,24 +184,6 @@ class AsyncControlChannel:
     def unregister_callback(self, field_number: int) -> None:
         self._native.unregister_callback(field_number)
 
-    @staticmethod
-    def _new_message(body) -> pb.MessageV1:
-        """Build a :class:`pb.MessageV1` wrapping *body* in the correct oneof field."""
-        msg = pb.MessageV1(id=str(uuid4()))
-        fields = msg.DESCRIPTOR.oneofs_by_name["kind"].fields
-        for field in fields:
-            if field.message_type == body.DESCRIPTOR:
-                getattr(msg, field.name).CopyFrom(body)
-                return msg
-        raise ValueError(f"No MessageV1 oneof field for {type(body).__name__}")
-
-    @staticmethod
-    def _to_result(response: pb.MessageV1) -> Result:
-        """Convert a response message to a :class:`~pybrid.base.result.Result`."""
-        if response.HasField("error_message"):
-            return Result.failure(response.error_message.description)
-        return Result.success()
-
     async def extract(
         self,
         path: "str | Path | None" = None,
@@ -360,23 +271,6 @@ class AsyncControlChannel:
         except RuntimeError as e:
             return Result.failure(str(e))
 
-    async def register_external_entities(
-        self,
-        entities: dict[str, tuple[int, int, int, int]],
-        timeout: float = 5.0,
-    ) -> Result:
-        """Send a ``RegisterExternalEntitiesCommand`` with the given entity map.
-
-        No C++ convenience method exists — builds protobuf in Python.
-        """
-        cmd = pb.RegisterExternalEntitiesCommand()
-        for mac, ip_octets in entities.items():
-            addr = pb.Address(data=bytes(ip_octets))
-            cmd.entities[mac].CopyFrom(addr)
-        msg = self._new_message(cmd)
-        response = await self.send_and_recv(msg, timeout)
-        return self._to_result(response)
-
     async def reset(
         self,
         *,

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/redac/controller.py

@@ -309,32 +309,6 @@ class Controller(BaseController):
         result = await session.execute()
         return result[0] if result else run
 
-    async def register_external_entities(self):
-        """Distribute carrier MACs and IP addresses to every connected device.
-
-        Builds a map of ``{carrier_mac: ip_octets}`` from all carriers
-        in :attr:`computer` and sends a ``RegisterExternalEntitiesCommand`` to
-        each unique backend connection.
-        """
-
-        # TODO: reinstate once implemented in the firmware
-        logger.warning("RegisterExternalEntities command skipped...")
-        return
-
-        if not self.computer.carriers:
-            return
-
-        entities: dict[str, tuple[int, int, int, int]] = {}
-        for carrier in self.computer.carriers:
-            conn = self.connection_manager.get_connection(carrier.path)
-            host = conn.control.remote_host
-            octets = tuple(int(x) for x in host.split("."))
-            entities[str(carrier.path)] = octets
-
-        for conn in self.connection_manager.get_unique_connections():
-            result = await conn.control.register_external_entities(entities)
-            result.raise_on_error()
-
     async def reset(self, keep_calibration: bool = True, sync: bool = True):
         """Reset all carrier boards to initial configuration."""
         for conn in self.connection_manager.get_unique_connections():

{pybrid_computing-0.12.0 → pybrid_computing-0.12.3}/src/pybrid/redac/protocol/serializer.py

@@ -14,7 +14,7 @@ from pybrid.base.proto import main_pb2 as pb
 from pybrid.redac.blocks import (
     CBlock, MMulBlock, TBlock, MIntBlock, UBlock, IBlock, MMDRBlock
 )
-from pybrid.redac.carrier import Carrier, ADCChannel
+from pybrid.redac.carrier import Carrier, ADCChannel, FrontPanelIOMode
 from pybrid.redac.blocks.backplane_tblock import BackplaneTBlock
 from pybrid.redac.cluster import Cluster
 from pybrid.redac.device import Device
@@ -74,6 +74,22 @@ class REDACSerializer(Serializer):
                 acl_select.append(pb.PortConfig.AclState.EXTERNAL if \
                     interface.lower() == "external" else pb.PortConfig.AclState.INTERNAL)
 
+        # Front Panel ports for mREDAC
+        if entity.front_panel_io:
+            front_panel_io_config = self.cc.new_config(entity).front_panel_io_config
+
+            for mode in entity.front_panel_io:
+                if mode == FrontPanelIOMode.ANALOG_OUT:
+                    front_panel_io_config.io_modes.append(pb.FrontPanelIOConfig.FrontPanelIOMode.ANALOG_OUT)
+                elif mode == FrontPanelIOMode.ANALOG_IN:
+                    front_panel_io_config.io_modes.append(pb.FrontPanelIOConfig.FrontPanelIOMode.ANALOG_IN)
+                elif mode == FrontPanelIOMode.DIGITAL_OUT:
+                    front_panel_io_config.io_modes.append(pb.FrontPanelIOConfig.FrontPanelIOMode.DIGITAL_OUT)
+                elif mode == FrontPanelIOMode.DIGITAL_IN:
+                    front_panel_io_config.io_modes.append(pb.FrontPanelIOConfig.FrontPanelIOMode.DIGITAL_IN)
+                else:
+                    logger.warning(f"Unknown FrontPanelIO value: {mode}")
+
     @_serialize_configuration.register
     def _(self, entity: CBlock):
         coef_config = self.cc.new_config(entity).coef_config
@@ -160,10 +176,15 @@ class REDACSerializer(Serializer):
     @_serialize_configuration.register
     def _(self, entity: BackplaneTBlock):
         switch_config = self.cc.new_config(entity).bpl_switch_config
-        for idx, state in enumerate(entity.muxes):
-            if state is None:
-                continue
-            switch_config.muxes.append(pb.Mux(state=state, index=idx))
+        for sector_out, lane_ins in enumerate(entity.sectors):
+            for lane_in, sector_in in enumerate(lane_ins):
+                if lane_ins is None:
+                    continue
+
+                if sector_in == 8:
+                    sector_in = sector_out
+
+                switch_config.muxes.append(pb.Mux(state=sector_in, index=9 * lane_in + sector_out))
 
         if len(switch_config.muxes) == 0:
             self.cc.pop_config()
@@ -622,15 +643,25 @@ class REDACDeserializer(Deserializer):
     def _(self, config: pb.BPLSwitchConfig):
         """Deserialize switch configuration and apply to TBlock."""
         entity_path = Path.parse(self._current_full_config.entity.path)
-        entity: TBlock = self.computer.get_entity(entity_path)
+        entity: BackplaneTBlock = self.computer.get_entity(entity_path)
 
         is_numerated = all(obj.index == 0 for obj in config.muxes)
+
+        def connect(in_sector, idx):
+            lane = idx // 9
+            out_sector = idx % 9
+
+            if out_sector == in_sector:
+                in_sector = 8
+
+            entity.connect(in_sector, out_sector, lane)
+
         if is_numerated:
             for idx, mux in enumerate(config.muxes):
-                entity.muxes[idx] = mux.state
+                connect(mux.state, idx)
         else:
             for mux in config.muxes:
-                entity.muxes[mux.index] = mux.state
+                connect(mux.state, mux.index)
 
 
     @_deserialize_configuration.register
@@ -647,4 +678,23 @@ class REDACDeserializer(Deserializer):
                 acl_select.append("internal")
         entity.acl_select = acl_select
 
+    @_deserialize_configuration.register
+    def _(self, config: pb.FrontPanelIOConfig):
+        """Deserialize front panel config from REDACs and apply to Carrier."""
+        entity_path = Path.parse(self._current_full_config.entity.path)
+        entity = self.computer.get_entity(entity_path)
+
+        io_modes = []
+        for mode in config.io_modes:
+            if mode == pb.FrontPanelIOConfig.ANALOG_OUT:
+                io_modes.append(FrontPanelIOMode.ANALOG_OUT)
+            elif mode == pb.FrontPanelIOConfig.ANALOG_IN:
+                io_modes.append(FrontPanelIOMode.ANALOG_IN)
+            elif mode == pb.FrontPanelIOConfig.DIGITAL_OUT:
+                io_modes.append(FrontPanelIOMode.DIGITAL_OUT)
+            elif mode == pb.FrontPanelIOConfig.DIGITAL_IN:
+                io_modes.append(FrontPanelIOMode.DIGITAL_IN)
+            else:
+                logger.warning(f"Unknown FrontPanelIOValue: {mode}")
 
+        entity.io_modes = io_modes

pybrid_computing-0.12.3/src/pybrid/redac/router.py

@@ -0,0 +1,184 @@
+import typing
+from typing import Dict, Set, List
+
+from pybrid.redac.blocks import TBlock
+from pybrid.redac.blocks.backplane_tblock import BackplaneTBlock
+from pybrid.redac.carrier import Carrier
+from pybrid.redac.entities import Path, Loc
+
+
+class RoutingException(Exception):
+    def __init__(self, message: str = ""):
+        self.message = message
+
+class Routing:
+    carrier_t_blocks: Dict[Loc, TBlock] = {}
+    bpl_t_blocks: Dict[Loc, Dict[int, BackplaneTBlock]] = {}
+    dummy = TBlock(Path(("dummy", "T")))
+    bpl_dummy = BackplaneTBlock(Path(("dummy", "T")))
+
+    def add_t_block(self, t_block: TBlock):
+        loc = t_block.loc()
+        if loc.is_carrier():
+            self.carrier_t_blocks[loc.carrier()] = t_block
+
+    def add_t_bpl_block(self, idx: int, t_block: BackplaneTBlock):
+        loc = t_block.loc()
+        self.bpl_t_blocks.setdefault(loc.stack(), {})[idx] = t_block
+
+    def add_carrier(self, carrier: Carrier):
+        if carrier.tblock:
+            self.add_t_block(carrier.tblock)
+        if carrier.st0block:
+            self.add_t_bpl_block(0, carrier.st0block)
+        if carrier.st1block:
+            self.add_t_bpl_block(1, carrier.st1block)
+        if carrier.st2block:
+            self.add_t_bpl_block(2, carrier.st2block)
+
+    def find_carrier_t_block(self, loc: Loc) -> TBlock:
+        return self.carrier_t_blocks.get(loc.carrier(), self.dummy)
+
+    def find_bpl_t_block(self, loc: Loc, idx: int) -> BackplaneTBlock:
+        return self.bpl_t_blocks.get(loc.stack(), {}).get(idx, self.bpl_dummy)
+
+class Router(Routing):
+
+    # route two cluster
+    def _route_cluster(self, src: Loc, dst: Loc):
+        assert src.carrier() == dst.carrier()
+
+        if src.lane_id() < 8:
+            if src != dst:
+                raise RoutingException("First 8 lanes only to same indices routable")
+            return None
+
+        output_sector_lane = src.lane_id() - 8
+        input_sector_lane = dst.lane_id() - 8
+
+        if output_sector_lane != input_sector_lane:
+            raise RoutingException("Connections inside cluster are only allowed between same lane indices!")
+
+        tblock = self.find_carrier_t_block(dst)
+        return tblock.connect(src.cluster_id() + 1, dst.cluster_id() + 1, input_sector_lane)
+
+    def _route_carrier(self, src: Loc, dst: Loc):
+        if src.lane_id() != dst.lane_id():
+            raise RoutingException("Connections between clusters are only allowed between same lane indices!")
+
+        if 0 <= src.lane_id() < 8:
+            raise RoutingException("Connections between clusters are only allowed between 8 to 31 lane indices!")
+
+        t_block = self.find_carrier_t_block(dst)
+        t_block.connect(src.cluster_id() + 1, dst.cluster_id() + 1, dst.lane_id() - 8)
+
+    def _route_stack(self, src: Loc, dst: Loc):
+        if src.lane_id() != dst.lane_id():
+            raise RoutingException("Connections between carrier are only allowed between same lane indices!")
+
+        if not (8 <= src.lane_id() < 32):
+            raise RoutingException("Connections between carrier are only allowed between 8 to 31 lane indices!")
+
+        offset_lane_id = src.lane_id() - 8
+        partition = offset_lane_id // 8
+
+        output_t_block = self.find_carrier_t_block(src)
+        input_t_block = self.find_carrier_t_block(dst)
+
+        #sector 0 is connect to backplane
+        #cluster 0-2 are sector 1-3
+        output_t_block.connect(src.cluster_id() + 1, 0, offset_lane_id)
+        input_t_block.connect(0, dst.cluster_id() + 1, offset_lane_id)
+
+        mod_dst_lane = dst.lane_id() % 8
+        if src.stack() != dst.stack():
+            src_bpl_t_block = self.find_bpl_t_block(src, partition)
+            dst_bpl_t_block = self.find_bpl_t_block(dst, partition)
+
+            exit_sector = 7 if src.stack_id() < dst.stack_id() else 8
+            entry_sector = 8 if src.stack_id() < dst.stack_id() else 7
+
+            src_bpl_t_block.connect(src.carrier_id(), exit_sector, mod_dst_lane)
+            dir = 1 if src.stack_id() < dst.stack_id() else -1
+            for btw_stack_idx in range(src.stack_id() + dir, dst.stack_id(), dir):
+                btw_bpl_t_block = self.find_bpl_t_block(Loc.new_stack(btw_stack_idx), partition)
+                btw_bpl_t_block.connect(entry_sector, exit_sector, mod_dst_lane)
+
+            dst_bpl_t_block.connect(entry_sector, dst.carrier_id(), mod_dst_lane)
+        else:
+            bpl_t_block = self.find_bpl_t_block(src, partition)
+            bpl_t_block.connect(src.carrier_id(), dst.carrier_id(), mod_dst_lane)
+
+
+    def route(self, src: Loc, dst: Loc):
+        assert src.carrier_id() < 7 and dst.carrier_id() < 7
+        assert src.cluster_id() < 3 and dst.cluster_id() < 3
+        assert dst.lane_id() < 32 and src.lane_id() < 32
+        if src.cluster() == dst.cluster():
+            return self._route_cluster(src, dst)
+
+        if src.carrier() == dst.carrier():
+            return self._route_carrier(src, dst)
+
+        return self._route_stack(src, dst)
+
+
+class Tracer(Routing):
+
+    #loc is a lane in a cluster after a the t block searching for the coef source
+    #loc here is stack / carrier / cluster_id / lane
+    def find_coef(self, loc: Loc) -> typing.Optional[Loc]:
+
+        visited = set()
+
+        if loc.lane_id() < 8:
+            return loc
+
+        # only here we bump cluster_id because we need 0 for backplane
+        loc = loc.carrier() / (loc.cluster_id() + 1) / loc.lane_id()
+
+        while True:
+            if loc.lane_id() < 8:
+                return loc
+
+            if loc in visited:
+                return None
+            visited.add(loc)
+
+            carrier_t_block = self.find_carrier_t_block(loc.carrier())
+
+            # source is either the result of coef or from bpl t block
+            tblock_lane = loc.lane_id() - 8
+            source = carrier_t_block.source(loc.cluster_id(), tblock_lane)
+            if source is None or not (0 <= source < 4):
+                return None
+
+            if source != 0:
+                return loc.carrier() / (source - 1) / loc.lane_id()
+
+            # here source is from backplane
+            current_stack = loc.stack()
+            prev_carrier_id = loc.carrier_id()
+
+            while True:
+                bpl_t_block = self.find_bpl_t_block(current_stack, tblock_lane // 8)
+                prev_carrier_id = bpl_t_block.source(prev_carrier_id, tblock_lane % 8)
+
+                if prev_carrier_id is None:
+                    return None
+                elif prev_carrier_id == 8:
+                    current_stack = Loc.new_stack(current_stack.stack_id() - 1)
+                    prev_carrier_id = 7
+                elif prev_carrier_id == 7:
+                    current_stack = Loc.new_stack(current_stack.stack_id() + 1)
+                    prev_carrier_id = 8
+                else:
+                    break
+
+            if 0 <= prev_carrier_id <= 6:
+                # 0 because backpanel here!
+                loc = current_stack / prev_carrier_id / 0 / loc.lane_id()
+                continue
+            else:
+                #external
+                raise RoutingException("Connections between stacks not implemented yet!")

pybrid_computing-0.12.0/src/pybrid/mock/handler/register_external_entities.py

@@ -1,33 +0,0 @@
-# Copyright (c) 2022-2025 anabrid GmbH
-# Contact: https://www.anabrid.com/licensing/
-# SPDX-License-Identifier: MIT OR GPL-2.0-or-later
-
-"""Handler for the register external entities command."""
-
-from typing import TYPE_CHECKING
-
-import pybrid.base.proto.main_pb2 as pb
-from pybrid.mock.handler.base import BaseHandler
-
-if TYPE_CHECKING:
-    from pybrid.mock.connection import ClientConnection
-
-
-class RegisterExternalEntitiesHandler(BaseHandler):
-    """Handler for external entities registration commands.
-
-    Stores the received entity map for test inspection but performs no
-    real coordination (DummyDAC doesn't route cross-carrier signals).
-    """
-
-    last_entities: dict[str, bytes]
-
-    def __init__(self, server):
-        super().__init__(server)
-        self.last_entities = {}
-
-    async def handle(
-        self, cmd: pb.RegisterExternalEntitiesCommand, connection: "ClientConnection"
-    ) -> pb.SuccessMessage:
-        self.last_entities = {k: v.data for k, v in cmd.entities.items()}
-        return pb.SuccessMessage()

pybrid_computing-0.12.0/src/pybrid/redac/router.py

@@ -1,159 +0,0 @@
-import typing
-from typing import Dict, Set, List
-
-from pybrid.redac.blocks import TBlock
-from pybrid.redac.blocks.backplane_tblock import BackplaneTBlock
-from pybrid.redac.carrier import Carrier
-from pybrid.redac.entities import Path, Loc
-
-
-class RoutingException(Exception):
-    def __init__(self, message: str = ""):
-        self.message = message
-
-class Routing:
-    carrier_t_blocks: Dict[Loc, TBlock] = {}
-    bpl_t_blocks: Dict[Loc, Dict[int, BackplaneTBlock]] = {}
-    dummy = TBlock(Path(("dummy", "T")))
-    bpl_dummy = BackplaneTBlock(Path(("dummy", "T")))
-
-    def add_t_block(self, t_block: TBlock):
-        loc = t_block.loc()
-        if loc.is_carrier():
-            self.carrier_t_blocks[loc.carrier()] = t_block
-
-    def add_t_bpl_block(self, idx: int, t_block: BackplaneTBlock):
-        loc = t_block.loc()
-        self.bpl_t_blocks.setdefault(loc.stack(), {})[idx] = t_block
-
-    def add_carrier(self, carrier: Carrier):
-        if carrier.tblock:
-            self.add_t_block(carrier.tblock)
-        if carrier.st0block:
-            self.add_t_bpl_block(0, carrier.st0block)
-        if carrier.st1block:
-            self.add_t_bpl_block(1, carrier.st1block)
-        if carrier.st2block:
-            self.add_t_bpl_block(2, carrier.st2block)
-
-    def find_carrier_t_block(self, loc: Loc) -> TBlock:
-        return self.carrier_t_blocks.get(loc.carrier(), self.dummy)
-
-    def find_bpl_t_block(self, loc: Loc, idx: int) -> BackplaneTBlock:
-        return self.bpl_t_blocks.get(loc.stack(), {}).get(idx, self.bpl_dummy)
-
-class Router(Routing):
-
-    # route two cluster
-    def _route_cluster(self, output: Loc, input: Loc):
-        assert output.carrier() == input.carrier()
-
-        if output.lane_id() < 8:
-            if output != input:
-                raise RoutingException("First 8 lanes only to same indices routable")
-            return None
-
-        output_sector_lane = output.lane_id() - 8
-        input_sector_lane = input.lane_id() - 8
-
-        if output_sector_lane != input_sector_lane:
-            raise RoutingException("Connections inside cluster only allowed between same lane indices!")
-
-        tblock = self.find_carrier_t_block(input)
-        return tblock.connect(output.cluster_id() + 1, input.cluster_id() + 1, input_sector_lane)
-
-    def _route_carrier(self, output: Loc, input: Loc):
-        if output.lane_id() != input.lane_id():
-            raise RoutingException("Connections between clusters only allowed between same lane indices!")
-
-        if 0 <= output.lane_id() < 8:
-            raise RoutingException("Connections between clusters only allowed between 8 to 31 lane indices!")
-
-        t_block = self.find_carrier_t_block(input)
-        t_block.connect(output.cluster_id() + 1, input.cluster_id() + 1, input.lane_id() - 8)
-
-    def _route_stack(self, output: Loc, input: Loc):
-        if output.lane_id() != input.lane_id():
-            raise RoutingException("Connections between carrier only allowed between same lane indices!")
-
-        if not (8 <= output.lane_id() < 32 ):
-            raise RoutingException("Connections between carrier only allowed between 8 to 31 lane indices!")
-
-        offset_lane_id = output.lane_id() - 8
-        partition = offset_lane_id // 8
-
-        output_t_block = self.find_carrier_t_block(output)
-        input_t_block = self.find_carrier_t_block(input)
-
-        #index 0 is connect to backplane
-        #cluster 0-2 are sector 1-3
-        output_t_block.connect(output.cluster_id() + 1, 0, offset_lane_id)
-        input_t_block.connect(0, input.cluster_id() + 1, offset_lane_id)
-
-        bpl_t_block = self.find_bpl_t_block(output, partition)
-        bpl_t_block.connect(output.carrier_id(), input.carrier_id(), input.lane_id() % 8)
-
-
-    def route(self, output: Loc, input: Loc):
-        assert output.stack_id() < 2 and input.stack_id() < 2
-        assert output.carrier_id() < 7 and input.carrier_id() < 7
-        assert output.cluster_id() < 3 and input.cluster_id() < 3
-        assert input.lane_id() < 32 and output.lane_id() < 32
-        if output.cluster() == input.cluster():
-            return self._route_cluster(output, input)
-
-        if output.carrier() == input.carrier():
-            return self._route_carrier(output, input)
-
-        if output.stack() == input.stack():
-            return self._route_stack(output, input)
-
-        raise RoutingException("Connections between stacks not implemented yet!")
-
-
-class Tracer(Routing):
-
-    #loc is a lane in a cluster after a the t block searching for the coef source
-    #loc here is stack / carrier / cluster_id / lane
-    def find_coef(self, loc: Loc) -> typing.Optional[Loc]:
-
-        visited = set()
-
-        if loc.lane_id() < 8:
-            return loc
-
-        # only here we bump cluster_id because we need 0 for backplane
-        loc = loc.carrier() / (loc.cluster_id() + 1) / loc.lane_id()
-
-        while True:
-            if loc.lane_id() < 8:
-                return loc
-
-            if loc in visited:
-                return None
-            visited.add(loc)
-
-            carrier_t_block = self.find_carrier_t_block(loc.carrier())
-
-            # source is either the result of coef or from bpl t block
-            tblock_lane = loc.lane_id() - 8
-            source = carrier_t_block.source(loc.cluster_id(), tblock_lane)
-            if source is None or not (0 <= source < 4):
-                return None
-
-            if source != 0:
-                return loc.carrier() / (source - 1) / loc.lane_id()
-
-            # here source is from backpanel
-            bpl_t_block = self.find_bpl_t_block(loc, tblock_lane // 8)
-            prev_carrier_id = bpl_t_block.source(loc.carrier_id(), tblock_lane % 8)
-            if prev_carrier_id is None:
-                return None
-
-            if 0 <= prev_carrier_id <= 6:
-                # 0 because backpanel here!
-                loc = loc.stack() / prev_carrier_id / 0 / loc.lane_id()
-                continue
-            else:
-                #external
-                raise RoutingException("Connections between stacks not implemented yet!")