unifi-network-maps 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

{unifi_mermaid → unifi_network_maps/render}/svg.py

@@ -7,7 +7,8 @@ import math
 from dataclasses import dataclass
 from pathlib import Path
 
-from .topology import Edge
+from ..model.topology import Edge
+from .svg_theme import DEFAULT_THEME, SvgTheme, svg_defs
 
 
 @dataclass(frozen=True)
@@ -23,6 +24,45 @@ class SvgOptions:
     height: int | None = None
 
 
+@dataclass(frozen=True)
+class IsoLayout:
+    iso_angle: float
+    tile_width: float
+    tile_height: float
+    step_width: float
+    step_height: float
+    grid_spacing_x: int
+    grid_spacing_y: int
+    padding: float
+    tile_y_offset: float
+    extra_pad: float
+
+
+def _iso_layout(options: SvgOptions) -> IsoLayout:
+    tile_width = options.node_width * 1.5
+    iso_angle = math.radians(30.0)
+    tile_height = tile_width * math.tan(iso_angle)
+    step_width = tile_width
+    step_height = tile_height
+    grid_spacing_x = max(2, 1 + int(round(options.h_gap / max(tile_width, 1))))
+    grid_spacing_y = max(2, 1 + int(round(options.v_gap / max(tile_height, 1))))
+    padding = float(options.padding)
+    tile_y_offset = tile_height / 2
+    extra_pad = max(12.0, tile_width * 0.35)
+    return IsoLayout(
+        iso_angle=iso_angle,
+        tile_width=tile_width,
+        tile_height=tile_height,
+        step_width=step_width,
+        step_height=step_height,
+        grid_spacing_x=grid_spacing_x,
+        grid_spacing_y=grid_spacing_y,
+        padding=padding,
+        tile_y_offset=tile_y_offset,
+        extra_pad=extra_pad,
+    )
+
+
 _TYPE_ORDER = ["gateway", "switch", "ap", "client", "other"]
 _ICON_FILES = {
     "gateway": "router-network.svg",
@@ -93,6 +133,136 @@ def _compact_edge_label(
     return label
 
 
+def _iso_tile_points(
+    center_x: float, center_y: float, width: float, height: float
+) -> list[tuple[float, float]]:
+    return [
+        (center_x, center_y - height / 2),
+        (center_x + width / 2, center_y),
+        (center_x, center_y + height / 2),
+        (center_x - width / 2, center_y),
+    ]
+
+
+def _points_to_svg(points: list[tuple[float, float]]) -> str:
+    return " ".join(f"{px},{py}" for px, py in points)
+
+
+def _format_port_label_lines(
+    port_label: str,
+    *,
+    node_type: str,
+    prefix: str,
+    max_chars: int,
+) -> list[str]:
+    def _port_only(segment: str) -> str:
+        port = _extract_port_text(segment)
+        if port:
+            return port
+        lower = segment.lower()
+        idx = lower.rfind("port ")
+        if idx != -1:
+            return segment[idx:].strip()
+        return segment.split(":", 1)[-1].strip()
+
+    def _truncate(text: str, max_len: int = max_chars) -> str:
+        return text[: max_len - 3].rstrip() + "..." if len(text) > max_len else text
+
+    if "<->" in port_label:
+        left_part, right_part = (part.strip() for part in port_label.split("<->", 1))
+        front_text = _truncate(f"{prefix}: {_port_only(left_part)}")
+        side_prefix = prefix if node_type == "client" else "local"
+        side_text = _truncate(f"{side_prefix}: {_port_only(right_part)}")
+        return [line for line in (front_text, side_text) if line]
+    side_prefix = prefix if node_type == "client" else "local"
+    side_text = _truncate(f"{side_prefix}: {_port_only(port_label)}")
+    return [side_text]
+
+
+def _iso_front_text_position(
+    top_points: list[tuple[float, float]], tile_width: float, tile_height: float
+) -> tuple[float, float, float]:
+    left_edge_top = top_points[0]
+    left_edge_bottom = top_points[3]
+    edge_mid_x = (left_edge_top[0] + left_edge_bottom[0]) / 2
+    edge_mid_y = (left_edge_top[1] + left_edge_bottom[1]) / 2
+    center_x = sum(px for px, _py in top_points) / len(top_points)
+    center_y = sum(py for _px, py in top_points) / len(top_points)
+    normal_x = center_x - edge_mid_x
+    normal_y = center_y - edge_mid_y
+    normal_len = math.hypot(normal_x, normal_y) or 1.0
+    normal_x /= normal_len
+    normal_y /= normal_len
+    inset = tile_height * 0.27
+    text_x = edge_mid_x + normal_x * inset - tile_width * 0.16
+    text_y = edge_mid_y + normal_y * inset + tile_height * 0.02
+    name_edge_left = top_points[3]
+    name_edge_right = top_points[2]
+    angle = math.degrees(
+        math.atan2(
+            name_edge_right[1] - name_edge_left[1],
+            name_edge_right[0] - name_edge_left[0],
+        )
+    )
+    return text_x, text_y, angle
+
+
+def _render_iso_text(
+    lines: list[str],
+    *,
+    text_x: float,
+    text_y: float,
+    angle: float,
+    text_lines: list[str],
+    font_size: int,
+    fill: str,
+) -> None:
+    line_height = font_size + 2
+    start_y = text_y - (len(text_lines) - 1) * line_height / 2
+    text_transform = (
+        f"translate({text_x} {start_y}) rotate({angle}) skewX(30) translate({-text_x} {-start_y})"
+    )
+    lines.append(
+        f'<text x="{text_x}" y="{start_y}" text-anchor="middle" fill="{fill}" '
+        f'font-size="{font_size}" font-style="normal" '
+        f'transform="{text_transform}">'
+    )
+    for idx, line in enumerate(text_lines):
+        dy = 0 if idx == 0 else line_height
+        lines.append(f'<tspan x="{text_x}" dy="{dy}">{_escape_text(line)}</tspan>')
+    lines.append("</text>")
+
+
+def _iso_name_label_position(
+    top_points: list[tuple[float, float]],
+    *,
+    tile_width: float,
+    tile_height: float,
+    font_size: int,
+) -> tuple[float, float, float]:
+    name_edge_left = top_points[3]
+    name_edge_right = top_points[2]
+    name_mid_x = (name_edge_left[0] + name_edge_right[0]) / 2
+    name_mid_y = (name_edge_left[1] + name_edge_right[1]) / 2
+    name_center_x = sum(px for px, _py in top_points) / len(top_points)
+    name_center_y = sum(py for _px, py in top_points) / len(top_points)
+    name_normal_x = name_center_x - name_mid_x
+    name_normal_y = name_center_y - name_mid_y
+    name_normal_len = math.hypot(name_normal_x, name_normal_y) or 1.0
+    name_normal_x /= name_normal_len
+    name_normal_y /= name_normal_len
+    name_inset = tile_height * 0.13
+    name_x = name_mid_x + name_normal_x * name_inset - tile_width * 0.08
+    name_y = name_mid_y + name_normal_y * name_inset + font_size - tile_height * 0.05
+    name_angle = math.degrees(
+        math.atan2(
+            name_edge_right[1] - name_edge_left[1],
+            name_edge_right[0] - name_edge_left[0],
+        )
+    )
+    return name_x, name_y, name_angle
+
+
 def _wrap_text(label: str, *, max_len: int = 24) -> list[str]:
     if len(label) <= max_len:
         return [label]
@@ -250,6 +420,7 @@ def render_svg(
     *,
     node_types: dict[str, str],
     options: SvgOptions | None = None,
+    theme: SvgTheme = DEFAULT_THEME,
 ) -> str:
     options = options or SvgOptions()
     icons = _load_icons()
@@ -260,42 +431,12 @@ def render_svg(
     lines = [
         f'<svg xmlns="http://www.w3.org/2000/svg" width="{out_width}" height="{out_height}" '
         f'viewBox="0 0 {width} {height}">',
-        "<defs>"
-        '<linearGradient id="link-standard" x1="0%" y1="0%" x2="100%" y2="0%">'
-        '<stop offset="0%" stop-color="#16a085"/>'
-        '<stop offset="100%" stop-color="#2ecc71"/>'
-        "</linearGradient>"
-        '<linearGradient id="link-poe" x1="0%" y1="0%" x2="100%" y2="0%">'
-        '<stop offset="0%" stop-color="#1e88e5"/>'
-        '<stop offset="100%" stop-color="#42a5f5"/>'
-        "</linearGradient>"
-        '<linearGradient id="node-gateway" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#ffd199"/>'
-        '<stop offset="100%" stop-color="#ffb15a"/>'
-        "</linearGradient>"
-        '<linearGradient id="node-switch" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#bfe4ff"/>'
-        '<stop offset="100%" stop-color="#8ac6ff"/>'
-        "</linearGradient>"
-        '<linearGradient id="node-ap" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#c4f2d4"/>'
-        '<stop offset="100%" stop-color="#8ee3b4"/>'
-        "</linearGradient>"
-        '<linearGradient id="node-client" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#e4ccff"/>'
-        '<stop offset="100%" stop-color="#c5a4ff"/>'
-        "</linearGradient>"
-        '<linearGradient id="node-other" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#e3e3e3"/>'
-        '<stop offset="100%" stop-color="#cfcfcf"/>'
-        "</linearGradient>"
-        "</defs>",
+        svg_defs("", theme),
         f"<style>text{{font-family:Arial,Helvetica,sans-serif;font-size:{options.font_size}px;}}</style>",
     ]
 
     node_port_labels: dict[str, str] = {}
     node_port_prefix: dict[str, str] = {}
-    node_port_prefix: dict[str, str] = {}
     for edge in edges:
         if edge.left not in positions or edge.right not in positions:
             continue
@@ -396,19 +537,20 @@ def render_svg_isometric(
     *,
     node_types: dict[str, str],
     options: SvgOptions | None = None,
+    theme: SvgTheme = DEFAULT_THEME,
 ) -> str:
     options = options or SvgOptions()
     icons = _load_isometric_icons()
     positions_index, levels = _tree_layout_indices(edges, node_types)
     if not positions_index:
         positions_index = {}
-    tile_w = options.node_width * 1.5
-    iso_angle = math.radians(30.0)
-    tile_h = tile_w * math.tan(iso_angle)
-    step_w = tile_w
-    step_h = tile_h
-    grid_spacing_x = max(2, 1 + int(round(options.h_gap / max(tile_w, 1))))
-    grid_spacing_y = max(2, 1 + int(round(options.v_gap / max(tile_h, 1))))
+    layout = _iso_layout(options)
+    tile_w = layout.tile_width
+    tile_h = layout.tile_height
+    step_w = layout.step_width
+    step_h = layout.step_height
+    grid_spacing_x = layout.grid_spacing_x
+    grid_spacing_y = layout.grid_spacing_y
 
     grid_positions: dict[str, tuple[float, float]] = {}
     positions: dict[str, tuple[float, float]] = {}
@@ -438,8 +580,8 @@ def render_svg_isometric(
         min_x = min_y = 0.0
         max_x = max_y = 0.0
 
-    padding = options.padding
-    tile_y_offset = tile_h / 2
+    padding = layout.padding
+    tile_y_offset = layout.tile_y_offset
     offset_x = -min_x + padding
     offset_y = -min_y + padding + tile_y_offset
     for name, (x, y) in positions.items():
@@ -457,8 +599,8 @@ def render_svg_isometric(
         cx, cy = grid_center(gx, gy)
         return cx, cy
 
-    width = max_x - min_x + tile_w + padding * 2
-    height = max_y - min_y + tile_h + padding * 2 + tile_y_offset
+    width = max_x - min_x + tile_w + padding * 2 + layout.extra_pad
+    height = max_y - min_y + tile_h + padding * 2 + tile_y_offset + layout.extra_pad
 
     out_width = options.width or int(width)
     out_height = options.height or int(height)
@@ -466,36 +608,7 @@ def render_svg_isometric(
     lines = [
         f'<svg xmlns="http://www.w3.org/2000/svg" width="{out_width}" height="{out_height}" '
         f'viewBox="0 0 {width} {height}">',
-        "<defs>"
-        '<linearGradient id="iso-link-standard" x1="0%" y1="0%" x2="100%" y2="0%">'
-        '<stop offset="0%" stop-color="#16a085"/>'
-        '<stop offset="100%" stop-color="#2ecc71"/>'
-        "</linearGradient>"
-        '<linearGradient id="iso-link-poe" x1="0%" y1="0%" x2="100%" y2="0%">'
-        '<stop offset="0%" stop-color="#1e88e5"/>'
-        '<stop offset="100%" stop-color="#42a5f5"/>'
-        "</linearGradient>"
-        '<linearGradient id="iso-node-gateway" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#ffd199"/>'
-        '<stop offset="100%" stop-color="#ffb15a"/>'
-        "</linearGradient>"
-        '<linearGradient id="iso-node-switch" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#bfe4ff"/>'
-        '<stop offset="100%" stop-color="#8ac6ff"/>'
-        "</linearGradient>"
-        '<linearGradient id="iso-node-ap" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#c4f2d4"/>'
-        '<stop offset="100%" stop-color="#8ee3b4"/>'
-        "</linearGradient>"
-        '<linearGradient id="iso-node-client" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#e4ccff"/>'
-        '<stop offset="100%" stop-color="#c5a4ff"/>'
-        "</linearGradient>"
-        '<linearGradient id="iso-node-other" x1="0%" y1="0%" x2="100%" y2="100%">'
-        '<stop offset="0%" stop-color="#e3e3e3"/>'
-        '<stop offset="100%" stop-color="#cfcfcf"/>'
-        "</linearGradient>"
-        "</defs>",
+        svg_defs("iso", theme),
         f"<style>text{{font-family:Arial,Helvetica,sans-serif;font-size:{options.font_size}px;}}</style>",
     ]
 
@@ -537,15 +650,6 @@ def render_svg_isometric(
     node_port_labels: dict[str, str] = {}
     node_port_prefix: dict[str, str] = {}
 
-    def iso_tile_points(cx: float, cy: float, width: float, height: float) -> str:
-        points = [
-            (cx, cy - height / 2),
-            (cx + width / 2, cy),
-            (cx, cy + height / 2),
-            (cx - width / 2, cy),
-        ]
-        return " ".join(f"{px},{py}" for px, py in points)
-
     for edge in edges:
         if edge.left not in positions or edge.right not in positions:
             continue
@@ -667,14 +771,9 @@ def render_svg_isometric(
             label_center_x = center_x
             stack_depth = tile_h / 2
             label_center_y = y + tile_height / 2 - stack_depth
-            tile_points = iso_tile_points(label_center_x, label_center_y, tile_width, tile_height)
+            top_points = _iso_tile_points(label_center_x, label_center_y, tile_width, tile_height)
+            tile_points = _points_to_svg(top_points)
             # Stack a shallow side to suggest elevation.
-            top_points = [
-                (label_center_x, label_center_y - tile_height / 2),
-                (label_center_x + tile_width / 2, label_center_y),
-                (label_center_x, label_center_y + tile_height / 2),
-                (label_center_x - tile_width / 2, label_center_y),
-            ]
             bottom_points = [(px, py + stack_depth) for px, py in top_points]
             # Right face uses points 1->2 and their offset counterparts.
             right_face = [
@@ -707,18 +806,6 @@ def render_svg_isometric(
             icon_center_x = label_center_x
             icon_center_y = label_center_y
             if port_label:
-
-                def _port_only(segment: str) -> str:
-                    port = _extract_port_text(segment)
-                    if port:
-                        return port
-                    lower = segment.lower()
-                    idx = lower.rfind("port ")
-                    if idx != -1:
-                        return segment[idx:].strip()
-                    return segment.split(":", 1)[-1].strip()
-
-                # Place port text along the front edge of the top tile.
                 left_edge_top = top[0]
                 left_edge_bottom = top[3]
                 edge_len = math.hypot(
@@ -726,66 +813,26 @@ def render_svg_isometric(
                     left_edge_bottom[1] - left_edge_top[1],
                 )
                 max_chars = max(6, int((edge_len * 0.85) / (font_size * 0.6)))
-
-                def _truncate(text: str, max_len: int = max_chars) -> str:
-                    return text[: max_len - 3].rstrip() + "..." if len(text) > max_len else text
-
                 prefix = node_port_prefix.get(name, "switch")
-                if "<->" in port_label:
-                    left_part, right_part = (part.strip() for part in port_label.split("<->", 1))
-                    front_text = _truncate(f"{prefix}: {_port_only(left_part)}")
-                    side_prefix = prefix if node_type == "client" else "local"
-                    side_text = _truncate(f"{side_prefix}: {_port_only(right_part)}")
-                else:
-                    front_text = ""
-                    side_prefix = prefix if node_type == "client" else "local"
-                    side_text = _truncate(f"{side_prefix}: {_port_only(port_label)}")
-
-                edge_mid_x = (left_edge_top[0] + left_edge_bottom[0]) / 2
-                edge_mid_y = (left_edge_top[1] + left_edge_bottom[1]) / 2
-                center_x = sum(px for px, _py in top) / len(top)
-                center_y = sum(py for _px, py in top) / len(top)
-                normal_x = center_x - edge_mid_x
-                normal_y = center_y - edge_mid_y
-                normal_len = math.hypot(normal_x, normal_y) or 1.0
-                normal_x /= normal_len
-                normal_y /= normal_len
-                inset = tile_h * 0.27
-                text_x = edge_mid_x + normal_x * inset - tile_w * 0.16
-                text_y = edge_mid_y + normal_y * inset + tile_h * 0.02
-                edge_angle = math.degrees(
-                    math.atan2(
-                        left_edge_bottom[1] - left_edge_top[1],
-                        left_edge_bottom[0] - left_edge_top[0],
-                    )
+                front_lines = _format_port_label_lines(
+                    port_label,
+                    node_type=node_type,
+                    prefix=prefix,
+                    max_chars=max_chars,
                 )
-                name_edge_left = top[3]
-                name_edge_right = top[2]
-                name_angle = math.degrees(
-                    math.atan2(
-                        name_edge_right[1] - name_edge_left[1],
-                        name_edge_right[0] - name_edge_left[0],
-                    )
-                )
-                edge_angle = name_angle
-
-                front_lines = [line for line in (front_text, side_text) if line]
                 if front_lines:
-                    line_height = font_size + 2
-                    start_y = text_y - (len(front_lines) - 1) * line_height / 2
-                    text_transform = (
-                        f"translate({text_x} {start_y}) rotate({edge_angle}) skewX(30) "
-                        f"translate({-text_x} {-start_y})"
+                    text_x, text_y, edge_angle = _iso_front_text_position(
+                        top_points, tile_w, tile_h
                     )
-                    lines.append(
-                        f'<text x="{text_x}" y="{start_y}" text-anchor="middle" fill="#555" '
-                        f'font-size="{font_size}" font-style="normal" '
-                        f'transform="{text_transform}">'
+                    _render_iso_text(
+                        lines,
+                        text_x=text_x,
+                        text_y=text_y,
+                        angle=edge_angle,
+                        text_lines=front_lines,
+                        font_size=font_size,
+                        fill="#555",
                     )
-                    for idx, line in enumerate(front_lines):
-                        dy = 0 if idx == 0 else line_height
-                        lines.append(f'<tspan x="{text_x}" dy="{dy}">{_escape_text(line)}</tspan>')
-                    lines.append("</text>")
 
         if node_type == "ap":
             icon_center_y -= tile_h * 0.4
@@ -802,25 +849,11 @@ def render_svg_isometric(
             )
 
         name_font_size = max(options.font_size - 2, 8)
-        name_edge_left = top[3]
-        name_edge_right = top[2]
-        name_mid_x = (name_edge_left[0] + name_edge_right[0]) / 2
-        name_mid_y = (name_edge_left[1] + name_edge_right[1]) / 2
-        name_center_x = sum(px for px, _py in top) / len(top)
-        name_center_y = sum(py for _px, py in top) / len(top)
-        name_normal_x = name_center_x - name_mid_x
-        name_normal_y = name_center_y - name_mid_y
-        name_normal_len = math.hypot(name_normal_x, name_normal_y) or 1.0
-        name_normal_x /= name_normal_len
-        name_normal_y /= name_normal_len
-        name_inset = tile_h * 0.13
-        name_x = name_mid_x + name_normal_x * name_inset - tile_w * 0.08
-        name_y = name_mid_y + name_normal_y * name_inset + name_font_size - tile_h * 0.05
-        name_angle = math.degrees(
-            math.atan2(
-                name_edge_right[1] - name_edge_left[1],
-                name_edge_right[0] - name_edge_left[0],
-            )
+        name_x, name_y, name_angle = _iso_name_label_position(
+            top,
+            tile_width=tile_w,
+            tile_height=tile_h,
+            font_size=name_font_size,
         )
         name_transform = (
             f"translate({name_x} {name_y}) rotate({name_angle}) skewX(30) "

unifi_network_maps/render/svg_theme.py

@@ -0,0 +1,64 @@
+"""Shared SVG defs and theming."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SvgTheme:
+    link_standard: tuple[str, str]
+    link_poe: tuple[str, str]
+    node_gateway: tuple[str, str]
+    node_switch: tuple[str, str]
+    node_ap: tuple[str, str]
+    node_client: tuple[str, str]
+    node_other: tuple[str, str]
+
+
+DEFAULT_THEME = SvgTheme(
+    link_standard=("#16a085", "#2ecc71"),
+    link_poe=("#1e88e5", "#42a5f5"),
+    node_gateway=("#ffd199", "#ffb15a"),
+    node_switch=("#bfe4ff", "#8ac6ff"),
+    node_ap=("#c4f2d4", "#8ee3b4"),
+    node_client=("#e4ccff", "#c5a4ff"),
+    node_other=("#e3e3e3", "#cfcfcf"),
+)
+
+
+def svg_defs(prefix: str, theme: SvgTheme = DEFAULT_THEME) -> str:
+    gradient_prefix = f"{prefix}-" if prefix else ""
+    node_prefix = f"{prefix}-node-" if prefix else "node-"
+    return (
+        "<defs>"
+        f'<linearGradient id="{gradient_prefix}link-standard" x1="0%" y1="0%" x2="100%" y2="0%">'
+        f'<stop offset="0%" stop-color="{theme.link_standard[0]}"/>'
+        f'<stop offset="100%" stop-color="{theme.link_standard[1]}"/>'
+        "</linearGradient>"
+        f'<linearGradient id="{gradient_prefix}link-poe" x1="0%" y1="0%" x2="100%" y2="0%">'
+        f'<stop offset="0%" stop-color="{theme.link_poe[0]}"/>'
+        f'<stop offset="100%" stop-color="{theme.link_poe[1]}"/>'
+        "</linearGradient>"
+        f'<linearGradient id="{node_prefix}gateway" x1="0%" y1="0%" x2="100%" y2="100%">'
+        f'<stop offset="0%" stop-color="{theme.node_gateway[0]}"/>'
+        f'<stop offset="100%" stop-color="{theme.node_gateway[1]}"/>'
+        "</linearGradient>"
+        f'<linearGradient id="{node_prefix}switch" x1="0%" y1="0%" x2="100%" y2="100%">'
+        f'<stop offset="0%" stop-color="{theme.node_switch[0]}"/>'
+        f'<stop offset="100%" stop-color="{theme.node_switch[1]}"/>'
+        "</linearGradient>"
+        f'<linearGradient id="{node_prefix}ap" x1="0%" y1="0%" x2="100%" y2="100%">'
+        f'<stop offset="0%" stop-color="{theme.node_ap[0]}"/>'
+        f'<stop offset="100%" stop-color="{theme.node_ap[1]}"/>'
+        "</linearGradient>"
+        f'<linearGradient id="{node_prefix}client" x1="0%" y1="0%" x2="100%" y2="100%">'
+        f'<stop offset="0%" stop-color="{theme.node_client[0]}"/>'
+        f'<stop offset="100%" stop-color="{theme.node_client[1]}"/>'
+        "</linearGradient>"
+        f'<linearGradient id="{node_prefix}other" x1="0%" y1="0%" x2="100%" y2="100%">'
+        f'<stop offset="0%" stop-color="{theme.node_other[0]}"/>'
+        f'<stop offset="100%" stop-color="{theme.node_other[1]}"/>'
+        "</linearGradient>"
+        "</defs>"
+    )

unifi_network_maps/render/theme.py

@@ -0,0 +1,90 @@
+"""Theme loading for Mermaid and SVG rendering."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+from .mermaid_theme import DEFAULT_THEME as DEFAULT_MERMAID_THEME
+from .mermaid_theme import MermaidTheme
+from .svg_theme import DEFAULT_THEME as DEFAULT_SVG_THEME
+from .svg_theme import SvgTheme
+
+
+def _coerce_pair(value: object, default: tuple[str, str]) -> tuple[str, str]:
+    if isinstance(value, list | tuple) and len(value) == 2:
+        left, right = value
+        if isinstance(left, str) and isinstance(right, str):
+            return (left, right)
+    if isinstance(value, dict):
+        left = value.get("from") or value.get("start")
+        right = value.get("to") or value.get("end")
+        if isinstance(left, str) and isinstance(right, str):
+            return (left, right)
+    return default
+
+
+def _coerce_color(value: object, default: str) -> str:
+    return value if isinstance(value, str) else default
+
+
+def _mermaid_theme_from_dict(data: dict, base: MermaidTheme) -> MermaidTheme:
+    nodes = data.get("nodes", {}) if isinstance(data.get("nodes"), dict) else {}
+
+    def _node(name: str) -> tuple[str, str]:
+        return (
+            _coerce_color(nodes.get(name, {}).get("fill"), getattr(base, f"node_{name}")[0]),
+            _coerce_color(nodes.get(name, {}).get("stroke"), getattr(base, f"node_{name}")[1]),
+        )
+
+    return MermaidTheme(
+        node_gateway=_node("gateway"),
+        node_switch=_node("switch"),
+        node_ap=_node("ap"),
+        node_client=_node("client"),
+        node_other=_node("other"),
+        poe_link=_coerce_color(data.get("poe_link"), base.poe_link),
+        poe_link_width=int(data.get("poe_link_width", base.poe_link_width)),
+        poe_link_arrow=_coerce_color(data.get("poe_link_arrow"), base.poe_link_arrow),
+        standard_link=_coerce_color(data.get("standard_link"), base.standard_link),
+        standard_link_width=int(data.get("standard_link_width", base.standard_link_width)),
+        standard_link_arrow=_coerce_color(
+            data.get("standard_link_arrow"), base.standard_link_arrow
+        ),
+    )
+
+
+def _svg_theme_from_dict(data: dict, base: SvgTheme) -> SvgTheme:
+    nodes = data.get("nodes", {}) if isinstance(data.get("nodes"), dict) else {}
+    links = data.get("links", {}) if isinstance(data.get("links"), dict) else {}
+
+    return SvgTheme(
+        link_standard=_coerce_pair(links.get("standard"), base.link_standard),
+        link_poe=_coerce_pair(links.get("poe"), base.link_poe),
+        node_gateway=_coerce_pair(nodes.get("gateway"), base.node_gateway),
+        node_switch=_coerce_pair(nodes.get("switch"), base.node_switch),
+        node_ap=_coerce_pair(nodes.get("ap"), base.node_ap),
+        node_client=_coerce_pair(nodes.get("client"), base.node_client),
+        node_other=_coerce_pair(nodes.get("other"), base.node_other),
+    )
+
+
+def load_theme(path: str | Path) -> tuple[MermaidTheme, SvgTheme]:
+    theme_path = Path(path)
+    payload = yaml.safe_load(theme_path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("Theme file must contain a YAML mapping")
+
+    mermaid_data = payload.get("mermaid", {})
+    svg_data = payload.get("svg", {})
+
+    mermaid_theme = _mermaid_theme_from_dict(mermaid_data, DEFAULT_MERMAID_THEME)
+    svg_theme = _svg_theme_from_dict(svg_data, DEFAULT_SVG_THEME)
+    return mermaid_theme, svg_theme
+
+
+def resolve_themes(theme_file: str | Path | None) -> tuple[MermaidTheme, SvgTheme]:
+    if theme_file:
+        return load_theme(theme_file)
+    return DEFAULT_MERMAID_THEME, DEFAULT_SVG_THEME