feat: attributes updated when vertices or edges are deleted; added igraph_full()

Author: ntamas

docs/fragments/igraph_full.txt

@@ -0,0 +1,9 @@
+Creates a full graph with the given number of vertices.
+
+Parameters:
+    n: the number of vertices
+    directed: whether the graph is directed
+    loops: whether each vertex should also have a loop edge
+
+Returns:
+    the newly created graph

src/igraph_ctypes/_internal/attributes/handler.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from ctypes import pointer, c_int
+from ctypes import cast, pointer, c_void_p
 from math import nan
 from typing import Any, Callable, Optional, TYPE_CHECKING
 
@@ -10,6 +10,7 @@
     numpy_array_to_igraph_vector_t_view,
 )
 from igraph_ctypes._internal.enums import AttributeElementType, AttributeType
+from igraph_ctypes._internal.functions import igraph_ecount, igraph_vcount
 from igraph_ctypes._internal.lib import (
     igraph_error,
     igraph_es_as_vector,
@@ -27,7 +28,10 @@
     igraph_strvector_push_back,
     igraph_strvector_set,
 )
-from igraph_ctypes._internal.types import igraph_attribute_table_t, igraph_bool_t
+from igraph_ctypes._internal.types import (
+    igraph_attribute_table_t,
+    igraph_bool_t,
+)
 from igraph_ctypes._internal.utils import nop, protect_with, protect_with_default
 
 from .storage import (
@@ -59,6 +63,10 @@ def _trigger_error(error: int) -> int:
     )
 
 
+def _are_pointers_equal(foo, bar):
+    return cast(foo, c_void_p).value == cast(bar, c_void_p).value
+
+
 class AttributeHandlerBase:
     """Base class for igraph attribute handlers."""
 
@@ -122,9 +130,18 @@ def copy(
         copy_edge_attributes: bool,
     ):
         storage = get_storage_from_graph(graph)
-        new_storage = storage.copy(
-            copy_graph_attributes, copy_vertex_attributes, copy_edge_attributes
-        )
+
+        if copy_vertex_attributes:
+            new_vcount = -1
+        else:
+            new_vcount = int(igraph_vcount(to))
+
+        if copy_edge_attributes:
+            new_ecount = -1
+        else:
+            new_ecount = int(igraph_ecount(to))
+
+        new_storage = storage.copy(copy_graph_attributes, new_vcount, new_ecount)
         assign_storage_to_graph(to, new_storage)
 
     def add_vertices(self, graph, n: int, attr) -> None:
@@ -139,10 +156,17 @@ def add_vertices(self, graph, n: int, attr) -> None:
         get_storage_from_graph(graph).add_vertices(graph, n)
 
     def permute_vertices(self, graph, to, mapping):
-        pass
+        mapping_array = igraph_vector_int_t_to_numpy_array_view(mapping)
+
+        old_attrs = get_storage_from_graph(graph).get_vertex_attribute_map()
+        new_attrs = get_storage_from_graph(to).get_vertex_attribute_map()
+
+        # The code below works for graph == to and graph != to as well
+        for name, values in old_attrs.items():
+            new_attrs.set(name, values[mapping_array], _check_length=False)
 
     def combine_vertices(self, graph, to, mapping, combinations):
-        pass
+        assert not _are_pointers_equal(graph, to)
 
     def add_edges(self, graph, edges, attr) -> None:
         # attr will only ever be NULL here so raise an error if it is not
@@ -157,10 +181,17 @@ def add_edges(self, graph, edges, attr) -> None:
         get_storage_from_graph(graph).add_edges(graph, edge_array)
 
     def permute_edges(self, graph, to, mapping):
-        pass
+        mapping_array = igraph_vector_int_t_to_numpy_array_view(mapping)
+
+        old_attrs = get_storage_from_graph(graph).get_edge_attribute_map()
+        new_attrs = get_storage_from_graph(to).get_edge_attribute_map()
+
+        # The code below works for graph == to and graph != to as well
+        for name, values in old_attrs.items():
+            new_attrs.set(name, values[mapping_array], _check_length=False)
 
     def combine_edges(self, graph, to, mapping, combinations):
-        pass
+        assert not _are_pointers_equal(graph, to)
 
     def get_info(self, graph, gnames, gtypes, vnames, vtypes, enames, etypes):
         storage = get_storage_from_graph(graph)

src/igraph_ctypes/_internal/attributes/map.py

@@ -42,16 +42,28 @@ def copy(self: C) -> C:
             self._common_length_of_values,
         )
 
-    def copy_empty(self: C) -> C:
-        """Returns another, empty attribute map with the same expected length
+    def copy_empty(self: C, expected_length: int = -1) -> C:
+        """Returns another, empty attribute map with the given expected length
         for any items being assigned in the future.
+
+        Args:
+            expected_length: the expected length for any items being assigned
+                to the new copy in the future; negative if the expected length
+                should be the same as for this instance
         """
-        return self.__class__.wrap_empty_dict(self._common_length_of_values)
+        return self.__class__.wrap_empty_dict(
+            expected_length if expected_length >= 0 else self._common_length_of_values
+        )
 
     def remove(self, key: str) -> None:
         del self._items[key]
 
-    def set(self, key: str, value: T | Iterable[T]) -> None:
+    def set(
+        self,
+        key: str,
+        value: T | Iterable[T],
+        _check_length: bool = True,
+    ) -> None:
         """Assigns a value to _all_ the attribute values corresponding to the
         given attribute.
 
@@ -79,7 +91,7 @@ def set(self, key: str, value: T | Iterable[T]) -> None:
             # iterables are mapped to an AttributeValueList. Note that this
             # also takes care of copying existing AttributeValueList instances
             avl = AttributeValueList(value, fixed_length=True)  # type: ignore
-            if len(avl) != length:
+            if _check_length and len(avl) != length:
                 raise RuntimeError(
                     f"attribute value list length must be {length}, got {len(avl)}"
                 )
@@ -90,7 +102,9 @@ def set(self, key: str, value: T | Iterable[T]) -> None:
                 [value] * length, fixed_length=True
             )  # type: ignore
 
-        assert avl.fixed_length and len(avl) == length
+        assert avl.fixed_length
+        assert not _check_length or len(avl) == length
+
         self._items[key] = avl
 
     def _extend_common_length(self, n: int) -> None:

src/igraph_ctypes/_internal/attributes/storage.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from ctypes import py_object
 from dataclasses import dataclass, field
-from typing import Any, MutableMapping, Optional
+from typing import Any, MutableMapping, Optional, TypeVar
 
 from igraph_ctypes._internal.refcount import incref, decref
 from igraph_ctypes._internal.types import IntArray
@@ -17,6 +17,9 @@
 )
 
 
+C = TypeVar("C", bound="AttributeStorage")
+
+
 class AttributeStorage(ABC):
     """Interface specification for objects that store graph, vertex and edge
     attributes.
@@ -43,11 +46,11 @@ def clear(self):
 
     @abstractmethod
     def copy(
-        self,
+        self: C,
         copy_graph_attributes: bool = True,
-        copy_vertex_attributes: bool = True,
-        copy_edge_attributes: bool = True,
-    ):
+        new_vcount: int = -1,
+        new_ecount: int = -1,
+    ) -> C:
         """Creates a shallow copy of the storage area."""
         raise NotImplementedError
 
@@ -101,17 +104,17 @@ def clear(self) -> None:
     def copy(
         self,
         copy_graph_attributes: bool = True,
-        copy_vertex_attributes: bool = True,
-        copy_edge_attributes: bool = True,
+        new_vertex_count: int = -1,
+        new_edge_count: int = -1,
     ):
         return self.__class__(
             self.graph_attributes.copy() if copy_graph_attributes else {},
             self.vertex_attributes.copy()
-            if copy_vertex_attributes
-            else self.vertex_attributes.copy_empty(),
+            if new_vertex_count < 0
+            else self.vertex_attributes.copy_empty(new_vertex_count),
             self.edge_attributes.copy()
-            if copy_edge_attributes
-            else self.edge_attributes.copy_empty(),
+            if new_edge_count < 0
+            else self.edge_attributes.copy_empty(new_edge_count),
         )
 
     def get_graph_attribute_map(self) -> MutableMapping[str, Any]:

src/igraph_ctypes/_internal/functions.py

@@ -559,7 +559,16 @@ def regular_tree(h: int, k: int = 3, type: TreeMode = TreeMode.UNDIRECTED) -> Gr
 
 
 def full(n: int, directed: bool = False, loops: bool = False) -> Graph:
-    """Type-annotated wrapper for ``igraph_full``."""
+    """Creates a full graph with the given number of vertices.
+
+    Parameters:
+        n: the number of vertices
+        directed: whether the graph is directed
+        loops: whether each vertex should also have a loop edge
+
+    Returns:
+        the newly created graph
+    """
     # Prepare input arguments
     c_graph = _Graph()
     c_n = n

src/igraph_ctypes/constructors.py

@@ -5,13 +5,15 @@
     create as create_graph_from_edge_list,
     empty as create_empty_graph,
     famous as create_famous_graph,
+    full as create_full_graph,
     grg_game,
     square_lattice,
 )
 
 __all__ = (
     "create_empty_graph",
     "create_famous_graph",
+    "create_full_graph",
     "create_geometric_random_graph",
     "create_graph_from_edge_list",
     "create_square_lattice",

tests/test_constructors.py

@@ -3,12 +3,13 @@
 from numpy import array, ndarray
 from numpy.testing import assert_array_equal
 
+from igraph_ctypes.conversion import get_edge_list
 from igraph_ctypes.constructors import (
     create_famous_graph,
+    create_full_graph,
     create_graph_from_edge_list,
     create_square_lattice,
 )
-from igraph_ctypes._internal.functions import get_edgelist
 
 
 def test_create_famous_graph():
@@ -19,6 +20,33 @@ def test_create_famous_graph():
     assert not g.is_directed() and g.vcount() == 10 and g.ecount() == 15
 
 
+def test_create_full_graph():
+    g = create_full_graph(0)
+    assert g.vcount() == 0
+    assert g.ecount() == 0
+    assert not g.is_directed()
+
+    g = create_full_graph(1, directed=True)
+    assert g.vcount() == 1
+    assert g.ecount() == 0
+    assert g.is_directed()
+
+    g = create_full_graph(5, loops=True)
+    assert g.vcount() == 5
+    assert g.ecount() == 15
+    assert not g.is_directed()
+    # fmt: off
+    assert_array_equal(
+        get_edge_list(g).reshape(-1),
+        array([0, 0, 0, 1, 0, 2, 0, 3, 0, 4,
+               1, 1, 1, 2, 1, 3, 1, 4,
+               2, 2, 2, 3, 2, 4,
+               3, 3, 3, 4,
+               4, 4])
+    )
+    # fmt: on
+
+
 @pytest.mark.parametrize(
     ("edges", "n", "directed"),
     [
@@ -52,7 +80,7 @@ def test_create_square_lattice():
     assert g.vcount() == 12 and g.ecount() == 17
     # fmt: off
     assert_array_equal(
-        get_edgelist(g._instance),
+        get_edge_list(g).reshape(-1),
         array([0, 1, 0, 4, 1, 2, 1, 5, 2, 3, 2, 6, 3, 7,
                4, 5, 4, 8, 5, 6, 5, 9, 6, 7, 6, 10, 7, 11,
                8, 9, 9, 10, 10, 11])

tests/test_graph_attributes.py

@@ -1,5 +1,9 @@
 from collections.abc import MutableMapping
-from igraph_ctypes.constructors import create_empty_graph, create_famous_graph
+from igraph_ctypes.constructors import (
+    create_empty_graph,
+    create_famous_graph,
+    create_full_graph,
+)
 
 
 def test_attribute_mapping_basic_operations():
@@ -37,3 +41,24 @@ def test_copying_graph_copies_attributes():
     del g2.attrs["age"]
     assert "age" not in g2.attrs
     assert g.attrs["age"] == 42
+
+
+def test_deleting_edges_updates_edge_attributes():
+    g = create_full_graph(6)
+    weights = [i + 10 for i in range(g.ecount())]
+    g.eattrs.set("weight", weights)
+
+    assert list(g.eattrs["weight"]) == weights
+    g.delete_edges([6, 4, 11])
+    assert list(g.eattrs["weight"]) == [10, 11, 12, 13, 15, 17, 18, 19, 20, 22, 23, 24]
+
+
+def test_deleting_vertices_updates_vertex_and_edge_attributes():
+    g = create_full_graph(5)
+    g.vattrs.set("name", list("ABCDE"))
+    weights = [i + 10 for i in range(g.ecount())]
+    g.eattrs.set("weight", weights)
+
+    assert list(g.vattrs["name"]) == ["A", "B", "C", "D", "E"]
+    g.delete_vertices([0, 3])
+    assert list(g.eattrs["weight"]) == [14, 16, 18]