bytesim 0.1.0__py3-none-any.whl

bytesim/model/types.py

@@ -0,0 +1,107 @@
+"""Plain data: devices, cables, interface addresses."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..constants import BOX_H, KINDS
+
+
+class NetError(Exception):
+    pass
+
+
+def fmt(addr: tuple[int, int] | None) -> str:
+    return f"({addr[0]},{addr[1]})" if addr else "—"
+
+
+@dataclass
+class Iface:
+    """Logical address of one port/NIC: (network id, 8-bit host).
+
+    mode: "dhcp" (computers' default), "adhoc" (pick a free host, no server),
+          "static", "auto" (router/gateway ports), or "none".
+    via:  how the current address was actually obtained.
+    """
+    mode: str
+    net: int | None = None
+    host: int | None = None
+    gw: int | None = None       # gateway's host number, on the same network
+    via: str = ""
+
+    @property
+    def addr(self) -> tuple[int, int] | None:
+        return (self.net, self.host) if self.host is not None and self.net is not None else None
+
+    def clear(self) -> None:
+        self.net = self.host = self.gw = None
+        self.via = ""
+
+
+Leg = tuple[tuple[str, int], tuple[str, int], list[tuple[str, int]]]
+
+
+@dataclass
+class Device:
+    kind: str
+    num: int
+    nports: int
+    x: int = 0
+    y: int = 0
+    up: bool = True
+
+    @property
+    def id(self) -> str:
+        return f"{self.kind}{self.num}"
+
+    @property
+    def name(self) -> str:
+        return KINDS[self.kind][0]
+
+    @property
+    def color(self) -> str:
+        return KINDS[self.kind][2]
+
+    @property
+    def width(self) -> int:
+        return max(len(self.id) + 2, self.nports + 2) + 2
+
+    def port_x(self, port: int) -> int:
+        inner = self.width - 2
+        return self.x + 1 + (inner - self.nports) // 2 + (port - 1)
+
+    def port_name(self, port: int) -> str:
+        return f"nic{port}" if self.kind == "c" else f"p{port}"
+
+    def mac(self, port: int) -> str:
+        """Device id plus a port letter: R1A, R1B, ... Z, AA, AB ..."""
+        letters, n = "", port
+        while n:
+            n, r = divmod(n - 1, 26)
+            letters = chr(65 + r) + letters
+        return self.id.upper() + letters
+
+    def contains(self, x: int, y: int) -> bool:
+        return self.x <= x < self.x + self.width and self.y <= y < self.y + BOX_H
+
+
+@dataclass
+class Link:
+    a: str
+    pa: int
+    b: str
+    pb: int
+    role: str = "data"       # data | control | control-backup | fabric
+    up: bool = True
+
+    @property
+    def control(self) -> bool:
+        return self.role.startswith("control")
+
+    def touches(self, dev_id: str) -> bool:
+        return dev_id in (self.a, self.b)
+
+    def other(self, dev_id: str) -> tuple[str, int]:
+        return (self.b, self.pb) if dev_id == self.a else (self.a, self.pa)
+
+    def port_of(self, dev_id: str) -> int:
+        return self.pa if dev_id == self.a else self.pb

bytesim/scripting.py

@@ -0,0 +1,108 @@
+"""Run ByteSim command scripts without the UI.
+
+The runner uses the *same* command handlers and interpreter as the app; only the
+screen is replaced by a stub. It builds structure (devices, groups, cables,
+settings) and skips what the screen and the address model would do after each
+command, which a script doesn't need to reproduce its structure.
+
+    from bytesim.scripting import replay
+    net = replay(open("site.txt").read())
+"""
+from __future__ import annotations
+
+from collections import Counter
+from types import SimpleNamespace
+
+from .model import NetError, Network
+from .tui.commands.addressing import AddressCommands
+from .tui.commands.groups import GroupCommands
+from .tui.commands.interpreter import Interpreter
+from .tui.commands.naming import NamingCommands
+from .tui.commands.registry import collect
+from .tui.commands.switching import SwitchingCommands
+from .tui.commands.topology import TopologyCommands
+from .tui.commands.traffic import TrafficCommands
+
+
+class _Screen:
+    """Stands in for the canvas: remembers the selection, finishes animations at once."""
+
+    def __init__(self) -> None:
+        self.selected: str | None = None
+        self.selected_group: str | None = None
+        self.pan = (0, 0)
+        self.packets: list = []
+        self.flash: dict = {}
+        self.hot_links: Counter = Counter()
+        self.size = SimpleNamespace(width=120, height=40)
+        self.busy = False
+
+    def select(self, dev_id: str | None) -> None:
+        self.selected, self.selected_group = dev_id, None
+
+    def select_group(self, name: str) -> None:
+        self.selected, self.selected_group = None, name
+
+    def send_packet(self, cells, color, on_done=None) -> None:
+        if on_done:
+            on_done()
+
+    def focus(self, *a) -> None: ...
+    def animate(self) -> None: ...
+    def refresh(self, *a, **k) -> None: ...
+    def reset(self) -> None: ...
+    def heat(self, links) -> None: ...
+    def cool(self, links) -> None: ...
+    def flash_device(self, *a, **k) -> None: ...
+
+
+class ScriptRunner(TopologyCommands, GroupCommands, AddressCommands, TrafficCommands, NamingCommands,
+                   SwitchingCommands, Interpreter):
+    """A headless ByteSim: feed it commands, read back ``net``."""
+
+    def __init__(self, network: Network | None = None) -> None:
+        self.net = network or Network()
+        self.auto = False
+        self.graph = False
+        self.replaying = 1            # always "in a script": no per-command side effects
+        self.naming = None
+        self.log: list[str] = []
+        self._ha_seen: dict = {}
+        self._screen = _Screen()
+        self._commands = collect(type(self))
+
+    @property
+    def canvas(self):  # type: ignore[override]
+        return self._screen
+
+    def log_msg(self, msg: str) -> None:
+        self.log.append(msg)
+
+    def changed(self, skip=frozenset()) -> None:   # structure only: no layout, no re-addressing
+        pass
+
+    def refresh_sidebar(self) -> None:
+        pass
+
+    def replace_network(self, net: Network, auto: bool) -> None:
+        self.net = net
+
+    def arrange(self, announce: bool = False) -> None:
+        pass
+
+    def exit(self) -> None:
+        pass
+
+    def run(self, text: str, origin: str = "script") -> Network:
+        """Run every command; raises NetError naming the line that failed."""
+        for n, line in self.script_lines(text):
+            try:
+                self.dispatch(self.tokens(line))
+            except NetError as e:
+                raise NetError(f"{origin}, line {n} ({line}): {e}") from None
+        return self.net
+
+
+def replay(text: str, network: Network | None = None) -> Network:
+    """Build a network by running a script (into a fresh network unless one is given)."""
+    return ScriptRunner(network).run(text)