feat: added support for attribute type retrieval and casting

Author: ntamas

src/igraph_ctypes/_internal/attributes/utils.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from numpy.typing import DTypeLike
-from typing import Any, Iterable
+from typing import Any, Iterable, Type
 
 from .enums import AttributeType
 from ..types import (
@@ -10,13 +10,24 @@
 )
 
 __all__ = (
-    "get_igraph_attribute_type_from_iterable",
-    "get_numpy_attribute_type_from_iterable",
     "igraph_to_numpy_attribute_type",
+    "iterable_to_igraph_attribute_type",
+    "iterable_to_numpy_attribute_type",
+    "python_type_to_igraph_attribute_type",
 )
 
 
-def get_igraph_attribute_type_from_iterable(  # noqa: C901
+def igraph_to_numpy_attribute_type(type: AttributeType) -> DTypeLike:
+    """Converts an igraph attribute type to an equivalent NumPy data type."""
+    if type is AttributeType.BOOLEAN:
+        return np_type_of_igraph_bool_t
+    elif type is AttributeType.NUMERIC:
+        return np_type_of_igraph_real_t
+    else:
+        return np.object_
+
+
+def iterable_to_igraph_attribute_type(
     it: Iterable[Any],
 ) -> AttributeType:
     """Determines the appropriate igraph attribute type to store all the items
@@ -31,26 +42,18 @@ def get_igraph_attribute_type_from_iterable(  # noqa: C901
         # Iterable empty
         return AttributeType.UNSPECIFIED
 
-    best_fit: AttributeType
-    if isinstance(item, bool):
-        best_fit = AttributeType.BOOLEAN
-    elif isinstance(item, (int, float, np.number)):
-        best_fit = AttributeType.NUMERIC
-    elif isinstance(item, str):
-        best_fit = AttributeType.STRING
-    else:
-        return AttributeType.OBJECT
-
+    best_fit = python_type_to_igraph_attribute_type(type(item))
     for item in it:
-        if isinstance(item, bool):
+        next_type = python_type_to_igraph_attribute_type(type(item))
+        if next_type is AttributeType.BOOLEAN:
             if best_fit == AttributeType.STRING:
                 return AttributeType.OBJECT
-        elif isinstance(item, (int, float, np.number)):
+        elif next_type is AttributeType.NUMERIC:
             if best_fit == AttributeType.STRING:
                 return AttributeType.OBJECT
             else:
                 best_fit = AttributeType.NUMERIC
-        elif isinstance(item, str):
+        elif next_type is AttributeType.STRING:
             if best_fit != AttributeType.STRING:
                 return AttributeType.OBJECT
         else:
@@ -59,9 +62,7 @@ def get_igraph_attribute_type_from_iterable(  # noqa: C901
     return best_fit
 
 
-def get_numpy_attribute_type_from_iterable(
-    it: Iterable[Any],
-) -> DTypeLike:
+def iterable_to_numpy_attribute_type(it: Iterable[Any]) -> DTypeLike:
     """Determines the appropriate NumPy attribute type to store all the items
     found in the given iterable as an attribute.
 
@@ -70,17 +71,33 @@ def get_numpy_attribute_type_from_iterable(
 
     When the iterable is empty, a numeric attribute will be assumed.
     """
-    attr_type = get_igraph_attribute_type_from_iterable(it)
+    attr_type = iterable_to_igraph_attribute_type(it)
     if attr_type is AttributeType.UNSPECIFIED:
         attr_type = AttributeType.NUMERIC
     return igraph_to_numpy_attribute_type(attr_type)
 
 
-def igraph_to_numpy_attribute_type(type: AttributeType) -> DTypeLike:
-    """Converts an igraph attribute type to an equivalent NumPy data type."""
-    if type is AttributeType.BOOLEAN:
-        return np_type_of_igraph_bool_t
-    elif type is AttributeType.NUMERIC:
-        return np_type_of_igraph_real_t
-    else:
-        return np.object_
+def python_object_to_igraph_attribute_type(obj: Any) -> AttributeType:
+    """Converts the given Python object into the most fitting igraph attribute
+    type.
+    """
+    if isinstance(obj, (bool, np.bool_)):
+        return AttributeType.BOOLEAN
+    if isinstance(obj, (int, float, np.number)):
+        return AttributeType.NUMERIC
+    if isinstance(obj, str):
+        return AttributeType.STRING
+    return AttributeType.OBJECT
+
+
+def python_type_to_igraph_attribute_type(obj: Type[Any]) -> AttributeType:
+    """Converts the given Python type into the most fitting igraph attribute
+    type.
+    """
+    if issubclass(obj, (bool, np.bool_)):
+        return AttributeType.BOOLEAN
+    if issubclass(obj, (int, float, np.number)):
+        return AttributeType.NUMERIC
+    if issubclass(obj, str):
+        return AttributeType.STRING
+    return AttributeType.OBJECT

src/igraph_ctypes/_internal/attributes/value_list.py

@@ -11,14 +11,17 @@
     NoReturn,
     Sequence,
     Sized,
+    Type,
     TypeVar,
+    Union,
     overload,
 )
 
 from .enums import AttributeType
 from .utils import (
-    get_igraph_attribute_type_from_iterable,
+    iterable_to_igraph_attribute_type,
     igraph_to_numpy_attribute_type,
+    python_type_to_igraph_attribute_type,
 )
 
 __all__ = ("AttributeValueList",)
@@ -126,18 +129,43 @@ def __init__(
                 type = (
                     AttributeType.NUMERIC
                     if items is None
-                    else get_igraph_attribute_type_from_iterable(items)
+                    else iterable_to_igraph_attribute_type(items)
                 )
 
             dtype = igraph_to_numpy_attribute_type(type)
             array = np.fromiter(items if items is not None else (), dtype=dtype)
 
+        self._fixed_length = bool(fixed_length)
+
         # Now we have a NumPy array, but what we actually want is a chunk of
         # memory that we manage ourselves, and a NumPy view on top of it
+        self._init_with_array(array, type)
+
+    def _init_with_array(self, array: NDArray, type: AttributeType):
         self._buffer = array
         self._items = self._buffer[:]
         self._type = type
-        self._fixed_length = bool(fixed_length)
+
+    def cast(self, new_type: Union[AttributeType, Type]) -> None:
+        """Converts the type of the attribute represented by this list to the
+        given type.
+
+        Args:
+            new_type: the new type of the attribute. May be an igraph
+                AttributeType_ or a Python type. Python types will be
+                converted to their equivalent igraph attribute types.
+        """
+        if not isinstance(new_type, AttributeType):
+            new_type = python_type_to_igraph_attribute_type(new_type)
+
+        numpy_type = igraph_to_numpy_attribute_type(new_type)
+        if new_type is AttributeType.STRING and self._type is not AttributeType.STRING:
+            # Requires special treatment because AttributeType.STRING is
+            # np.object_ so no conversion would happen by default
+            new_array = np.array([str(x) for x in self._items], dtype=numpy_type)
+        else:
+            new_array = self._items.astype(numpy_type)
+        self._init_with_array(new_array, new_type)
 
     def compact(self) -> None:
         """Compacts the list in-place, reclaiming any memory that was used
@@ -208,9 +236,7 @@ def __delitem__(self, index: IndexLike) -> None:  # noqa: C901
                 ):
                     del self[...]
                 else:
-                    tmp = np.delete(self._items, index)
-                    self._buffer = tmp
-                    self._items = self._buffer[:]
+                    self._init_with_array(np.delete(self._items, index), self._type)
                 return
 
         elif hasattr(index, "__getitem__"):
@@ -220,8 +246,7 @@ def __delitem__(self, index: IndexLike) -> None:  # noqa: C901
 
             tmp = np.delete(self._items, index)  # type: ignore
             if not self.fixed_length:
-                self._buffer = tmp
-                self._items = self._buffer[:]
+                self._init_with_array(tmp, self._type)
                 return
             else:
                 # Try to delete anyway, check if the length remains the same

src/igraph_ctypes/_internal/conversion.py

@@ -9,6 +9,7 @@
 from os import strerror
 from typing import Any, IO, Iterable, Iterator, Optional, Sequence, TYPE_CHECKING
 
+from .attributes.utils import python_type_to_igraph_attribute_type
 from .enums import MatrixStorage
 from .lib import (
     fdopen,
@@ -129,6 +130,7 @@
     "iterable_to_igraph_vector_t",
     "iterable_to_igraph_vector_t_view",
     "iterable_vertex_indices_to_igraph_vector_int_t",
+    "python_type_to_igraph_attribute_type",
     "sequence_to_igraph_matrix_int_t",
     "sequence_to_igraph_matrix_int_t_view",
     "sequence_to_igraph_matrix_t",

tests/test_utils.py tests/test_attribute_utils.pytests/test_utils.py renamed to tests/test_attribute_utils.py

@@ -1,18 +1,54 @@
-from numpy import inf, nan, object_
+from numpy import inf, nan, bool_, int_, object_
 
 from igraph_ctypes._internal.enums import AttributeType
 from igraph_ctypes._internal.types import (
     np_type_of_igraph_bool_t,
     np_type_of_igraph_real_t,
 )
 from igraph_ctypes._internal.attributes.utils import (
-    get_igraph_attribute_type_from_iterable,
-    get_numpy_attribute_type_from_iterable,
+    iterable_to_igraph_attribute_type,
+    iterable_to_numpy_attribute_type,
+    python_object_to_igraph_attribute_type,
+    python_type_to_igraph_attribute_type,
 )
 
 from pytest import mark
 
 
+@mark.parametrize(
+    ("input", "expected"),
+    [
+        (42, AttributeType.NUMERIC),
+        (42.0, AttributeType.NUMERIC),
+        (True, AttributeType.BOOLEAN),
+        ("42", AttributeType.STRING),
+        ([42], AttributeType.OBJECT),
+        (int_(42), AttributeType.NUMERIC),
+        (bool_(True), AttributeType.BOOLEAN),
+        (None, AttributeType.OBJECT),
+    ],
+)
+def test_python_object_to_igraph_attribute_type(input, expected):
+    assert python_object_to_igraph_attribute_type(input) == expected
+
+
+@mark.parametrize(
+    ("input", "expected"),
+    [
+        (int, AttributeType.NUMERIC),
+        (float, AttributeType.NUMERIC),
+        (bool, AttributeType.BOOLEAN),
+        (str, AttributeType.STRING),
+        (object, AttributeType.OBJECT),
+        (int_, AttributeType.NUMERIC),
+        (bool_, AttributeType.BOOLEAN),
+        (object_, AttributeType.OBJECT),
+    ],
+)
+def test_python_type_to_igraph_attribute_type(input, expected):
+    assert python_type_to_igraph_attribute_type(input) == expected
+
+
 @mark.parametrize(
     ("input", "expected"),
     [
@@ -32,7 +68,7 @@
     ],
 )
 def test_conversion_from_python_to_numpy_array_type(input, expected):
-    assert get_numpy_attribute_type_from_iterable(input) == expected
+    assert iterable_to_numpy_attribute_type(input) == expected
 
 
 @mark.parametrize(
@@ -54,4 +90,4 @@ def test_conversion_from_python_to_numpy_array_type(input, expected):
     ],
 )
 def test_conversion_from_python_to_igraph_attribute_type(input, expected):
-    assert get_igraph_attribute_type_from_iterable(input) == expected
+    assert iterable_to_igraph_attribute_type(input) == expected

tests/test_attribute_value_list.py

@@ -396,3 +396,21 @@ def test_type_getter():
 
     items = AVL(["foo", "bar", False, 42])
     assert items.type == AttributeType.OBJECT
+
+
+def test_casting():
+    items = AVL([0, 1, 2, 0, 4])
+    items.cast(bool)
+
+    assert items.type == AttributeType.BOOLEAN
+    assert list(items) == [False, True, True, False, True]
+
+    items.cast(str)
+
+    assert items.type == AttributeType.STRING
+    assert list(items) == ["False", "True", "True", "False", "True"]
+
+    items.cast(object)
+
+    assert items.type == AttributeType.OBJECT
+    assert list(items) == ["False", "True", "True", "False", "True"]

tests/test_conversion.py

@@ -3,6 +3,7 @@
 from numpy import array
 
 from igraph_ctypes.constructors import create_empty_graph
+from igraph_ctypes.enums import EdgeSequenceType, VertexSequenceType
 from igraph_ctypes._internal.conversion import (
     any_to_igraph_bool_t,
     edgelike_to_igraph_integer_t,
@@ -30,7 +31,6 @@
     vertexlike_to_igraph_integer_t,
     vertex_selector_to_igraph_vs_t,
 )
-from igraph_ctypes._internal.enums import EdgeSequenceType, VertexSequenceType
 from igraph_ctypes._internal.types import igraph_bool_t, igraph_integer_t
 from igraph_ctypes._internal.wrappers import (
     _Matrix,

tests/test_write_graph.py

@@ -11,6 +11,15 @@ def simple_graph():
     return g
 
 
+@fixture
+def graph_with_attributes():
+    g = create_graph_from_edge_list(
+        [0, 1, 0, 2, 2, 3, 3, 4, 4, 2, 2, 5, 5, 0, 6, 3, 5, 6], directed=False
+    )
+    g.attrs["date"] = "2009-01-10"
+    return g
+
+
 def test_write_graph_edgelist(simple_graph, tmp_path, datadir):
     path: Path = tmp_path / "edges.txt"
     expected = (datadir / "simple_graph.txt").read_text()