bytesim 0.1.0__py3-none-any.whl

bytesim/model/equivalence.py

@@ -0,0 +1,86 @@
+"""Canonical form of a network, and the differences between two of them.
+
+Two networks are *equivalent* when they agree on everything ByteSim promises a
+construction script rebuilds: device ids, kinds and port counts; id counters
+(so the next new device gets the same id); groups, their nesting and member
+order; every cable's endpoints, ports and role; HA clusters; STP, DHCP-server
+and interface settings; and which devices and cables are failed.
+
+Deliberately ignored: positions (layout is recomputed), learned addresses
+(re-learned by DHCP and router autoconfiguration), MAC tables, STP's blocked
+ports (recomputed), storms, and the order groups were created in.
+"""
+from __future__ import annotations
+
+from collections import Counter
+from typing import Any
+
+from ..constants import KINDS
+from .network import Network
+
+DEFAULT_MODE = {"c": "dhcp", "g": "auto", "r": "auto"}
+
+
+def iface_config(net: Network, dev_id: str, port: int) -> tuple[str, Any]:
+    """An interface's configuration: (mode, static address or None)."""
+    dev = net.devices[dev_id]
+    ifc = net.ifaces.get(f"{dev_id}:{port}")
+    mode = ifc.mode if ifc else DEFAULT_MODE[dev.kind]
+    static = (ifc.net, ifc.host, ifc.gw) if ifc and mode == "static" and ifc.addr else None
+    return mode, static
+
+
+def link_key(a: str, pa: int, b: str, pb: int, role: str) -> tuple:
+    return (*sorted([(a, pa), (b, pb)], key=lambda e: (e[0][0], int(e[0][1:]), e[1])), role)
+
+
+def canonical(net: Network) -> dict[str, Any]:
+    nums = {k: [d.num for d in net.devices.values() if d.kind == k] for k in KINDS}
+    ifaces = {}
+    for d in net.sorted_devices():
+        if d.kind == "s":
+            continue
+        for p in range(1, d.nports + 1):
+            cfg = iface_config(net, d.id, p)
+            if cfg != (DEFAULT_MODE[d.kind], None):
+                ifaces[f"{d.id}:{p}"] = cfg
+    return {
+        "devices": {d.id: (d.kind, d.nports) for d in net.devices.values()},
+        "counters": {k: max([net.counters[k], *nums[k]]) for k in KINDS},
+        "cables": Counter(link_key(l.a, l.pa, l.b, l.pb, l.role) for l in net.links),
+        "groups": {g: tuple(ms) for g, ms in net.groups.items()},
+        "clusters": dict(net.clusters),
+        "stp_off": frozenset(net.stp_off),
+        "stp_priority": dict(net.stp_priority),
+        "dhcp_off": frozenset(net.dhcp_off),
+        "ifaces": ifaces,
+        "devices_down": frozenset(d.id for d in net.devices.values() if not d.up),
+        "cables_down": Counter(link_key(l.a, l.pa, l.b, l.pb, l.role) for l in net.links if not l.up),
+    }
+
+
+def differences(want: Network, got: Network, limit: int = 8) -> list[str]:
+    """Human-readable differences between two networks' canonical forms ([] = equivalent)."""
+    a, b = canonical(want), canonical(got)
+    out: list[str] = []
+    for key in a:
+        x, y = a[key], b[key]
+        if x == y:
+            continue
+        if isinstance(x, dict):
+            for k in sorted(set(x) | set(y), key=str):
+                if x.get(k) != y.get(k):
+                    out.append(f"{key} {k}: expected {x.get(k)!r}, got {y.get(k)!r}")
+        elif isinstance(x, Counter):
+            for k in sorted((x - y).keys()):
+                out.append(f"{key}: missing {_cable(k)}")
+            for k in sorted((y - x).keys()):
+                out.append(f"{key}: unexpected {_cable(k)}")
+        else:
+            out.append(f"{key}: expected {sorted(x)}, got {sorted(y)}")
+    return out[:limit] + ([f"… and {len(out) - limit} more"] if len(out) > limit else [])
+
+
+def _cable(key: tuple) -> str:
+    (a, pa), (b, pb), role = key
+    return f"{a}:p{pa}–{b}:p{pb}" + (f" ({role})" if role != "data" else "")

bytesim/model/groups.py

@@ -0,0 +1,133 @@
+"""Groups: named, nestable sets of devices and other groups."""
+from __future__ import annotations
+
+from ..constants import AUTO, BOX_H, GROUP_NAME, REF
+from .base import NetworkBase
+from .types import NetError
+
+
+class GroupsMixin(NetworkBase):
+    # A group's members are device ids and/or other group names (never ambiguous:
+    # group names can't look like device ids). Membership is a tree.
+
+    def parent_of(self, member: str) -> str | None:
+        return next((g for g, ms in self.groups.items() if member in ms), None)
+
+    def group_of(self, dev_id: str) -> str | None:
+        """The innermost group holding a device."""
+        return self.parent_of(dev_id)
+
+    def chain(self, member: str) -> list[str]:
+        """Enclosing groups, outermost first."""
+        out, g = [], self.parent_of(member)
+        while g is not None:
+            out.append(g)
+            g = self.parent_of(g)
+        return out[::-1]
+
+    def devices_in(self, name: str) -> list[str]:
+        out: list[str] = []
+        for m in self.groups.get(name, []):
+            out.extend(self.devices_in(m) if m in self.groups else [m])
+        return out
+
+    def subgroups(self, name: str) -> list[str]:
+        return [m for m in self.groups.get(name, []) if m in self.groups]
+
+    def height(self, name: str) -> int:
+        """Levels of nested groups inside this one (0 = only devices)."""
+        return max((1 + self.height(g) for g in self.subgroups(name)), default=0)
+
+    def free_group_name(self, prefix: str, reserved: frozenset[str] = frozenset()) -> str:
+        """prefix + the lowest number not already taken: fab → fab5 when fab1–fab4 exist.
+        ``reserved`` holds names claimed explicitly elsewhere (not created yet)."""
+        prefix = prefix.lower()
+        if REF.match(f"{prefix}1"):
+            raise NetError(f"{prefix}(…) would make names like device ids ({prefix}1)")
+        n = 1
+        while f"{prefix}{n}" in self.groups or f"{prefix}{n}" in self.devices or f"{prefix}{n}" in reserved:
+            n += 1
+        name = f"{prefix}{n}"
+        if not GROUP_NAME.match(name):
+            raise NetError(f"bad group name {name!r} (start with a letter, at most 16 characters)")
+        return name
+
+    def resolve_group_name(self, name: str, reserved: frozenset[str] = frozenset()) -> str:
+        """A group name, or an auto-number pattern like fab(1) turned into the next free one."""
+        m = AUTO.match(name)
+        if not m:
+            return name.lower()
+        if int(m[2]) != 1:
+            raise NetError(f"{name}: a group name stands for one group, so write {m[1]}(1)")
+        return self.free_group_name(m[1], reserved)
+
+    def group_add(self, name: str, members: list[str]) -> list[str]:
+        """Add devices and/or groups to a group (creating it at the top level).
+        Returns members that were moved out of another group."""
+        if not GROUP_NAME.match(name) or REF.match(name):
+            raise NetError(f"bad group name {name!r}: start with a letter and must not look like a device id")
+        if name in self.devices:
+            raise NetError(f"{name} is a device")
+        ids = []
+        for m in members:
+            if m in self.groups:
+                if m == name:
+                    raise NetError(f"can't put {name} inside itself")
+                if m in self.chain(name):
+                    raise NetError(f"can't put {m} inside {name}: {name} is already inside {m}")
+                ids.append(m)
+            else:
+                ids.append(self.get(m).id)
+        moved = [m for m in ids if self.parent_of(m) not in (None, name)]
+        group = self.groups.setdefault(name, [])
+        for m in ids:
+            old = self.parent_of(m)
+            if old not in (None, name):
+                self.groups[old].remove(m)
+            if m not in group:
+                group.append(m)
+        self._drop_from_groups([])
+        return moved
+
+    def ungroup(self, name: str, members: list[str] | None = None) -> int:
+        """Dissolve a group, or take some members out; either way they move up to its parent."""
+        if name not in self.groups:
+            raise NetError(f"no such group: {name}")
+        parent = self.parent_of(name)
+        if members is None:
+            kids = self.groups.pop(name)
+            if parent:
+                at = self.groups[parent].index(name)
+                self.groups[parent][at:at + 1] = kids
+            self.clusters.pop(name, None)
+            self._drop_from_groups([])
+            return len(kids)
+        ids = [m if m in self.groups else self.get(m).id for m in members]
+        out = [m for m in self.groups[name] if m in ids]
+        self.groups[name] = [m for m in self.groups[name] if m not in ids]
+        if parent:
+            self.groups[parent].extend(out)
+        self._drop_from_groups([])
+        return len(out)
+
+    def _drop_from_groups(self, ids: list[str]) -> None:
+        """Remove members everywhere, then prune groups left empty (and their references)."""
+        gone = set(ids)
+        while True:
+            for g in self.groups:
+                self.groups[g] = [m for m in self.groups[g] if m not in gone]
+            empty = {g for g, ms in self.groups.items() if not ms}
+            if not empty:
+                break
+            for g in empty:
+                del self.groups[g]
+            gone = empty
+        self.clusters = {c: pol for c, pol in self.clusters.items() if c in self.groups}
+
+    def group_bounds(self, name: str) -> tuple[int, int, int, int]:
+        """Frame rectangle (x0, y0, x1, y1), inclusive. Outer groups get wider margins
+        so nested frames sit inside each other."""
+        ds = [self.devices[d] for d in self.devices_in(name)]
+        h = self.height(name)
+        return (min(d.x for d in ds) - 2 - 2 * h, min(d.y for d in ds) - 1 - h,
+                max(d.x + d.width for d in ds) + 1 + 2 * h, max(d.y for d in ds) + BOX_H + h)

bytesim/model/ha.py

@@ -0,0 +1,93 @@
+"""HA router clusters: coordination over control links, virtual gateways, split-brain."""
+from __future__ import annotations
+
+from collections import deque
+
+from .base import NetworkBase
+from .types import Link
+
+
+class HAMixin(NetworkBase):
+    def cluster_of(self, dev_id: str) -> str | None:
+        if not self.is_router(dev_id):
+            return None
+        return next((g for g in reversed(self.chain(dev_id)) if g in self.clusters), None)
+
+    def ha_state(self, name: str) -> dict:
+        """Who is alive, who can coordinate, who is active, and who owns each virtual gateway.
+
+        Members coordinate only over control links. Each control-connected partition
+        elects its own active member per network; more than one active partition is
+        split-brain. The policy decides which partitions may stay active:
+        none (all), quorum (strict majority), witness (majority; a tie goes to the
+        partition holding the first surviving member)."""
+        members = [m for m in self.devices_in(name) if self.is_router(m)]
+        alive = [m for m in members if self.devices[m].up]
+        ctrl = [l for l in self.links if l.control and l.a in members and l.b in members]
+        ctrl_up = [l for l in ctrl if l.up and self.devices[l.a].up and self.devices[l.b].up]
+
+        def parts(links: list[Link]) -> list[list[str]]:
+            out, seen = [], set()
+            for m in alive:
+                if m in seen:
+                    continue
+                comp, q = [m], deque([m])
+                seen.add(m)
+                while q:
+                    u = q.popleft()
+                    for l in links:
+                        if l.touches(u) and (v := l.other(u)[0]) not in seen:
+                            seen.add(v)
+                            comp.append(v)
+                            q.append(v)
+                out.append(sorted(comp, key=members.index))
+            return out
+
+        partitions = parts(ctrl_up)
+        n, policy = len(members), self.clusters.get(name, "none")
+
+        def may_lead(part: list[str]) -> bool:
+            if policy == "quorum":
+                return 2 * len(part) > n
+            if policy == "witness":
+                # The witness sees who is alive and breaks ties for the first survivor.
+                return 2 * len(part) > n or (2 * len(part) == n and alive[0] in part)
+            return True
+
+        active = [p for p in partitions if may_lead(p)]
+        owners: dict[int, list[tuple[str, int]]] = {}
+        for part in active:
+            claimed: set[int] = set()
+            for m in part:
+                for port, ifc in self.addressed(m):
+                    li = self.link_index(m, port)
+                    if li is not None and self.usable(self.links[li]) and ifc.net not in claimed:
+                        claimed.add(ifc.net)
+                        owners.setdefault(ifc.net, []).append((m, port))
+        # Redundant coordination: losing any single control link mustn't split anyone.
+        redundant = len(partitions) == 1 and all(
+            len(parts([k for k in ctrl_up if k is not l])) == 1 for l in ctrl_up)
+        dead = [m for m in members if m not in alive]
+        leaders = [p[0] for p in active]
+        if not alive:
+            level, text = "down", "DOWN · every member has failed"
+        elif len(active) > 1:
+            level, text = "split", ("SPLIT-BRAIN · " + " | ".join(p[0] for p in active)
+                                    + " all active, no control link between them")
+        elif not active:
+            level, text = "down", "OUTAGE · no partition has quorum, all members stood down"
+        elif len(partitions) > 1:
+            standby = [m for p in partitions if p not in active for m in p]
+            level, text = "degraded", f"partitioned · {leaders[0]} active, {' '.join(standby)} stood down ({policy})"
+        elif dead:
+            level, text = "degraded", f"failover · {' '.join(dead)} down, {leaders[0]} active"
+        elif n > 1 and not redundant:
+            level, text = "degraded", f"no redundancy · control {len(ctrl_up)}/{len(ctrl)} up, one more failure splits it"
+        else:
+            level, text = "ok", f"healthy · {leaders[0]} active, control {len(ctrl_up)}/{len(ctrl)} up"
+        return {"members": members, "alive": alive, "partitions": partitions, "active": active,
+                "owners": owners, "ctrl": len(ctrl), "ctrl_up": len(ctrl_up),
+                "policy": policy, "level": level, "text": text}
+
+    def vip_owners(self, net: int) -> list[tuple[str, int]]:
+        return [o for c in self.clusters for o in self.ha_state(c)["owners"].get(net, [])]

bytesim/model/layer2.py

@@ -0,0 +1,106 @@
+"""Layer 2: which cables carry data, broadcast domains, frame paths, MAC learning."""
+from __future__ import annotations
+
+from collections import deque
+
+from .base import NetworkBase
+from .types import Link
+
+
+class Layer2Mixin(NetworkBase):
+    def usable(self, l: Link) -> bool:
+        """Can this cable carry data? Not if it's down, a control link, an end is dead,
+        STP is blocking either end, or a broadcast storm has saturated it."""
+        return (l.up and not l.control and self.devices[l.a].up and self.devices[l.b].up
+                and (l.a, l.pa) not in self.stp_blocked and (l.b, l.pb) not in self.stp_blocked
+                and l.a not in self.storming and l.b not in self.storming)
+
+    def segment(self, dev_id: str, port: int) -> list[tuple[str, int]]:
+        """Other interfaces in the same broadcast domain (reached through switches only)."""
+        li = self.link_index(dev_id, port)
+        if li is None or not self.usable(self.links[li]):
+            return []
+        v, vp = self.links[li].other(dev_id)
+        if self.devices[v].kind != "s":
+            return [(v, vp)]
+        seen, q, out = {v}, deque([v]), []
+        while q:
+            u = q.popleft()
+            for l in self.links:
+                if l.touches(u) and self.usable(l):
+                    w, wp = l.other(u)
+                    if (w, wp) == (dev_id, port):
+                        continue
+                    if self.devices[w].kind == "s":
+                        if w not in seen:
+                            seen.add(w)
+                            q.append(w)
+                    elif (w, wp) not in out:
+                        out.append((w, wp))
+        return out
+
+    def l2path(self, src: tuple[str, int], dst: tuple[str, int]) -> list[tuple[str, int]] | None:
+        """Frame path from one interface to another, switching only through switches."""
+        a, ap = src
+        li = self.link_index(a, ap)
+        if li is None or not self.usable(self.links[li]):
+            return None
+        v, vp = self.links[li].other(a)
+        if (v, vp) == dst:
+            return [(a, -1), (v, li)]
+        if self.devices[v].kind != "s":
+            return None
+        prev: dict[str, tuple[str, int]] = {v: (a, li)}
+        q = deque([v])
+        while q:
+            u = q.popleft()
+            for i, l in enumerate(self.links):
+                if not l.touches(u) or not self.usable(l):
+                    continue
+                w, wp = l.other(u)
+                if (w, wp) == dst:
+                    out, node = [(w, i)], u
+                    while node != a:
+                        out.append((node, prev[node][1]))
+                        node = prev[node][0]
+                    return [(a, -1)] + out[::-1]
+                if self.devices[w].kind == "s" and w not in prev:
+                    prev[w] = (u, i)
+                    q.append(w)
+        return None
+
+    def learn(self, src: tuple[str, int], path: list[tuple[str, int]]) -> None:
+        """Switches along a frame's path learn the sender's MAC on the ingress port."""
+        mac = self.devices[src[0]].mac(src[1])
+        for dev_id, li in path[1:]:
+            if self.devices[dev_id].kind == "s":
+                self.mac_tables.setdefault(dev_id, {})[mac] = self.links[li].port_of(dev_id)
+
+
+    # ---- graph-only mode -----------------------------------------------
+    def tree(self, src: str) -> dict[str, tuple[str, int] | None]:
+        """Shortest-path tree ignoring addresses. Computers never forward."""
+        prev: dict[str, tuple[str, int] | None] = {src: None}
+        q = deque([src] if self.devices[src].up else [])
+        while q:
+            u = q.popleft()
+            if u != src and self.devices[u].kind == "c":
+                continue
+            for i, l in enumerate(self.links):
+                if l.touches(u) and self.usable(l):
+                    v = l.other(u)[0]
+                    if v not in prev:
+                        prev[v] = (u, i)
+                        q.append(v)
+        return prev
+
+    @staticmethod
+    def path_in(tree: dict[str, tuple[str, int] | None], dst: str) -> list[tuple[str, int]] | None:
+        if dst not in tree:
+            return None
+        out, node = [], dst
+        while node is not None:
+            p = tree[node]
+            out.append((node, p[1] if p else -1))
+            node = p[0] if p else None
+        return out[::-1]

bytesim/model/layout.py

@@ -0,0 +1,203 @@
+"""Automatic arrangement: rows by device type, groups kept together, nested frames."""
+from __future__ import annotations
+
+from collections import deque
+from typing import Callable
+
+from ..constants import BOX_H, H_GAP, KINDS, LAYER_GAP, RANK
+from .base import NetworkBase
+from .types import Device
+
+
+class LayoutMixin(NetworkBase):
+    def auto_layout(self, width: int) -> None:
+        if not self.devices:
+            return
+        adj: dict[str, set[str]] = {d: set() for d in self.devices}
+        for l in self.links:
+            adj[l.a].add(l.b)
+            adj[l.b].add(l.a)
+
+        # Rows follow device type (gateways on top, computers at the bottom);
+        # chains of the same type (r1-r2, s1-s2) get extra sub-rows by BFS depth.
+        key: dict[str, tuple[int, int]] = {}
+        for kind in KINDS:
+            same = {d.id for d in self.devices.values() if d.kind == kind}
+            roots = sorted((d for d in same
+                            if any(RANK[self.devices[n].kind] < RANK[kind] for n in adj[d])),
+                           key=lambda d: self.devices[d].num)
+            for seed in roots + sorted(same, key=lambda d: self.devices[d].num):
+                if seed in key:
+                    continue
+                key[seed] = (RANK[kind], 0)
+                q = deque([seed])
+                while q:
+                    u = q.popleft()
+                    for v in sorted(adj[u] & same):
+                        if v not in key:
+                            key[v] = (RANK[kind], key[u][1] + 1)
+                            q.append(v)
+        # Devices directly in the same group share a row (the highest any would get).
+        # Subgroups keep their own rows; nesting only keeps members side by side.
+        for ids in self.groups.values():
+            devs = [d for d in ids if d in self.devices]
+            if devs:
+                top = min(key[d] for d in devs)
+                for d in devs:
+                    key[d] = top
+        layer = key
+        chains = {d: self.chain(d) for d in self.devices}
+        pad = {g: 2 * (1 + self.height(g)) for g in self.groups}
+
+        def grouped(ids: list[str], keyf: Callable[[int, str], float], depth: int = 0) -> list[str]:
+            """Sort a row by keyf, keeping every group's members contiguous, at every level."""
+            keys = {d: keyf(i, d) for i, d in enumerate(ids)}
+            units: dict[str, list[str]] = {}
+            for d in ids:
+                c = chains[d]
+                units.setdefault(c[depth] if len(c) > depth else d, []).append(d)
+            ranked = sorted(units.values(), key=lambda ms: sum(keys[m] for m in ms) / len(ms))
+            out: list[str] = []
+            for ms in ranked:
+                if len(chains[ms[0]]) > depth and len(ms) > 1:   # a group: same rule inside it
+                    out += grouped(ms, lambda i, d: keys[d], depth + 1)
+                else:
+                    out += ms
+            return out
+
+        used = sorted(set(layer.values()))
+        layers: list[list[str]] = [[] for _ in used]
+        for dev in self.sorted_devices():
+            layers[used.index(layer[dev.id])].append(dev.id)
+        layers = [grouped(ids, lambda i, d: i) for ids in layers]
+
+        # Barycenter sweeps to reduce crossings.
+        def sweep(order: range, ref_offset: int) -> None:
+            for li in order:
+                ref = {d: i for i, d in enumerate(layers[li + ref_offset])}
+
+                def bary(i: int, d: str) -> float:
+                    pos = [ref[n] for n in adj[d] if n in ref]
+                    return sum(pos) / len(pos) if pos else i
+
+                layers[li] = grouped(layers[li], bary)
+
+        for _ in range(2):
+            sweep(range(1, len(layers)), -1)
+            sweep(range(len(layers) - 2, -1, -1), 1)
+
+        # Pack the widest row, then pull other boxes toward their neighbours.
+        # A group is placed as one block, with extra room for its frame.
+        rows = [[self.devices[d] for d in ids] for ids in layers]
+
+        def blocks(devs: list[Device]) -> list[list[Device]]:
+            """Runs of devices under the same outermost group move as one block."""
+            out: list[list[Device]] = []
+            for d in devs:
+                root = chains[d.id][:1]
+                if out and root and chains[out[-1][0].id][:1] == root:
+                    out[-1].append(d)
+                else:
+                    out.append([d])
+            return out
+
+        def gap1(a: Device, b: Device) -> int:
+            """Room between neighbours for every frame that closes after a or opens before b."""
+            ca, cb = chains[a.id], chains[b.id]
+            k = 0
+            while k < min(len(ca), len(cb)) and ca[k] == cb[k]:
+                k += 1
+            return H_GAP + (pad[ca[k]] if len(ca) > k else 0) + (pad[cb[k]] if len(cb) > k else 0)
+
+        def gap(a: list[Device], b: list[Device]) -> int:
+            return gap1(a[-1], b[0])
+
+        def offsets(blk: list[Device]) -> list[int]:
+            offs, x = [0], 0
+            for a, b in zip(blk, blk[1:]):
+                x += a.width + gap1(a, b)
+                offs.append(x)
+            return offs
+
+        def span(devs: list[Device]) -> int:
+            return sum(d.width for d in devs) + sum(gap1(a, b) for a, b in zip(devs, devs[1:]))
+
+        widest = max(range(len(rows)), key=lambda i: span(rows[i]))
+        for li, devs in enumerate(rows):
+            x = max(2, (width - span(devs)) // 2)
+            prev = None
+            for b in blocks(devs):
+                x += gap(prev, b) if prev else 0
+                for d, off in zip(b, offsets(b)):
+                    d.x, d.y = x + off, 1 + li * (BOX_H + LAYER_GAP)
+                x = b[-1].x + b[-1].width
+                prev = b
+        for _ in range(4):
+            for li in sorted(range(len(rows)), key=lambda i: abs(i - widest)):
+                if li == widest:
+                    continue
+                want = []
+                for d in rows[li]:
+                    # Line our port up with the far end of each cable.
+                    nb = []
+                    for l in self.links:
+                        if l.touches(d.id):
+                            o, op = l.other(d.id)
+                            od = self.devices[o]
+                            if od.y != d.y:
+                                nb.append(od.port_x(op) - (d.port_x(l.port_of(d.id)) - d.x))
+                    want.append(sum(nb) / len(nb) if nb else d.x)
+                wants = dict(zip((d.id for d in rows[li]), want))
+                end, prev = -10**6, None
+                for b in blocks(rows[li]):
+                    offs = offsets(b)
+                    w = sum(wants[d.id] - o for d, o in zip(b, offs)) / len(b)
+                    x = max(round(w), end + gap(prev, b) if prev else -10**6)
+                    for d, o in zip(b, offs):
+                        d.x = x + o
+                    end, prev = b[-1].x + b[-1].width, b
+        self._separate_siblings()
+        margin = 2 + max((2 * self.height(g) for g in self.groups), default=0)
+        shift = margin - min(d.x for d in self.devices.values())
+        if shift > 0:
+            for d in self.devices.values():
+                d.x += shift
+
+    def _separate_siblings(self) -> None:
+        """A group spanning several rows can overlap a sibling on one of them;
+        push the right-hand sibling (and its contents) clear, until nothing overlaps."""
+        def rect(m: str) -> tuple[int, int, int, int]:
+            if m in self.groups:
+                return self.group_bounds(m)
+            d = self.devices[m]
+            return d.x, d.y, d.x + d.width - 1, d.y + BOX_H - 1
+
+        def contents(m: str) -> list[Device]:
+            return [self.devices[d] for d in (self.devices_in(m) if m in self.groups else [m])]
+
+        levels = [[m for m in list(self.devices) + list(self.groups) if self.parent_of(m) is None]]
+        levels += [ms for ms in self.groups.values()]
+        for _ in range(50):
+            moved = False
+            for sibs in levels:
+                rs = sorted(((rect(m), m) for m in sibs), key=lambda t: t[0][0])
+                for i, (ra, a) in enumerate(rs):
+                    for rb, b in rs[i + 1:]:
+                        if ra[0] <= rb[0] <= ra[2] + 1 and ra[1] <= rb[3] and rb[1] <= ra[3]:
+                            for d in contents(b):
+                                d.x += ra[2] + 2 - rb[0]
+                            moved = True
+                            break
+                    if moved:
+                        break
+                if moved:
+                    break
+            if not moved:
+                return
+
+    def place_new(self, dev: Device) -> None:
+        """Drop a new device into free space on its type's row (manual mode)."""
+        y = 1 + RANK[dev.kind] * (BOX_H + LAYER_GAP)
+        right = [o.x + o.width for o in self.devices.values()
+                 if o is not dev and o.y < y + BOX_H + 1 and y < o.y + BOX_H + 1]
+        dev.x, dev.y = (max(right) + H_GAP if right else 2), y