topolib 0.0.0__py3-none-any.whl

topolib/elements/__init__.py

@@ -0,0 +1,8 @@
+
+from .node import Node
+from .link import Link
+
+# Hide re-exported Link from Sphinx index to avoid duplicate warnings
+Link.__doc__ = """.. :noindex:"""
+
+__all__ = ["Node", "Link"]

topolib/elements/link.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from topolib.elements.node import Node
+
+
+class Link:
+
+    """
+    .. :noindex:
+
+    Represents a link between two nodes.
+
+    Parameters
+    ----------
+    id : int
+        Unique identifier for the link.
+    source : :class:`topolib.elements.node.Node`
+        Source node-like object (must have id, name, latitude, longitude).
+    target : :class:`topolib.elements.node.Node`
+        Target node-like object (must have id, name, latitude, longitude).
+    length : float
+        Length of the link (must be non-negative).
+
+    Attributes
+    ----------
+    id : int
+        Unique identifier for the link.
+    source : :class:`topolib.elements.node.Node`
+        Source node of the link.
+    target : :class:`topolib.elements.node.Node`
+        Target node of the link.
+    length : float
+        Length of the link.
+
+    Examples
+    --------
+    >>> link = Link(1, nodeA, nodeB, 10.5)
+    >>> link.length
+    """
+
+    def __init__(self, id: int, source: "Node", target: "Node", length: float):
+        self._id = id
+        self.source = source
+        self.target = target
+        self.length = length
+
+    @property
+    def id(self) -> int:
+        """
+        .. :noindex:
+
+        int: Unique identifier for the link.
+        """
+        return self._id
+
+    @id.setter
+    def id(self, value: int) -> None:
+        """
+        Set the link's unique identifier.
+        """
+        self._id = value
+
+    @property
+    def source(self) -> "Node":
+        """
+        .. :noindex:
+
+        :class:`topolib.elements.node.Node`: Source node of the link.
+        """
+        return self._source
+
+    @source.setter
+    def source(self, value: "Node") -> None:
+        """
+        Set the source node. Must have id, name, latitude, longitude.
+        """
+        required_attrs = ("id", "name", "latitude", "longitude")
+        for attr in required_attrs:
+            if not hasattr(value, attr):
+                raise TypeError(
+                    f"source must behave like a Node (missing {attr})")
+        self._source = value
+
+    @property
+    def target(self) -> "Node":
+        """
+        .. :noindex:
+
+        :class:`topolib.elements.node.Node`: Target node of the link.
+        """
+        return self._target
+
+    @target.setter
+    def target(self, value: "Node") -> None:
+        """
+        Set the target node. Must have id, name, latitude, longitude.
+        """
+        required_attrs = ("id", "name", "latitude", "longitude")
+        for attr in required_attrs:
+            if not hasattr(value, attr):
+                raise TypeError(
+                    f"target must behave like a Node (missing {attr})")
+        self._target = value
+
+    @property
+    def length(self) -> float:
+        """
+        .. :noindex:
+
+        float: Length of the link (non-negative).
+        """
+        return self._length
+
+    @length.setter
+    def length(self, value: float) -> None:
+        """
+        Set the length of the link. Must be a non-negative float.
+        """
+        try:
+            numeric = float(value)
+        except Exception:
+            raise TypeError("length must be a numeric value")
+        if numeric < 0:
+            raise ValueError("length must be non-negative")
+        self._length = numeric
+
+    def endpoints(self):
+        """
+        Return the (source, target) nodes as a tuple.
+
+        Returns
+        -------
+        tuple
+            (source_node, target_node)
+        """
+        return self._source, self._target
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the Link.
+        """
+        return f"Link(id={self._id}, source={self._source.id}, target={self._target.id}, length={self._length})"

topolib/elements/node.py

@@ -0,0 +1,221 @@
+"""
+Node class for optical network topologies.
+
+This module defines the Node class, representing a network node with geographic coordinates.
+"""
+
+from typing import Tuple
+
+
+class Node:
+    """
+    .. :noindex:
+
+    Represents a node in an optical network topology.
+
+    :param id: Unique identifier for the node.
+    :type id: int
+    :param name: Name of the node.
+    :type name: str
+    :param latitude: Latitude coordinate of the node.
+    :type latitude: float
+    :param longitude: Longitude coordinate of the node.
+    :type longitude: float
+    :param weight: Node weight (optional, default 0).
+    :type weight: float or int
+    :param pop: Node population (optional, default 0).
+    :type pop: int
+    :param dc: Datacenter (DC) value for the node (optional, default 0).
+    :type dc: int
+    :param ixp: IXP (Internet Exchange Point) value for the node (optional, default 0).
+    :type ixp: int
+    """
+
+    def __init__(
+        self,
+        id: int,
+        name: str,
+        latitude: float,
+        longitude: float,
+        weight: float = 0,
+        pop: int = 0,
+        dc: int = 0,
+        ixp: int = 0,
+    ):
+        self._id = id
+        self._name = name
+        self._latitude = latitude
+        self._longitude = longitude
+        self._weight = weight
+        self._pop = pop
+        self._dc = dc
+        self._ixp = ixp
+
+    @property
+    def dc(self) -> int:
+        """
+        Get the datacenter (DC) count or value for the node.
+
+        :return: Node DC value.
+        :rtype: int
+        """
+        return self._dc
+
+    @dc.setter
+    def dc(self, value: int) -> None:
+        """
+        Set the datacenter (DC) value for the node.
+
+        :param value: Node DC value.
+        :type value: int
+        """
+        self._dc = value
+
+    @property
+    def ixp(self) -> int:
+        """
+        Get the IXP (Internet Exchange Point) count or value for the node.
+
+        :return: Node IXP value.
+        :rtype: int
+        """
+        return self._ixp
+
+    @ixp.setter
+    def ixp(self, value: int) -> None:
+        """
+        Set the IXP (Internet Exchange Point) value for the node.
+
+        :param value: Node IXP value.
+        :type value: int
+        """
+        self._ixp = value
+
+    @property
+    def id(self) -> int:
+        """
+        Get the unique identifier of the node.
+
+        :return: Node ID.
+        :rtype: int
+        """
+        return self._id
+
+    @id.setter
+    def id(self, value: int) -> None:
+        """
+        Set the unique identifier of the node.
+
+        :param value: Node ID.
+        :type value: int
+        """
+        self._id = value
+
+    @property
+    def name(self) -> str:
+        """
+        Get the name of the node.
+
+        :return: Node name.
+        :rtype: str
+        """
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        """
+        Set the name of the node.
+
+        :param value: Node name.
+        :type value: str
+        """
+        self._name = value
+
+    @property
+    def latitude(self) -> float:
+        """
+        Get the latitude coordinate of the node.
+
+        :return: Latitude value.
+        :rtype: float
+        """
+        return self._latitude
+
+    @latitude.setter
+    def latitude(self, value: float) -> None:
+        """
+        Set the latitude coordinate of the node.
+
+        :param value: Latitude value.
+        :type value: float
+        """
+        self._latitude = value
+
+    @property
+    def longitude(self) -> float:
+        """
+        Get the longitude coordinate of the node.
+
+        :return: Longitude value.
+        :rtype: float
+        """
+        return self._longitude
+
+    @longitude.setter
+    def longitude(self, value: float) -> None:
+        """
+        Set the longitude coordinate of the node.
+
+        :param value: Longitude value.
+        :type value: float
+        """
+        self._longitude = value
+
+    @property
+    def weight(self) -> float:
+        """
+        Get the weight of the node.
+
+        :return: Node weight.
+        :rtype: float
+        """
+        return self._weight
+
+    @weight.setter
+    def weight(self, value: float) -> None:
+        """
+        Set the weight of the node.
+
+        :param value: Node weight.
+        :type value: float
+        """
+        self._weight = value
+
+    @property
+    def pop(self) -> int:
+        """
+        Get the population of the node.
+
+        :return: Node population.
+        :rtype: int
+        """
+        return self._pop
+
+    @pop.setter
+    def pop(self, value: int) -> None:
+        """
+        Set the population of the node.
+
+        :param value: Node population.
+        :type value: int
+        """
+        self._pop = value
+
+    def coordinates(self) -> Tuple[float, float]:
+        """
+        Returns the (latitude, longitude) coordinates of the node.
+
+        :return: Tuple containing latitude and longitude.
+        :rtype: Tuple[float, float]
+        """
+        return self._latitude, self._longitude

topolib/topology/__init__.py

@@ -0,0 +1,4 @@
+from .path import Path
+from .topology import Topology
+
+__all__ = ["Path", "Topology"]

topolib/topology/path.py

@@ -0,0 +1,84 @@
+"""
+Path class for representing a sequence of nodes and links in a topology.
+"""
+
+from typing import List, Any
+
+
+class Path:
+    """
+    Represents a path through the network topology as an ordered sequence of nodes and links.
+
+    Parameters
+    ----------
+    nodes : list
+        Ordered list of node objects in the path.
+    links : list
+        Ordered list of link objects in the path (len(links) == len(nodes) - 1).
+
+    Raises
+    ------
+    ValueError
+        If the number of nodes and links is inconsistent or empty.
+
+    Attributes
+    ----------
+    nodes : list
+        Ordered list of nodes in the path.
+    links : list
+        Ordered list of links in the path.
+
+    Examples
+    --------
+    >>> nodes = [Node(1), Node(2), Node(3)]
+    >>> links = [Link('a'), Link('b')]
+    >>> path = Path(nodes, links)
+    >>> path.length()
+    2
+    >>> path.endpoints()
+    (Node(1), Node(3))
+    """
+
+    def __init__(self, nodes: List[Any], links: List[Any]):
+        if not nodes or not links:
+            raise ValueError("A path must have at least one node and one link.")
+        if len(nodes) != len(links) + 1:
+            raise ValueError("Number of nodes must be one more than number of links.")
+        self.nodes = nodes
+        self.links = links
+
+    def length(self) -> int:
+        """
+        Return the number of links in the path.
+
+        Returns
+        -------
+        int
+            Number of links in the path.
+        """
+        return len(self.links)
+
+    def hop_count(self) -> int:
+        """
+        Return the number of hops (links) in the path.
+
+        Returns
+        -------
+        int
+            Number of hops (links) in the path.
+        """
+        return self.length()
+
+    def endpoints(self):
+        """
+        Return the source and target nodes of the path as a tuple.
+
+        Returns
+        -------
+        tuple
+            (source_node, target_node)
+        """
+        return (self.nodes[0], self.nodes[-1])
+
+    def __repr__(self):
+        return f"Path(nodes={self.nodes}, links={self.links})"

topolib/topology/topology.py

@@ -0,0 +1,172 @@
+"""
+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, Dict, Any, Optional
+import numpy as np
+import networkx as nx
+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.Graph()
+        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
+        """
+        import json
+        from topolib.elements.node import Node
+        from topolib.elements.link import Link
+
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        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) -> np.ndarray:
+        """
+        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

topolib/visualization/__init__.py

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