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

unifi_network_maps/model/mock.py

@@ -112,8 +112,12 @@ def _build_clients(
     aps: list[dict[str, Any]],
 ) -> list[dict[str, Any]]:
     clients = []
-    clients.extend(_build_wired_clients(options.wired_client_count, state, core_switch))
-    clients.extend(_build_wireless_clients(options.wireless_client_count, state, aps))
+    wired = _build_wired_clients(options.wired_client_count, state, core_switch, start_index=0)
+    wireless = _build_wireless_clients(
+        options.wireless_client_count, state, aps, start_index=len(wired)
+    )
+    clients.extend(wired)
+    clients.extend(wireless)
     return clients
 
 
@@ -125,39 +129,62 @@ def _build_networks() -> list[dict[str, Any]]:
 
 
 def _build_wired_clients(
-    count: int, state: _MockState, core_switch: dict[str, Any]
+    count: int, state: _MockState, core_switch: dict[str, Any], start_index: int = 0
 ) -> list[dict[str, Any]]:
     clients = []
-    for _ in range(max(0, count)):
+    for i in range(max(0, count)):
         port_idx = _next_core_port(state)
         _add_port(core_switch, port_idx, poe_enabled=False, rng=state.rng)
-        name = _unique_client_name(state)
+        name = _unique_client_name(state, client_index=start_index + i)
+        # Assign VLANs to wired clients based on index
+        vlan_options = [1, 10, 20, 30, 100]
+        client_vlan = vlan_options[port_idx % len(vlan_options)]
         clients.append(
             {
                 "name": name,
                 "is_wired": True,
                 "sw_mac": core_switch["mac"],
                 "sw_port": port_idx,
+                "vlan": client_vlan,
             }
         )
     return clients
 
 
 def _build_wireless_clients(
-    count: int, state: _MockState, aps: list[dict[str, Any]]
+    count: int, state: _MockState, aps: list[dict[str, Any]], start_index: int = 0
 ) -> list[dict[str, Any]]:
     if not aps:
         return []
     clients = []
+    # Wireless VLANs - typically IoT or guest networks
+    wireless_vlans = [10, 20]
+    # Wireless channels (2.4GHz and 5GHz)
+    channels = [1, 6, 11, 36, 44, 149]
     for idx in range(max(0, count)):
         ap = aps[idx % len(aps)]
-        name = _unique_client_name(state)
+        name = _unique_client_name(state, client_index=start_index + idx)
+        client_vlan = wireless_vlans[idx % len(wireless_vlans)]
+        channel = channels[idx % len(channels)]
+        # Generate realistic signal quality metrics
+        signal = state.rng.randint(-80, -40)
+        noise = state.rng.randint(-100, -90)
+        tx_rate = state.rng.choice([72, 144, 288, 433, 866, 1200])
+        rx_rate = state.rng.choice([72, 144, 288, 433, 866, 1200])
+        satisfaction = state.rng.randint(70, 100)
         clients.append(
             {
                 "name": name,
                 "is_wired": False,
                 "ap_mac": ap["mac"],
                 "ap_port": 1,
+                "vlan": client_vlan,
+                "channel": channel,
+                "signal": signal,
+                "noise": noise,
+                "tx_rate": tx_rate,
+                "rx_rate": rx_rate,
+                "satisfaction": satisfaction,
             }
         )
     return clients
@@ -192,7 +219,7 @@ def _pick_version(state: _MockState, dev_type: str) -> str:
 def _link_gateway_to_switch(
     state: _MockState, gateway: dict[str, Any], core_switch: dict[str, Any]
 ) -> None:
-    _add_port(core_switch, 1, poe_enabled=False, rng=state.rng)
+    _add_port(core_switch, 1, poe_enabled=False, rng=state.rng, is_trunk=True)
     _add_lldp_link(
         gateway,
         core_switch,
@@ -259,7 +286,15 @@ def _add_port(
     *,
     poe_enabled: bool,
     rng: random.Random,
+    is_trunk: bool = False,
 ) -> None:
+    # Assign VLAN based on port index for variety
+    vlan_options = [1, 10, 20, 30, 100]
+    native_vlan = vlan_options[port_idx % len(vlan_options)]
+    tagged_vlans: list[int] = []
+    if is_trunk:
+        # Trunk ports carry multiple VLANs
+        tagged_vlans = [v for v in vlan_options if v != native_vlan]
     device["port_table"].append(
         {
             "port_idx": port_idx,
@@ -273,6 +308,8 @@ def _add_port(
             "poe_good": poe_enabled,
             "poe_voltage": round(rng.uniform(44.0, 52.0), 1) if poe_enabled else 0.0,
             "poe_current": round(rng.uniform(0.05, 0.12), 3) if poe_enabled else 0.0,
+            "native_vlan": native_vlan,
+            "tagged_vlans": tagged_vlans,
         }
     )
 
@@ -283,41 +320,91 @@ def _next_core_port(state: _MockState) -> int:
     return port_idx
 
 
-def _unique_name(state: _MockState, prefix: str) -> str:
+def _unique_name(state: _MockState, prefix: str, max_attempts: int = 100) -> str:
     name = prefix
-    while name in state.used_names:
-        name = f"{prefix} {state.rng.randint(2, 9)}"
+    for _ in range(max_attempts):
+        if name not in state.used_names:
+            state.used_names.add(name)
+            return name
+        name = f"{prefix} {state.rng.randint(2, 99)}"
+    # Fallback with random suffix
+    name = f"{prefix}_{state.rng.randint(1000, 9999)}"
     state.used_names.add(name)
     return name
 
 
-def _unique_client_name(state: _MockState) -> str:
-    name = state.fake.first_name()
-    while name in state.used_names:
+# Device name templates for testing device categorization
+# Ordered by category to ensure variety in mock data
+_DEVICE_NAME_TEMPLATES = [
+    "Living Room TV",  # tv
+    "Sonos One",  # speaker
+    "Ring Doorbell",  # camera
+    "HP LaserJet",  # printer
+    "Synology NAS",  # nas
+    "PlayStation 5",  # game_console
+    "iPhone",  # phone
+    "Hue Bridge",  # iot
+    "Samsung Smart TV",  # tv
+    "HomePod Mini",  # speaker
+    "Front Door Camera",  # camera
+    "Brother Printer",  # printer
+    "Xbox Series X",  # game_console
+    "Nest Thermostat",  # iot
+    "Echo Dot",  # speaker
+]
+
+
+def _unique_client_name(state: _MockState, client_index: int = 0, max_attempts: int = 100) -> str:
+    # Use device names for first N clients to ensure variety in mock output
+    # This guarantees different device types appear in smoketests
+    if client_index < len(_DEVICE_NAME_TEMPLATES):
+        name = _DEVICE_NAME_TEMPLATES[client_index]
+        if name not in state.used_names:
+            state.used_names.add(name)
+            return name
+    # Fall back to person names for additional clients
+    for _ in range(max_attempts):
         name = state.fake.first_name()
+        if name not in state.used_names:
+            state.used_names.add(name)
+            return name
+    # Fallback with random suffix
+    name = f"Client_{state.rng.randint(1000, 9999)}"
     state.used_names.add(name)
     return name
 
 
-def _unique_room(state: _MockState) -> str:
-    room = state.fake.word().title()
-    while room in state.used_rooms:
+def _unique_room(state: _MockState, max_attempts: int = 100) -> str:
+    for _ in range(max_attempts):
         room = state.fake.word().title()
+        if room not in state.used_rooms:
+            state.used_rooms.add(room)
+            return room
+    # Fallback with random suffix
+    room = f"Room_{state.rng.randint(1000, 9999)}"
     state.used_rooms.add(room)
     return room
 
 
-def _unique_mac(state: _MockState) -> str:
-    mac = state.fake.mac_address()
-    while mac in state.used_macs:
+def _unique_mac(state: _MockState, max_attempts: int = 1000) -> str:
+    for _ in range(max_attempts):
         mac = state.fake.mac_address()
+        if mac not in state.used_macs:
+            state.used_macs.add(mac)
+            return mac
+    # Fallback - extremely unlikely to reach here
+    mac = f"99:{state.rng.randint(10, 99)}:{state.rng.randint(10, 99)}:{state.rng.randint(10, 99)}:{state.rng.randint(10, 99)}:{state.rng.randint(10, 99)}"
     state.used_macs.add(mac)
     return mac
 
 
-def _unique_ip(state: _MockState) -> str:
-    ip = state.fake.ipv4_private()
-    while ip in state.used_ips:
+def _unique_ip(state: _MockState, max_attempts: int = 1000) -> str:
+    for _ in range(max_attempts):
         ip = state.fake.ipv4_private()
+        if ip not in state.used_ips:
+            state.used_ips.add(ip)
+            return ip
+    # Fallback - extremely unlikely to reach here
+    ip = f"10.{state.rng.randint(0, 255)}.{state.rng.randint(0, 255)}.{state.rng.randint(1, 254)}"
     state.used_ips.add(ip)
     return ip

unifi_network_maps/model/snapshot.py

@@ -0,0 +1,294 @@
+"""Serialization helpers for topology data structures.
+
+Provides to_dict/from_dict conversions for persistence and transmission.
+"""
+
+from __future__ import annotations
+
+from dataclasses import fields, is_dataclass
+from typing import Any, TypeVar
+
+from .connection import ConnectionInfo
+from .lldp import LLDPEntry
+from .topology import Device, Edge, PortInfo, UplinkInfo, WanInfo, WanInterface
+
+T = TypeVar("T")
+
+
+def _serialize_value(value: Any) -> Any:
+    """Recursively serialize a value to JSON-compatible form."""
+    if value is None:
+        return None
+    if isinstance(value, str | int | float | bool):
+        return value
+    if isinstance(value, tuple):
+        return list(_serialize_value(v) for v in value)
+    if isinstance(value, list):
+        return [_serialize_value(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _serialize_value(v) for k, v in value.items()}
+    if is_dataclass(value) and not isinstance(value, type):
+        return _dataclass_to_dict(value)
+    return str(value)
+
+
+def _dataclass_to_dict(obj: Any) -> dict[str, Any]:
+    """Convert a dataclass instance to a dictionary."""
+    result: dict[str, Any] = {}
+    for field in fields(obj):
+        value = getattr(obj, field.name)
+        result[field.name] = _serialize_value(value)
+    return result
+
+
+# --- PortInfo ---
+
+
+def port_info_to_dict(port: PortInfo) -> dict[str, Any]:
+    """Serialize a PortInfo to a dictionary."""
+    return _dataclass_to_dict(port)
+
+
+def port_info_from_dict(data: dict[str, Any]) -> PortInfo:
+    """Deserialize a PortInfo from a dictionary."""
+    return PortInfo(
+        port_idx=data.get("port_idx"),
+        name=data.get("name"),
+        ifname=data.get("ifname"),
+        speed=data.get("speed"),
+        aggregation_group=data.get("aggregation_group"),
+        port_poe=data.get("port_poe", False),
+        poe_enable=data.get("poe_enable", False),
+        poe_good=data.get("poe_good", False),
+        poe_power=data.get("poe_power"),
+        native_vlan=data.get("native_vlan"),
+        tagged_vlans=tuple(data.get("tagged_vlans", [])),
+        wan_networkconf_id=data.get("wan_networkconf_id"),
+    )
+
+
+# --- UplinkInfo ---
+
+
+def uplink_info_to_dict(uplink: UplinkInfo) -> dict[str, Any]:
+    """Serialize an UplinkInfo to a dictionary."""
+    return _dataclass_to_dict(uplink)
+
+
+def uplink_info_from_dict(data: dict[str, Any]) -> UplinkInfo:
+    """Deserialize an UplinkInfo from a dictionary."""
+    return UplinkInfo(
+        mac=data.get("mac"),
+        name=data.get("name"),
+        port=data.get("port"),
+    )
+
+
+# --- LLDPEntry ---
+
+
+def lldp_entry_to_dict(entry: LLDPEntry) -> dict[str, Any]:
+    """Serialize an LLDPEntry to a dictionary."""
+    return _dataclass_to_dict(entry)
+
+
+def lldp_entry_from_dict(data: dict[str, Any]) -> LLDPEntry:
+    """Deserialize an LLDPEntry from a dictionary."""
+    return LLDPEntry(
+        chassis_id=data.get("chassis_id", ""),
+        port_id=data.get("port_id", ""),
+        port_desc=data.get("port_desc"),
+        local_port_name=data.get("local_port_name"),
+        local_port_idx=data.get("local_port_idx"),
+    )
+
+
+# --- WanInterface ---
+
+
+def wan_interface_to_dict(wan: WanInterface) -> dict[str, Any]:
+    """Serialize a WanInterface to a dictionary."""
+    return _dataclass_to_dict(wan)
+
+
+def wan_interface_from_dict(data: dict[str, Any]) -> WanInterface:
+    """Deserialize a WanInterface from a dictionary."""
+    return WanInterface(
+        port_idx=data.get("port_idx", 0),
+        link_speed=data.get("link_speed"),
+        ip_address=data.get("ip_address"),
+        enabled=data.get("enabled", False),
+        label=data.get("label"),
+        isp_speed=data.get("isp_speed"),
+    )
+
+
+# --- WanInfo ---
+
+
+def wan_info_to_dict(wan_info: WanInfo) -> dict[str, Any]:
+    """Serialize a WanInfo to a dictionary."""
+    result: dict[str, Any] = {}
+    if wan_info.wan1:
+        result["wan1"] = wan_interface_to_dict(wan_info.wan1)
+    else:
+        result["wan1"] = None
+    if wan_info.wan2:
+        result["wan2"] = wan_interface_to_dict(wan_info.wan2)
+    else:
+        result["wan2"] = None
+    return result
+
+
+def wan_info_from_dict(data: dict[str, Any]) -> WanInfo:
+    """Deserialize a WanInfo from a dictionary."""
+    wan1 = None
+    wan2 = None
+    if data.get("wan1"):
+        wan1 = wan_interface_from_dict(data["wan1"])
+    if data.get("wan2"):
+        wan2 = wan_interface_from_dict(data["wan2"])
+    return WanInfo(wan1=wan1, wan2=wan2)
+
+
+# --- Device ---
+
+
+def device_to_dict(device: Device) -> dict[str, Any]:
+    """Serialize a Device to a dictionary."""
+    return {
+        "name": device.name,
+        "model_name": device.model_name,
+        "model": device.model,
+        "mac": device.mac,
+        "ip": device.ip,
+        "type": device.type,
+        "lldp_info": [lldp_entry_to_dict(e) for e in device.lldp_info],
+        "port_table": [port_info_to_dict(p) for p in device.port_table],
+        "poe_ports": {str(k): v for k, v in device.poe_ports.items()},
+        "uplink": uplink_info_to_dict(device.uplink) if device.uplink else None,
+        "last_uplink": uplink_info_to_dict(device.last_uplink) if device.last_uplink else None,
+        "version": device.version,
+    }
+
+
+def device_from_dict(data: dict[str, Any]) -> Device:
+    """Deserialize a Device from a dictionary."""
+    lldp_info = [lldp_entry_from_dict(e) for e in data.get("lldp_info", [])]
+    port_table = [port_info_from_dict(p) for p in data.get("port_table", [])]
+    poe_ports = {int(k): v for k, v in data.get("poe_ports", {}).items()}
+    uplink = uplink_info_from_dict(data["uplink"]) if data.get("uplink") else None
+    last_uplink = uplink_info_from_dict(data["last_uplink"]) if data.get("last_uplink") else None
+    return Device(
+        name=data.get("name", ""),
+        model_name=data.get("model_name", ""),
+        model=data.get("model", ""),
+        mac=data.get("mac", ""),
+        ip=data.get("ip", ""),
+        type=data.get("type", ""),
+        lldp_info=lldp_info,
+        port_table=port_table,
+        poe_ports=poe_ports,
+        uplink=uplink,
+        last_uplink=last_uplink,
+        version=data.get("version", ""),
+    )
+
+
+# --- ConnectionInfo ---
+
+
+def connection_info_to_dict(conn: ConnectionInfo) -> dict[str, Any]:
+    """Serialize a ConnectionInfo to a dictionary."""
+    return _dataclass_to_dict(conn)
+
+
+def connection_info_from_dict(data: dict[str, Any]) -> ConnectionInfo:
+    """Deserialize a ConnectionInfo from a dictionary."""
+    return ConnectionInfo(
+        signal_dbm=data.get("signal_dbm"),
+        noise_dbm=data.get("noise_dbm"),
+        tx_rate_mbps=data.get("tx_rate_mbps"),
+        rx_rate_mbps=data.get("rx_rate_mbps"),
+        satisfaction=data.get("satisfaction"),
+        quality=data.get("quality"),
+    )
+
+
+# --- Edge ---
+
+
+def edge_to_dict(edge: Edge) -> dict[str, Any]:
+    """Serialize an Edge to a dictionary."""
+    return {
+        "left": edge.left,
+        "right": edge.right,
+        "label": edge.label,
+        "poe": edge.poe,
+        "wireless": edge.wireless,
+        "speed": edge.speed,
+        "channel": edge.channel,
+        "vlans": list(edge.vlans),
+        "active_vlans": list(edge.active_vlans),
+        "is_trunk": edge.is_trunk,
+        "connection": connection_info_to_dict(edge.connection) if edge.connection else None,
+    }
+
+
+def edge_from_dict(data: dict[str, Any]) -> Edge:
+    """Deserialize an Edge from a dictionary."""
+    connection = None
+    if data.get("connection"):
+        connection = connection_info_from_dict(data["connection"])
+    return Edge(
+        left=data.get("left", ""),
+        right=data.get("right", ""),
+        label=data.get("label"),
+        poe=data.get("poe", False),
+        wireless=data.get("wireless", False),
+        speed=data.get("speed"),
+        channel=data.get("channel"),
+        vlans=tuple(data.get("vlans", [])),
+        active_vlans=tuple(data.get("active_vlans", [])),
+        is_trunk=data.get("is_trunk", False),
+        connection=connection,
+    )
+
+
+# --- Client (dict-based, since clients come from API as dicts) ---
+
+
+def client_to_dict(client: dict[str, Any]) -> dict[str, Any]:
+    """Serialize a client dict, keeping only relevant fields."""
+    relevant_keys = {
+        "mac",
+        "name",
+        "hostname",
+        "ip",
+        "vlan",
+        "vlan_id",
+        "is_wired",
+        "is_unifi",
+        "is_unifi_device",
+        "ap_mac",
+        "sw_mac",
+        "uplink_mac",
+        "uplink_device_mac",
+        "sw_port",
+        "uplink_remote_port",
+        "channel",
+        "signal",
+        "noise",
+        "tx_rate",
+        "rx_rate",
+        "satisfaction",
+        "oui",
+        "vendor",
+        "unifi_device_info_from_ucore",
+    }
+    return {k: v for k, v in client.items() if k in relevant_keys}
+
+
+def client_from_dict(data: dict[str, Any]) -> dict[str, Any]:
+    """Deserialize a client dict (identity for now, but validates structure)."""
+    return dict(data)