unifi-network-maps 1.4.14__py3-none-any.whl → 1.5.0__py3-none-any.whl

unifi_network_maps/render/svg_labels.py

@@ -0,0 +1,184 @@
+"""Text formatting and label utilities for SVG rendering."""
+
+from __future__ import annotations
+
+from ..model.topology import WanInfo, WanInterface
+
+
+def _escape_text(value: str) -> str:
+    return value.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+def _extract_port_text(side: str) -> str | None:
+    candidate = side.split(":", 1)[1].strip() if ":" in side else side.strip()
+    if candidate.lower().startswith("port "):
+        return candidate
+    return None
+
+
+def _extract_device_name(side: str) -> str | None:
+    if ":" not in side:
+        return None
+    name = side.split(":", 1)[0].strip()
+    return name or None
+
+
+def _compact_edge_label(
+    label: str, *, left_node: str | None = None, right_node: str | None = None
+) -> str:
+    if "<->" not in label:
+        return label
+    left_segment, right_segment = (part.strip() for part in label.split("<->", 1))
+    left_name = _extract_device_name(left_segment)
+    right_name = _extract_device_name(right_segment)
+    left_port = _extract_port_text(left_segment)
+    right_port = _extract_port_text(right_segment)
+    if left_node and right_node:
+        if right_name and right_name == left_node and left_name == right_node:
+            left_name, right_name = right_name, left_name
+            left_port, right_port = right_port, left_port
+    if left_port and right_port:
+        if left_name:
+            return f"{left_name} {left_port} <-> {right_port}"
+        return f"{left_port} <-> {right_port}"
+    if left_port:
+        return left_port
+    if right_port:
+        return right_port
+    return label
+
+
+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 _wrap_text(label: str, *, max_len: int = 24) -> list[str]:
+    if len(label) <= max_len:
+        return [label]
+    split_at = label.rfind(" ", 0, max_len + 1)
+    if split_at == -1:
+        split_at = max_len
+    first = label[:split_at].rstrip()
+    rest = label[split_at:].lstrip()
+    return [first, rest] if rest else [first]
+
+
+def _shorten_prefix(name: str, max_words: int = 2) -> str:
+    words = name.split()
+    if len(words) <= max_words:
+        return name
+    return " ".join(words[:max_words]) + "..."
+
+
+def _label_metrics(
+    lines: list[str], *, font_size: int, padding_x: int = 6, padding_y: int = 3
+) -> tuple[float, float]:
+    max_len = max((len(line) for line in lines), default=0)
+    text_width = max_len * font_size * 0.6
+    text_height = len(lines) * (font_size + 2)
+    width = text_width + padding_x * 2
+    height = text_height + padding_y * 2
+    return width, height
+
+
+def _format_wan_speed(speed_mbps: int | None) -> str | None:
+    """Format speed in Mbps to human-readable string (e.g., 10GbE, 100MbE)."""
+    if speed_mbps is None or speed_mbps == 0:
+        return None
+    if speed_mbps >= 1000:
+        gbps = speed_mbps / 1000
+        if gbps == int(gbps):
+            return f"{int(gbps)}GbE"
+        return f"{gbps:.1f}GbE"
+    return f"{speed_mbps}MbE"
+
+
+def _format_wan_interface_line(
+    wan: WanInterface,
+    prefix: str,
+    *,
+    is_dual: bool,
+    include_speed: bool = True,
+) -> str:
+    """Format a single WAN interface line."""
+    status = "●" if wan.enabled else "○"
+    label = wan.label or prefix
+    speed_parts = []
+    if include_speed and wan.link_speed and wan.enabled:
+        speed_parts.append(f"Link {_format_wan_speed(wan.link_speed)}")
+    if wan.isp_speed:
+        speed_parts.append(f"ISP {wan.isp_speed}")
+    speed_str = " / ".join(speed_parts) if speed_parts else ""
+
+    if not wan.enabled and prefix == "WAN2":
+        return f"{prefix}: {label} (disabled) {status}"
+
+    if is_dual:
+        line = f"{prefix}: {label}"
+        if speed_str:
+            line += f" ({speed_str})"
+        return f"{line} {status}"
+
+    return label
+
+
+def _build_wan_label_lines(wan_info: WanInfo) -> list[str]:
+    """Build label lines for WAN display."""
+    label_lines: list[str] = []
+    is_dual = wan_info.wan2 is not None
+
+    if wan_info.wan1:
+        wan1 = wan_info.wan1
+        if is_dual:
+            label_lines.append(
+                _format_wan_interface_line(wan1, "WAN1", is_dual=True, include_speed=True)
+            )
+        else:
+            # Single WAN format: multi-line
+            label_lines.append(wan1.label or "WAN1")
+            speed_parts = []
+            if wan1.link_speed:
+                speed_parts.append(f"Link {_format_wan_speed(wan1.link_speed)}")
+            if wan1.isp_speed:
+                speed_parts.append(f"ISP {wan1.isp_speed}")
+            if speed_parts:
+                label_lines.append(" / ".join(speed_parts))
+            if wan1.ip_address:
+                label_lines.append(wan1.ip_address)
+
+    if wan_info.wan2:
+        label_lines.append(
+            _format_wan_interface_line(wan_info.wan2, "WAN2", is_dual=True, include_speed=True)
+        )
+        # Add IP from WAN1 for dual WAN display
+        if wan_info.wan1 and wan_info.wan1.ip_address:
+            label_lines.append(wan_info.wan1.ip_address)
+
+    return label_lines

unifi_network_maps/render/svg_theme.py

@@ -2,18 +2,103 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 
 @dataclass(frozen=True)
 class SvgTheme:
+    # Links
     link_standard: tuple[str, str]
     link_poe: tuple[str, str]
+
+    # Nodes - infrastructure
     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]
+    node_client_cluster: tuple[str, str] = ("#d4b8ff", "#a080e0")
+
+    # Nodes - extended device types
+    node_camera: tuple[str, str] = ("#b3e5fc", "#64b5f6")  # Light blue
+    node_tv: tuple[str, str] = ("#d1c4e9", "#9575cd")  # Light violet
+    node_phone: tuple[str, str] = ("#c8e6c9", "#81c784")  # Light green
+    node_printer: tuple[str, str] = ("#cfd8dc", "#90a4ae")  # Blue-gray
+    node_nas: tuple[str, str] = ("#ffe0b2", "#ffb74d")  # Amber
+    node_speaker: tuple[str, str] = ("#b2dfdb", "#4db6ac")  # Teal
+    node_game_console: tuple[str, str] = ("#e1bee7", "#ba68c8")  # Light purple
+    node_iot: tuple[str, str] = ("#b2ebf2", "#4dd0e1")  # Cyan
+
+    # Groups
+    group_fill: str = "#f8f9fa"
+    group_stroke: str = "#dee2e6"
+    group_radius: int = 8
+    group_label_fill: str = "#495057"
+    group_stroke_width: int = 2
+
+    # VLANs
+    vlan_colors: dict[int, str] = field(default_factory=dict)
+
+    # Background & text
+    background: str = "#ffffff"
+    text_primary: str = "#1a1a1a"
+    text_secondary: str = "#6b7280"
+
+    # Status indicators
+    status_online: str = "#00a86b"
+    status_offline: str = "#ef4444"
+
+    # WAN globe
+    wan_globe: tuple[str, str] = ("#4fc3f7", "#0288d1")
+    wan_background: str = "#f0f9ff"  # Light blue tint for WAN box
+
+    # PoE indicator
+    poe_fill: str = "#1565c0"  # Dark blue
+    poe_stroke: str = "#ffc107"  # Golden
+
+    # Icon set
+    icon_set: str = "isometric"
+
+    # Font
+    font_family: str | None = None
+
+    # Icon decal color (for modern icons rendered on node surface)
+    icon_decal: str = "#5A6878"
+
+    # Isometric grid
+    grid_color: str = "#efefef"
+
+    # Isometric node side face colors (SW=left, E=right)
+    node_side_left: str = "#dcdcdc"
+    node_side_right: str = "#c8c8c8"
+
+    def group_colors(self, group_name: str) -> tuple[str, str]:
+        """Return (fill, stroke) colors for a group based on its type."""
+        color_map = {
+            "gateway": self.node_gateway,
+            "switch": self.node_switch,
+            "ap": self.node_ap,
+            "client": self.node_client,
+            "client_cluster": self.node_client_cluster,
+            "camera": self.node_camera,
+            "tv": self.node_tv,
+            "phone": self.node_phone,
+            "printer": self.node_printer,
+            "nas": self.node_nas,
+            "speaker": self.node_speaker,
+            "game_console": self.node_game_console,
+            "iot": self.node_iot,
+            "other": self.node_other,
+        }
+        return color_map.get(group_name.lower(), (self.group_fill, self.group_stroke))
+
+    def vlan_color(self, vlan_id: int) -> str:
+        """Return color for a VLAN, using theme color or auto-generated fallback."""
+        if vlan_id in self.vlan_colors:
+            return self.vlan_colors[vlan_id]
+        # Golden angle HSL rotation for distinct, deterministic colors
+        hue = (vlan_id * 137) % 360
+        return f"hsl({hue}, 70%, 55%)"
 
 
 DEFAULT_THEME = SvgTheme(
@@ -27,38 +112,87 @@ DEFAULT_THEME = SvgTheme(
 )
 
 
+def _gradient(grad_id: str, colors: tuple[str, str], *, horizontal: bool = False) -> str:
+    """Build a single linearGradient element."""
+    x2, y2 = ("100%", "0%") if horizontal else ("100%", "100%")
+    return (
+        f'<linearGradient id="{grad_id}" x1="0%" y1="0%" x2="{x2}" y2="{y2}">'
+        f'<stop offset="0%" stop-color="{colors[0]}"/>'
+        f'<stop offset="100%" stop-color="{colors[1]}"/>'
+        "</linearGradient>"
+    )
+
+
 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>"
+    filter_prefix = f"{prefix}-" if prefix else ""
+
+    parts = ["<defs>"]
+
+    # Link gradients (horizontal)
+    parts.append(_gradient(f"{gradient_prefix}link-standard", theme.link_standard, horizontal=True))
+    parts.append(_gradient(f"{gradient_prefix}link-poe", theme.link_poe, horizontal=True))
+
+    # Node gradients (diagonal)
+    node_types: list[tuple[str, tuple[str, str]]] = [
+        ("gateway", theme.node_gateway),
+        ("switch", theme.node_switch),
+        ("ap", theme.node_ap),
+        ("client", theme.node_client),
+        ("client_cluster", theme.node_client_cluster),
+        ("other", theme.node_other),
+        ("camera", theme.node_camera),
+        ("tv", theme.node_tv),
+        ("phone", theme.node_phone),
+        ("printer", theme.node_printer),
+        ("nas", theme.node_nas),
+        ("speaker", theme.node_speaker),
+        ("game_console", theme.node_game_console),
+        ("iot", theme.node_iot),
+    ]
+    for name, colors in node_types:
+        parts.append(_gradient(f"{node_prefix}{name}", colors))
+
+    # Filters
+    parts.append(
+        f'<filter id="{filter_prefix}edge-glow" x="-50%" y="-50%" width="200%" height="200%">'
+        '<feGaussianBlur stdDeviation="4" result="blur"/>'
+        "</filter>"
     )
+    # Emboss filter for icon decals - iOS glass effect
+    parts.append(
+        f'<filter id="{filter_prefix}icon-emboss" x="-50%" y="-50%" width="200%" height="200%">'
+        '<feGaussianBlur in="SourceAlpha" stdDeviation="2.5" result="blur"/>'
+        '<feOffset in="blur" dx="0" dy="2.5" result="dropShadow"/>'
+        '<feFlood flood-color="#000000" flood-opacity="0.4" result="shadowColor"/>'
+        '<feComposite in="shadowColor" in2="dropShadow" operator="in" result="shadow"/>'
+        '<feGaussianBlur in="SourceAlpha" stdDeviation="1.5" result="blurLight"/>'
+        '<feOffset in="blurLight" dx="-2" dy="-1.8" result="lightOffset"/>'
+        '<feFlood flood-color="#ffffff" flood-opacity="0.9" result="lightColor"/>'
+        '<feComposite in="lightColor" in2="lightOffset" operator="in" result="highlight"/>'
+        '<feComposite in="highlight" in2="SourceAlpha" operator="out" result="edgeHighlight"/>'
+        '<feGaussianBlur in="SourceAlpha" stdDeviation="1.5" result="blurDark"/>'
+        '<feOffset in="blurDark" dx="2" dy="1.8" result="darkOffset"/>'
+        '<feFlood flood-color="#000000" flood-opacity="0.6" result="darkColor"/>'
+        '<feComposite in="darkColor" in2="darkOffset" operator="in" result="innerShadow"/>'
+        '<feComposite in="innerShadow" in2="SourceAlpha" operator="out" result="edgeShadow"/>'
+        "<feMerge>"
+        '<feMergeNode in="shadow"/>'
+        '<feMergeNode in="edgeHighlight"/>'
+        '<feMergeNode in="edgeShadow"/>'
+        '<feMergeNode in="SourceGraphic"/>'
+        "</feMerge>"
+        "</filter>"
+    )
+
+    # Globe gradient and PoE bolt symbol
+    parts.append(_gradient(f"{gradient_prefix}globe", theme.wan_globe))
+    parts.append(
+        f'<symbol id="{filter_prefix}poe-bolt" viewBox="0 0 24 24">'
+        '<path fill-rule="evenodd" d="M14.615 1.595a.75.75 0 0 1 .359.852L12.982 9.75h7.268a.75.75 0 0 1 .548 1.262l-10.5 11.25a.75.75 0 0 1-1.272-.71l1.992-7.302H3.75a.75.75 0 0 1-.548-1.262l10.5-11.25a.75.75 0 0 1 .913-.143Z" clip-rule="evenodd"/>'
+        "</symbol>"
+    )
+    parts.append("</defs>")
+
+    return "".join(parts)

unifi_network_maps/render/theme.py

@@ -12,6 +12,18 @@ from .mermaid_theme import MermaidTheme
 from .svg_theme import DEFAULT_THEME as DEFAULT_SVG_THEME
 from .svg_theme import SvgTheme
 
+# Built-in theme names mapped to YAML files in assets/themes/
+BUILTIN_THEMES = {
+    "unifi": "unifi.yaml",
+    "unifi-dark": "unifi-dark.yaml",
+    "minimal": "minimal.yaml",
+    "minimal-dark": "minimal-dark.yaml",
+    "classic": "default.yaml",
+    "classic-dark": "dark.yaml",
+}
+
+_ASSETS_DIR = Path(__file__).parent.parent / "assets" / "themes"
+
 
 def _coerce_pair(value: object, default: tuple[str, str]) -> tuple[str, str]:
     if isinstance(value, list | tuple) and len(value) == 2:
@@ -75,9 +87,39 @@ def _mermaid_theme_from_dict(data: dict, base: MermaidTheme) -> MermaidTheme:
     )
 
 
+def _coerce_vlan_colors(value: object) -> dict[int, str]:
+    """Parse vlan_colors from theme YAML."""
+    if not isinstance(value, dict):
+        return {}
+    result: dict[int, str] = {}
+    for key, color in value.items():
+        if isinstance(color, str):
+            if isinstance(key, int):
+                result[key] = color
+            elif isinstance(key, str) and key.isdigit():
+                result[int(key)] = color
+    return result
+
+
+def _coerce_font_family(value: object, default: str | None) -> str | None:
+    """Parse font_family from theme YAML."""
+    if isinstance(value, str) and value:
+        return value
+    return default
+
+
+def _coerce_icon_set(value: object, default: str) -> str:
+    """Parse icon_set from theme YAML."""
+    if isinstance(value, str) and value in ("isometric", "modern"):
+        return value
+    return default
+
+
 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 {}
+    text = data.get("text", {}) if isinstance(data.get("text"), dict) else {}
+    status = data.get("status", {}) if isinstance(data.get("status"), dict) else {}
 
     return SvgTheme(
         link_standard=_coerce_pair(links.get("standard"), base.link_standard),
@@ -87,6 +129,31 @@ def _svg_theme_from_dict(data: dict, base: SvgTheme) -> SvgTheme:
         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),
+        node_client_cluster=_coerce_pair(nodes.get("client_cluster"), base.node_client_cluster),
+        node_camera=_coerce_pair(nodes.get("camera"), base.node_camera),
+        node_tv=_coerce_pair(nodes.get("tv"), base.node_tv),
+        node_phone=_coerce_pair(nodes.get("phone"), base.node_phone),
+        node_printer=_coerce_pair(nodes.get("printer"), base.node_printer),
+        node_nas=_coerce_pair(nodes.get("nas"), base.node_nas),
+        node_speaker=_coerce_pair(nodes.get("speaker"), base.node_speaker),
+        node_game_console=_coerce_pair(nodes.get("game_console"), base.node_game_console),
+        node_iot=_coerce_pair(nodes.get("iot"), base.node_iot),
+        vlan_colors=_coerce_vlan_colors(data.get("vlan_colors")),
+        background=_coerce_color(data.get("background"), base.background),
+        text_primary=_coerce_color(text.get("primary"), base.text_primary),
+        text_secondary=_coerce_color(text.get("secondary"), base.text_secondary),
+        status_online=_coerce_color(status.get("online"), base.status_online),
+        status_offline=_coerce_color(status.get("offline"), base.status_offline),
+        wan_globe=_coerce_pair(data.get("wan_globe"), base.wan_globe),
+        wan_background=_coerce_color(data.get("wan_background"), base.wan_background),
+        poe_fill=_coerce_color(data.get("poe_fill"), base.poe_fill),
+        poe_stroke=_coerce_color(data.get("poe_stroke"), base.poe_stroke),
+        icon_set=_coerce_icon_set(data.get("icon_set"), base.icon_set),
+        font_family=_coerce_font_family(data.get("font_family"), base.font_family),
+        icon_decal=_coerce_color(data.get("icon_decal"), base.icon_decal),
+        grid_color=_coerce_color(data.get("grid_color"), base.grid_color),
+        node_side_left=_coerce_color(data.get("node_side_left"), base.node_side_left),
+        node_side_right=_coerce_color(data.get("node_side_right"), base.node_side_right),
     )
 
 
@@ -104,7 +171,25 @@ def load_theme(path: str | Path) -> tuple[MermaidTheme, SvgTheme]:
     return mermaid_theme, svg_theme
 
 
-def resolve_themes(theme_file: str | Path | None) -> tuple[MermaidTheme, SvgTheme]:
+def resolve_themes(
+    theme_name: str | None = None,
+    theme_file: str | Path | None = None,
+) -> tuple[MermaidTheme, SvgTheme]:
+    """Resolve theme from name or file path.
+
+    Args:
+        theme_name: Built-in theme name (e.g., "unifi", "classic").
+        theme_file: Custom theme file path. Takes priority over theme_name.
+
+    Returns:
+        Tuple of (MermaidTheme, SvgTheme).
+    """
     if theme_file:
         return load_theme(theme_file)
+    if theme_name:
+        if theme_name not in BUILTIN_THEMES:
+            valid = ", ".join(sorted(BUILTIN_THEMES.keys()))
+            raise ValueError(f"Unknown theme: {theme_name}. Valid themes: {valid}")
+        builtin_path = _ASSETS_DIR / BUILTIN_THEMES[theme_name]
+        return load_theme(builtin_path)
     return DEFAULT_MERMAID_THEME, DEFAULT_SVG_THEME