topolib 0.8.0__py3-none-any.whl

topolib/topology/topology.py

@@ -0,0 +1,469 @@
+"""
+Topology class for optical network topologies.
+
+This module defines the Topology class, representing a network topology with nodes and links,
+and providing an adjacency matrix using numpy.
+
+This file uses NetworkX (BSD 3-Clause License):
+https://github.com/networkx/networkx/blob/main/LICENSE.txt
+"""
+
+from typing import List, Optional, Any
+from numpy.typing import NDArray
+
+
+# Standard library imports
+import json
+import csv
+from pathlib import Path
+
+# Third-party imports
+import numpy as np
+import networkx as nx
+import jsonschema
+
+# Local imports
+from topolib.elements.node import Node
+from topolib.elements.link import Link
+
+
+class Topology:
+    """
+    Represents a network topology with nodes and links.
+
+    :param nodes: Initial list of nodes (optional).
+    :type nodes: list[topolib.elements.node.Node] or None
+    :param links: Initial list of links (optional).
+    :type links: list[topolib.elements.link.Link] or None
+
+    :ivar nodes: List of nodes in the topology.
+    :vartype nodes: list[Node]
+    :ivar links: List of links in the topology.
+    :vartype links: list[Link]
+
+    **Examples**
+        >>> from topolib.elements.node import Node
+        >>> from topolib.elements.link import Link
+        >>> from topolib.topology import Topology
+        >>> n1 = Node(1, "A", 0.0, 0.0)
+        >>> n2 = Node(2, "B", 1.0, 1.0)
+        >>> l1 = Link(1, n1, n2, 10.0)
+        >>> topo = Topology(nodes=[n1, n2], links=[l1])
+        >>> topo.adjacency_matrix()
+        array([[0, 1],
+               [1, 0]])
+    """
+
+    def __init__(
+        self,
+        nodes: Optional[List[Node]] = None,
+        links: Optional[List[Link]] = None,
+        name: Optional[str] = None,
+    ):
+        """
+        Initialize a Topology object.
+
+        :param nodes: Initial list of nodes (optional).
+        :type nodes: list[topolib.elements.node.Node] or None
+        :param links: Initial list of links (optional).
+        :type links: list[topolib.elements.link.Link] or None
+        :param name: Name of the topology (optional).
+        :type name: str or None
+        """
+        self.nodes = nodes if nodes is not None else []
+        self.links = links if links is not None else []
+        self.name = name
+        # Internal NetworkX graph for algorithms and visualization
+        self._graph: nx.DiGraph[Any] = nx.DiGraph()
+        for node in self.nodes:
+            self._graph.add_node(node.id, node=node)
+        for link in self.links:
+            self._graph.add_edge(link.source.id, link.target.id, link=link)
+
+    @classmethod
+    def from_json(cls, json_path: str) -> "Topology":
+        """
+        Create a Topology object from a JSON file.
+
+        :param json_path: Path to the JSON file containing the topology.
+        :type json_path: str
+        :return: Topology instance loaded from the file.
+        :rtype: Topology
+        """
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        # Validation schema for the assets JSON format
+        topology_schema: dict[str, Any] = {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "nodes": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "integer"},
+                            "name": {"type": "string"},
+                            "weight": {"type": "number"},
+                            "latitude": {"type": "number"},
+                            "longitude": {"type": "number"},
+                            "pop": {"type": "integer"},
+                            "DC": {"type": "integer"},
+                            "IXP": {"type": "integer"},
+                        },
+                        "required": ["id", "name", "latitude", "longitude"],
+                    },
+                },
+                "links": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "integer"},
+                            "src": {"type": "integer"},
+                            "dst": {"type": "integer"},
+                            "length": {"type": "number"},
+                        },
+                        "required": ["id", "src", "dst", "length"],
+                    },
+                },
+            },
+            "required": ["nodes", "links"],
+        }
+        try:
+            jsonschema.validate(instance=data, schema=topology_schema)
+        except jsonschema.ValidationError as e:
+            raise ValueError(f"Invalid topology JSON format: {e.message}")
+        nodes = [
+            Node(
+                n["id"],
+                n["name"],
+                n["latitude"],
+                n["longitude"],
+                n.get("weight", 0),
+                n.get("pop", 0),
+                n.get("dc", n.get("DC", 0)),
+                n.get("ixp", n.get("IXP", 0)),
+            )
+            for n in data["nodes"]
+        ]
+        # Crear un dict para mapear id a Node
+        node_dict = {n.id: n for n in nodes}
+        links = [
+            Link(l["id"], node_dict[l["src"]],
+                 node_dict[l["dst"]], l["length"])
+            for l in data["links"]
+        ]
+        name = data.get("name", None)
+        return cls(nodes=nodes, links=links, name=name)
+
+    def add_node(self, node: Node) -> None:
+        """
+        Add a node to the topology.
+
+        :param node: Node to add.
+        :type node: Node
+        """
+        self.nodes.append(node)
+        self._graph.add_node(node.id, node=node)
+
+    def add_link(self, link: Link) -> None:
+        """
+        Add a link to the topology.
+
+        :param link: Link to add.
+        :type link: Link
+        """
+        self.links.append(link)
+        self._graph.add_edge(link.source.id, link.target.id, link=link)
+
+    def remove_node(self, node_id: int) -> None:
+        """
+        Remove a node and all its links by node id.
+
+        :param node_id: ID of the node to remove.
+        :type node_id: int
+        """
+        self.nodes = [n for n in self.nodes if n.id != node_id]
+        self.links = [
+            l for l in self.links if l.source.id != node_id and l.target.id != node_id
+        ]
+        self._graph.remove_node(node_id)
+
+    def remove_link(self, link_id: int) -> None:
+        """
+        Remove a link by its id.
+
+        :param link_id: ID of the link to remove.
+        :type link_id: int
+        """
+        # Find the link and remove from graph
+        link = next((l for l in self.links if l.id == link_id), None)
+        if link:
+            self._graph.remove_edge(link.source.id, link.target.id)
+        self.links = [l for l in self.links if l.id != link_id]
+
+    def adjacency_matrix(self) -> NDArray[np.int_]:
+        """
+        Return the adjacency matrix of the topology as a numpy array.
+
+        :return: Adjacency matrix (1 if connected, 0 otherwise).
+        :rtype: numpy.ndarray
+
+        **Example**
+            >>> topo.adjacency_matrix()
+            array([[0, 1],
+                   [1, 0]])
+        """
+        # Usa NetworkX para obtener la matriz de adyacencia
+        if not self.nodes:
+            return np.zeros((0, 0), dtype=int)
+        node_ids = [n.id for n in self.nodes]
+        mat = nx.to_numpy_array(self._graph, nodelist=node_ids, dtype=int)
+        return mat
+
+    def export_to_json(self, file_path: str) -> None:
+        """
+        Export the current topology to the JSON format used in the assets folder.
+
+        :param file_path: Path where the JSON file will be saved.
+        :type file_path: str
+
+        Example usage::
+
+            topo.export_to_json("/path/output.json")
+
+        Example output format::
+
+            {
+                "name": "Abilene",
+                "nodes": [
+                    {
+                        "id": 0,
+                        "name": "Seattle",
+                        ...
+                    }
+                ],
+                "links": [
+                    {
+                        "id": 0,
+                        "src": 0,
+                        "dst": 1,
+                        "length": 1482.26
+                    }
+                ]
+            }
+        """
+        nodes_list: list[dict[str, Any]] = []
+        for n in self.nodes:
+            node_dict: dict[str, Any] = {
+                "id": n.id,
+                "name": getattr(n, "name", None),
+                "weight": getattr(n, "weight", 0),
+                "latitude": getattr(n, "latitude", None),
+                "longitude": getattr(n, "longitude", None),
+                "pop": getattr(n, "pop", 0),
+                "DC": getattr(n, "dc", getattr(n, "DC", 0)),
+                "IXP": getattr(n, "ixp", getattr(n, "IXP", 0)),
+            }
+            nodes_list.append(node_dict)
+        links_list: list[dict[str, Any]] = []
+        for l in self.links:
+            link_dict: dict[str, Any] = {
+                "id": l.id,
+                "src": l.source.id,
+                "dst": l.target.id,
+                "length": getattr(l, "length", None),
+            }
+            links_list.append(link_dict)
+        data: dict[str, Any] = {
+            "name": self.name if self.name else "Topology",
+            "nodes": nodes_list,
+            "links": links_list,
+        }
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+
+    def export_to_csv(self, filename_prefix: str) -> None:
+        """
+        Export the topology to two CSV files: one for nodes and one for links.
+        The files will be named as <filename_prefix>_nodes.csv and <filename_prefix>_links.csv.
+
+        :param filename_prefix: Prefix for the output files (e.g., 'topology1').
+        :type filename_prefix: str
+
+        Example:
+            >>> topo.export_to_csv("mytopo")
+            # Generates 'mytopo_nodes.csv' and 'mytopo_links.csv'
+        """
+        # Export nodes
+        nodes_path = f"{filename_prefix}_nodes.csv"
+        with open(nodes_path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            # Header
+            writer.writerow(
+                ["id", "name", "weight", "latitude",
+                    "longitude", "pop", "DC", "IXP"]
+            )
+            for n in self.nodes:
+                writer.writerow(
+                    [
+                        n.id,
+                        getattr(n, "name", None),
+                        getattr(n, "weight", 0),
+                        getattr(n, "latitude", None),
+                        getattr(n, "longitude", None),
+                        getattr(n, "pop", 0),
+                        getattr(n, "dc", getattr(n, "DC", 0)),
+                        getattr(n, "ixp", getattr(n, "IXP", 0)),
+                    ]
+                )
+        # Export links
+        links_path = f"{filename_prefix}_links.csv"
+        with open(links_path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            writer.writerow(["id", "src", "dst", "length"])
+            for l in self.links:
+                writer.writerow(
+                    [
+                        l.id,
+                        l.source.id,
+                        l.target.id,
+                        getattr(l, "length", None),
+                    ]
+                )
+
+    def export_to_flexnetsim_json(self, file_path: str, slots: int) -> None:
+        """
+        Export the current topology to a JSON file compatible with Flex Net Sim.
+
+        :param file_path: Path where the JSON file will be saved.
+        :type file_path: str
+        :param slots: Number of slots for each link.
+        :type slots: int
+
+        The generated format includes the following fields:
+        - alias: short name of the topology (uses self.name if available)
+        - name: full name of the topology (uses self.name if available)
+        - nodes: list of nodes with 'id' field
+        - links: list of links with id, src, dst, length, slots
+        """
+        alias = self.name if self.name else "Topology"
+        name = self.name if self.name else "Topology"
+        nodes_list = [{"id": n.id} for n in self.nodes]
+        links_list = []
+        for l in self.links:
+            link_dict = {
+                "id": l.id,
+                "src": l.source.id,
+                "dst": l.target.id,
+                "length": getattr(l, "length", None),
+                "slots": slots,
+            }
+            links_list.append(link_dict)
+        data = {
+            "alias": alias,
+            "name": name,
+            "nodes": nodes_list,
+            "links": links_list,
+        }
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+
+    def export_to_flexnetsim_ksp_json(self, file_path: str, k: int = 3) -> None:
+        """
+        Export the k-shortest paths between all node pairs to a JSON file compatible with Flex Net Sim.
+
+        :param file_path: Path where the JSON file will be saved.
+        :type file_path: str
+        :param k: Number of shortest paths to compute for each node pair (default: 3).
+        :type k: int
+
+        Example output format::
+
+            {
+                "name": self.name,
+                "alias": self.name,
+                "routes": [
+                    {"src": <id>, "dst": <id>, "paths": [[id, ...], ...]},
+                    ...
+                ]
+            }
+        """
+
+        # Build a weighted graph using link length as edge weight
+        G = nx.DiGraph()
+        for l in self.links:
+            G.add_edge(l.source.id, l.target.id,
+                       weight=getattr(l, "length", 1))
+        routes = []
+        node_ids = [n.id for n in self.nodes]
+        for src in node_ids:
+            for dst in node_ids:
+                if src == dst:
+                    continue
+                try:
+                    # Compute k shortest paths using link length as weight
+                    paths_gen = nx.shortest_simple_paths(
+                        G, src, dst, weight="weight")
+                    paths = []
+                    for i, path in enumerate(paths_gen):
+                        if i >= k:
+                            break
+                        paths.append(path)
+                except (nx.NetworkXNoPath, nx.NodeNotFound):
+                    paths = []
+                routes.append({"src": src, "dst": dst, "paths": paths})
+        data = {
+            "name": self.name if self.name else "Topology",
+            "alias": self.name if self.name else "Topology",
+            "routes": routes,
+        }
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+
+    @classmethod
+    def list_available_topologies(cls) -> list[dict]:
+        """
+        List available topologies in the assets folder.
+
+        Returns a list of dictionaries with keys:
+        - 'name': topology name (filename without extension)
+        - 'nodes': number of nodes
+        - 'links': number of links
+
+        :return: List of available topologies with metadata.
+        :rtype: list[dict]
+        """
+        asset_dir = Path(__file__).parent.parent / "assets"
+        result = []
+        for json_path in asset_dir.glob("*.json"):
+            try:
+                topo = cls.from_json(str(json_path))
+                result.append({
+                    "name": json_path.stem,
+                    "nodes": len(topo.nodes),
+                    "links": len(topo.links),
+                })
+            except Exception:
+                continue
+        return result
+
+    @staticmethod
+    def load_default_topology(name: str) -> "Topology":
+        """
+        Load a default topology from the assets folder by name (filename without extension).
+
+        :param name: Name of the topology asset (without .json extension)
+        :type name: str
+        :return: Topology instance loaded from the asset file
+        :rtype: Topology
+        :raises FileNotFoundError: If the asset file does not exist
+        """
+        asset_dir = Path(__file__).parent.parent / "assets"
+        asset_path = asset_dir / f"{name}.json"
+        if not asset_path.exists():
+            raise FileNotFoundError(
+                f"Topology asset '{name}.json' not found in assets directory.")
+        return Topology.from_json(str(asset_path))

topolib/visualization/__init__.py

@@ -0,0 +1 @@
+from .mapview import MapView

topolib/visualization/_qt_screenshot.py

@@ -0,0 +1,103 @@
+"""
+Qt screenshot script for capturing maps as PNG images.
+
+This module provides a standalone script that can be executed in a subprocess
+to render HTML content and capture it as a PNG screenshot.
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Suppress Qt warnings
+os.environ['QT_LOGGING_RULES'] = '*.debug=false;qt.webenginecontext.debug=false;qt.qpa.windows=false'
+os.environ['QTWEBENGINE_CHROMIUM_FLAGS'] = '--disable-logging --log-level=3'
+
+try:
+    from PyQt6.QtWidgets import QApplication
+    from PyQt6.QtWebEngineWidgets import QWebEngineView
+    from PyQt6.QtCore import QUrl, QTimer, QEventLoop, Qt
+    from PyQt6.QtWebEngineCore import QWebEngineSettings
+    from PyQt6.QtGui import QPixmap
+except ImportError:
+    print("ERROR: PyQt6 not installed. Install with: pip install PyQt6 PyQt6-WebEngine")
+    sys.exit(1)
+
+
+def capture_screenshot(html_path: str, output_path: str, width: int = 1920, height: int = 1080, wait_time: float = 1.0) -> None:
+    """Capture a screenshot of an HTML file.
+    
+    :param html_path: Absolute path to the HTML file to render.
+    :type html_path: str
+    :param output_path: Path where the PNG screenshot will be saved.
+    :type output_path: str
+    :param width: Width of the screenshot in pixels.
+    :type width: int
+    :param height: Height of the screenshot in pixels.
+    :type height: int
+    :param wait_time: Time in seconds to wait for rendering before capture.
+    :type wait_time: float
+    """
+    app = QApplication(sys.argv)
+    
+    # Create web view offscreen (no window displayed)
+    web_view = QWebEngineView()
+    web_view.setGeometry(0, 0, width, height)
+    # Render offscreen without showing window
+    web_view.setAttribute(Qt.WidgetAttribute.WA_DontShowOnScreen, True)
+    web_view.show()  # Trigger rendering without displaying
+    
+    # Configure settings
+    settings = web_view.settings()
+    settings.setAttribute(QWebEngineSettings.WebAttribute.LocalContentCanAccessRemoteUrls, True)
+    settings.setAttribute(QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls, True)
+    
+    def on_load_finished(ok):
+        if ok:
+            # Wait for Leaflet/JavaScript to fully render the map
+            QTimer.singleShot(int(wait_time * 1000), capture)
+    
+    def capture():
+        # Grab the rendered content
+        pixmap = web_view.grab()
+        pixmap.save(output_path, 'PNG')
+        app.quit()
+    
+    web_view.loadFinished.connect(on_load_finished)
+    
+    # Load the HTML file
+    web_view.load(QUrl.fromLocalFile(html_path))
+    
+    # Suppress output during execution
+    null_fd = os.open(os.devnull, os.O_RDWR)
+    save_stderr = os.dup(2)
+    os.dup2(null_fd, 2)
+    
+    app.exec()
+    
+    # Restore stderr
+    os.dup2(save_stderr, 2)
+    os.close(null_fd)
+    os.close(save_stderr)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print("Usage: python _qt_screenshot.py <html_path> <output_path> [width] [height] [wait_time]")
+        sys.exit(1)
+    
+    html_path = sys.argv[1]
+    output_path = sys.argv[2]
+    width = int(sys.argv[3]) if len(sys.argv) > 3 else 1920
+    height = int(sys.argv[4]) if len(sys.argv) > 4 else 1080
+    wait_time = float(sys.argv[5]) if len(sys.argv) > 5 else 1.0
+    
+    if not Path(html_path).exists():
+        print(f"ERROR: HTML file not found: {html_path}")
+        sys.exit(1)
+    
+    try:
+        capture_screenshot(html_path, output_path, width, height, wait_time)
+    except Exception as e:
+        print(f"ERROR: Failed to capture screenshot: {e}")
+        sys.exit(1)

topolib/visualization/_qt_window.py

@@ -0,0 +1,78 @@
+"""
+Qt window script for displaying maps in isolated subprocess.
+
+This module provides a standalone script that can be executed in a subprocess
+to display HTML content in a PyQt6 window without interfering with the main process.
+"""
+
+import sys
+import os
+
+# Suppress Qt warnings
+os.environ['QT_LOGGING_RULES'] = '*.debug=false;qt.webenginecontext.debug=false;qt.qpa.windows=false'
+os.environ['QTWEBENGINE_CHROMIUM_FLAGS'] = '--disable-logging --log-level=3'
+
+try:
+    from PyQt6.QtWidgets import QApplication, QMainWindow
+    from PyQt6.QtWebEngineWidgets import QWebEngineView
+    from PyQt6.QtCore import QUrl
+    from PyQt6.QtWebEngineCore import QWebEngineSettings
+except ImportError:
+    print("ERROR: PyQt6 not installed. Install with: pip install PyQt6 PyQt6-WebEngine")
+    sys.exit(1)
+
+
+class SuppressOutput:
+    """Context manager to suppress stdout/stderr during Qt event loop."""
+    
+    def __enter__(self):
+        self.null_fd = os.open(os.devnull, os.O_RDWR)
+        self.save_stdout = os.dup(1)
+        self.save_stderr = os.dup(2)
+        os.dup2(self.null_fd, 1)
+        os.dup2(self.null_fd, 2)
+        return self
+    
+    def __exit__(self, *args):
+        os.dup2(self.save_stdout, 1)
+        os.dup2(self.save_stderr, 2)
+        os.close(self.null_fd)
+        os.close(self.save_stdout)
+        os.close(self.save_stderr)
+
+
+def show_html_in_window(html_path: str, window_title: str = "Map Viewer") -> None:
+    """Display an HTML file in a PyQt6 window.
+    
+    :param html_path: Absolute path to the HTML file to display.
+    :type html_path: str
+    :param window_title: Title for the window.
+    :type window_title: str
+    """
+    app = QApplication(sys.argv)
+    window = QMainWindow()
+    window.setWindowTitle(window_title)
+    window.resize(1200, 800)
+
+    web_view = QWebEngineView()
+    settings = web_view.settings()
+    settings.setAttribute(QWebEngineSettings.WebAttribute.LocalContentCanAccessRemoteUrls, True)
+    settings.setAttribute(QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls, True)
+
+    web_view.load(QUrl.fromLocalFile(html_path))
+    window.setCentralWidget(web_view)
+    window.show()
+
+    with SuppressOutput():
+        app.exec()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python _qt_window.py <html_path> [window_title]")
+        sys.exit(1)
+    
+    html_path = sys.argv[1]
+    window_title = sys.argv[2] if len(sys.argv) > 2 else "Map Viewer"
+    
+    show_html_in_window(html_path, window_title)