topolib 0.0.0__py3-none-any.whl

tests/test_topology.py

@@ -0,0 +1,225 @@
+"""
+Unit tests for the Topology class.
+Covers all public methods, success and error cases, and adjacency matrix validation (numpy), including NetworkX integration.
+"""
+
+import pytest
+import numpy as np
+from topolib.topology import Topology
+from topolib.elements.node import Node
+from topolib.elements.link import Link
+
+
+def test_add_and_get_nodes():
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    n2 = Node(2, "B", 1.0, 1.0)
+    topo.add_node(n1)
+    topo.add_node(n2)
+    assert n1 in topo.nodes and n2 in topo.nodes
+    assert len(topo.nodes) == 2
+    # Check that nodes are present in the internal networkx graph
+    assert n1.id in topo._graph.nodes  # type: ignore
+    assert n2.id in topo._graph.nodes  # type: ignore
+
+
+def test_add_duplicate_node_allowed():
+    # The current design allows duplicate nodes (no check in Topology)
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    topo.add_node(n1)
+    topo.add_node(n1)
+    assert topo.nodes.count(n1) == 2
+
+
+def test_remove_node():
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    n2 = Node(2, "B", 1.0, 1.0)
+    topo.add_node(n1)
+    topo.add_node(n2)
+    topo.remove_node(n1.id)
+    assert n1 not in topo.nodes
+    assert n2 in topo.nodes
+    # Check that the node was removed from the internal graph
+    assert n1.id not in topo._graph.nodes  # type: ignore
+
+
+def test_remove_nonexistent_node():
+    import networkx as nx
+
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    # Should raise NetworkXError when trying to remove a node not in the graph
+    with pytest.raises(nx.NetworkXError):
+        topo.remove_node(n1.id)
+    assert n1 not in topo.nodes
+
+
+def test_add_and_get_links():
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    n2 = Node(2, "B", 1.0, 1.0)
+    topo.add_node(n1)
+    topo.add_node(n2)
+    l1 = Link(1, n1, n2, 10.0)
+    topo.add_link(l1)
+    assert l1 in topo.links
+    assert len(topo.links) == 1
+    # Check that the edge is present in the internal networkx graph
+    assert topo._graph.has_edge(n1.id, n2.id)  # type: ignore
+
+
+def test_add_link_with_missing_nodes():
+    # The current design allows adding links even if nodes are not in the topology
+    topo = 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.add_link(l1)
+    assert l1 in topo.links
+
+
+def test_remove_link():
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    n2 = Node(2, "B", 1.0, 1.0)
+    topo.add_node(n1)
+    topo.add_node(n2)
+    l1 = Link(1, n1, n2, 10.0)
+    topo.add_link(l1)
+    topo.remove_link(l1.id)
+    assert l1 not in topo.links
+    # Check that the edge was removed from the internal graph
+    assert not topo._graph.has_edge(n1.id, n2.id)  # type: ignore
+
+
+def test_remove_nonexistent_link():
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    n2 = Node(2, "B", 1.0, 1.0)
+    topo.add_node(n1)
+    topo.add_node(n2)
+    # Should not raise, just does nothing
+    topo.remove_link(999)
+    assert len(topo.links) == 0
+
+
+def test_adjacency_matrix():
+    topo = Topology()
+    n1 = Node(1, "A", 0.0, 0.0)
+    n2 = Node(2, "B", 1.0, 1.0)
+    n3 = Node(3, "C", 2.0, 2.0)
+    topo.add_node(n1)
+    topo.add_node(n2)
+    topo.add_node(n3)
+    l1 = Link(1, n1, n2, 10.0)
+    l2 = Link(2, n2, n3, 20.0)
+    topo.add_link(l1)
+    topo.add_link(l2)
+    matrix = topo.adjacency_matrix()
+    assert isinstance(matrix, np.ndarray)
+    assert matrix.shape == (3, 3)
+    # Check connections
+    idx = {n.id: i for i, n in enumerate(topo.nodes)}
+    assert matrix[idx[n1.id], idx[n2.id]] == 1
+    assert matrix[idx[n2.id], idx[n3.id]] == 1
+    assert matrix[idx[n1.id], idx[n3.id]] == 0
+    # Validate with networkx adjacency
+    adj_nx = np.asarray(
+        np.array(
+            [
+                [1 if topo._graph.has_edge(n1.id, n2.id) else 0 for n2 in topo.nodes]  # type: ignore
+                for n1 in topo.nodes
+            ]
+        )
+    )
+    assert np.array_equal(matrix, adj_nx)
+
+
+def test_adjacency_matrix_empty():
+    topo = Topology()
+    matrix = topo.adjacency_matrix()
+    assert isinstance(matrix, np.ndarray)
+    assert matrix.shape == (0, 0)
+
+
+def test_topology_from_json():
+    import os
+    import tempfile
+    import json
+    from topolib.topology import Topology
+
+    # Usar un ejemplo mínimo de topología
+    data = {
+        "name": "TestNet",
+        "nodes": [
+            {
+                "id": 1,
+                "name": "A",
+                "latitude": 0.0,
+                "longitude": 0.0,
+                "weight": 1.5,
+                "pop": 1000,
+            },
+            {
+                "id": 2,
+                "name": "B",
+                "latitude": 1.0,
+                "longitude": 1.0,
+                "weight": 2.5,
+                "pop": 2000,
+            },
+        ],
+        "links": [{"id": 10, "src": 1, "dst": 2, "length": 42.0}],
+    }
+    with tempfile.NamedTemporaryFile("w+", suffix=".json", delete=False) as f:
+        json.dump(data, f)
+        f.flush()
+        path = f.name
+    topo = Topology.from_json(path)
+    os.remove(path)
+    assert len(topo.nodes) == 2
+    assert len(topo.links) == 1
+    n1, n2 = topo.nodes
+    assert n1.name == "A"
+    assert n2.pop == 2000
+    l = topo.links[0]
+    assert l.length == 42.0
+    assert l.source.id == 1 and l.target.id == 2
+
+
+def test_topology_from_json_reads_dc_ixp(tmp_path):
+    import json
+    from topolib.topology import Topology
+
+    # Crear un archivo JSON temporal con los nuevos campos
+    data = {
+        "name": "TestNet",
+        "nodes": [
+            {
+                "id": 1,
+                "name": "A",
+                "latitude": 0.0,
+                "longitude": 0.0,
+                "dc": 10,
+                "ixp": 2,
+            },
+            {
+                "id": 2,
+                "name": "B",
+                "latitude": 1.0,
+                "longitude": 1.0,
+                "dc": 20,
+                "ixp": 5,
+            },
+        ],
+        "links": [],
+    }
+    json_file = tmp_path / "testnet.json"
+    json_file.write_text(json.dumps(data))
+    topo = Topology.from_json(str(json_file))
+    assert topo.nodes[0].dc == 10
+    assert topo.nodes[0].ixp == 2
+    assert topo.nodes[1].dc == 20
+    assert topo.nodes[1].ixp == 5

tests/test_version.py

@@ -0,0 +1,6 @@
+import importlib
+
+def test_package_exports_version():
+    pkg = importlib.import_module("topolib")
+    assert hasattr(pkg, "__version__"), "topolib should expose __version__"
+    assert isinstance(pkg.__version__, str), "__version__ should be a string"

topolib/__init__.py

@@ -0,0 +1,4 @@
+try:
+    from ._version import __version__
+except ImportError:
+    __version__ = "unknown"

topolib/analysis/__init__.py

@@ -0,0 +1,3 @@
+from .metrics import Metrics
+
+__all__ = ["Metrics"]

topolib/analysis/metrics.py

@@ -0,0 +1,80 @@
+"""
+Metrics module for network topology analysis.
+"""
+
+from typing import List, Any, Dict, Optional
+
+
+from topolib.topology import Topology
+
+
+class Metrics:
+    """
+    Provides static methods for computing metrics on network topologies.
+
+    Todos los métodos reciben una instancia de Topology.
+
+    Métodos
+    -------
+    node_degree(topology)
+        Calcula el grado de cada nodo.
+    link_length_stats(topology)
+        Calcula estadísticas (min, max, avg) de las longitudes de los enlaces.
+    connection_matrix(topology)
+        Construye la matriz de adyacencia.
+    """
+
+    @staticmethod
+    def node_degree(topology: "Topology") -> Dict[int, int]:
+        """
+        Calculates the degree of each node in the topology.
+
+        :param topology: Instance of topolib.topology.topology.Topology.
+        :type topology: topolib.topology.topology.Topology
+        :return: Dictionary {node_id: degree}
+        :rtype: dict[int, int]
+        """
+        degree = {n.id: 0 for n in topology.nodes}
+        for link in topology.links:
+            degree[link.source.id] += 1
+            degree[link.target.id] += 1
+        return degree
+
+    @staticmethod
+    def link_length_stats(topology: "Topology") -> Dict[str, Optional[float]]:
+        """
+        Calculates the minimum, maximum, and average link lengths.
+
+        :param topology: Instance of topolib.topology.topology.Topology.
+        :type topology: topolib.topology.topology.Topology
+        :return: Dictionary with keys 'min', 'max', 'avg'.
+        :rtype: dict[str, float | None]
+        """
+        lengths = [l.length for l in topology.links]
+        if not lengths:
+            return {"min": None, "max": None, "avg": None}
+        return {
+            "min": min(lengths),
+            "max": max(lengths),
+            "avg": sum(lengths) / len(lengths),
+        }
+
+    @staticmethod
+    def connection_matrix(topology: "Topology") -> List[List[int]]:
+        """
+        Builds the adjacency matrix of the topology.
+
+        :param topology: Instance of topolib.topology.topology.Topology.
+        :type topology: topolib.topology.topology.Topology
+        :return: Adjacency matrix (1 if connected, 0 otherwise).
+        :rtype: list[list[int]]
+        """
+        id_to_idx = {n.id: i for i, n in enumerate(topology.nodes)}
+        size = len(topology.nodes)
+        matrix = [[0] * size for _ in range(size)]
+        for link in topology.links:
+            i = id_to_idx[link.source.id]
+            j = id_to_idx[link.target.id]
+            matrix[i][j] = 1
+            matrix[j][i] = 1
+        return matrix

topolib/assets/Abilene_IXP.json

@@ -0,0 +1,285 @@
+{
+    "name": "Abilene",
+    "nodes": [
+        {
+            "id": 0,
+            "name": "Seattle",
+            "weight": 0,
+            "longitude": -122.3328481,
+            "latitude": 47.6061389,
+            "pop": 780995,
+            "DC": 58,
+            "IXP": 5
+        },
+        {
+            "id": 1,
+            "name": "Sunnyvale",
+            "weight": 0,
+            "longitude": -122.0363496,
+            "latitude": 37.36883,
+            "pop": 155805,
+            "DC": 0,
+            "IXP": 0
+        },
+        {
+            "id": 2,
+            "name": "Los Angeles",
+            "weight": 0,
+            "longitude": -118.242643,
+            "latitude": 34.0549076,
+            "pop": 3820914,
+            "DC": 71,
+            "IXP": 9
+        },
+        {
+            "id": 3,
+            "name": "Denver",
+            "weight": 0,
+            "longitude": -104.990251,
+            "latitude": 39.7392358,
+            "pop": 729019,
+            "DC": 49,
+            "IXP": 6
+        },
+        {
+            "id": 4,
+            "name": "Kansas City",
+            "weight": 0,
+            "longitude": -94.5785667,
+            "latitude": 39.0997265,
+            "pop": 475378,
+            "DC": 25,
+            "IXP": 1
+        },
+        {
+            "id": 5,
+            "name": "Houston",
+            "weight": 0,
+            "longitude": -95.3701108,
+            "latitude": 29.7600771,
+            "pop": 2314157,
+            "DC": 55,
+            "IXP": 6
+        },
+        {
+            "id": 6,
+            "name": "Atlanta",
+            "weight": 0,
+            "longitude": -84.3885209,
+            "latitude": 33.7501275,
+            "pop": 510823,
+            "DC": 145,
+            "IXP": 7
+        },
+        {
+            "id": 7,
+            "name": "Indianapolis",
+            "weight": 0,
+            "longitude": -86.158018,
+            "latitude": 39.76909,
+            "pop": 887642,
+            "DC": 30,
+            "IXP": 2
+        },
+        {
+            "id": 8,
+            "name": "Chicago",
+            "weight": 0,
+            "longitude": -87.6323879,
+            "latitude": 41.88325,
+            "pop": 2664452,
+            "DC": 165,
+            "IXP": 10
+        },
+        {
+            "id": 9,
+            "name": "Washington D.C.",
+            "weight": 0,
+            "longitude": -77.0368707,
+            "latitude": 38.9071923,
+            "pop": 689545,
+            "DC": 7,
+            "IXP": 3
+        },
+        {
+            "id": 10,
+            "name": "New York",
+            "weight": 0,
+            "longitude": -74.0059728,
+            "latitude": 40.7127753,
+            "pop": 8804190,
+            "DC": 70,
+            "IXP": 11
+        }
+    ],
+    "links": [
+        {
+            "id": 0,
+            "src": 0,
+            "dst": 1,
+            "length": 1482.26
+        },
+        {
+            "id": 1,
+            "src": 2,
+            "dst": 1,
+            "length": 649.31
+        },
+        {
+            "id": 2,
+            "src": 5,
+            "dst": 2,
+            "length": 2870.2
+        },
+        {
+            "id": 3,
+            "src": 4,
+            "dst": 5,
+            "length": 1360.7
+        },
+        {
+            "id": 4,
+            "src": 3,
+            "dst": 0,
+            "length": 2123.16
+        },
+        {
+            "id": 5,
+            "src": 3,
+            "dst": 1,
+            "length": 1949.85
+        },
+        {
+            "id": 6,
+            "src": 4,
+            "dst": 3,
+            "length": 1153.26
+        },
+        {
+            "id": 7,
+            "src": 8,
+            "dst": 7,
+            "length": 345.36
+        },
+        {
+            "id": 8,
+            "src": 4,
+            "dst": 7,
+            "length": 933.65
+        },
+        {
+            "id": 9,
+            "src": 5,
+            "dst": 6,
+            "length": 1471.24
+        },
+        {
+            "id": 10,
+            "src": 6,
+            "dst": 7,
+            "length": 912.61
+        },
+        {
+            "id": 11,
+            "src": 10,
+            "dst": 8,
+            "length": 1489.76
+        },
+        {
+            "id": 12,
+            "src": 6,
+            "dst": 9,
+            "length": 1126.74
+        },
+        {
+            "id": 13,
+            "src": 9,
+            "dst": 10,
+            "length": 416.12
+        },
+        {
+            "id": 14,
+            "src": 1,
+            "dst": 0,
+            "length": 1482.26
+        },
+        {
+            "id": 15,
+            "src": 1,
+            "dst": 2,
+            "length": 649.31
+        },
+        {
+            "id": 16,
+            "src": 2,
+            "dst": 5,
+            "length": 2870.2
+        },
+        {
+            "id": 17,
+            "src": 5,
+            "dst": 4,
+            "length": 1360.7
+        },
+        {
+            "id": 18,
+            "src": 0,
+            "dst": 3,
+            "length": 2123.16
+        },
+        {
+            "id": 19,
+            "src": 1,
+            "dst": 3,
+            "length": 1949.85
+        },
+        {
+            "id": 20,
+            "src": 3,
+            "dst": 4,
+            "length": 1153.26
+        },
+        {
+            "id": 21,
+            "src": 7,
+            "dst": 8,
+            "length": 345.36
+        },
+        {
+            "id": 22,
+            "src": 7,
+            "dst": 4,
+            "length": 933.65
+        },
+        {
+            "id": 23,
+            "src": 6,
+            "dst": 5,
+            "length": 1471.24
+        },
+        {
+            "id": 24,
+            "src": 7,
+            "dst": 6,
+            "length": 912.61
+        },
+        {
+            "id": 25,
+            "src": 8,
+            "dst": 10,
+            "length": 1489.76
+        },
+        {
+            "id": 26,
+            "src": 9,
+            "dst": 6,
+            "length": 1126.74
+        },
+        {
+            "id": 27,
+            "src": 10,
+            "dst": 9,
+            "length": 416.12
+        }
+    ]
+}