feat: first prototype of edge attribute combinations that works

Author: ntamas

src/codegen/internal_lib.py.in

@@ -34,7 +34,6 @@ from .types import (
     igraph_bliss_info_t,
     igraph_error_handler_t,
     igraph_fatal_handler_t,
-    igraph_function_pointer_t,
     igraph_hrg_t,
     igraph_layout_drl_options_t,
     igraph_maxflow_stats_t,
@@ -546,11 +545,11 @@ igraph_attribute_combination_destroy.argtypes = [POINTER(igraph_attribute_combin
 
 igraph_attribute_combination_add = _lib.igraph_attribute_combination_add
 igraph_attribute_combination_add.restype = handle_igraph_error_t
-igraph_attribute_combination_add.argtypes = [POINTER(igraph_attribute_combination_t), c_char_p, c_int, igraph_function_pointer_t]
+igraph_attribute_combination_add.argtypes = [POINTER(igraph_attribute_combination_t), c_char_p, c_int, c_void_p]
 
 igraph_attribute_combination_query = _lib.igraph_attribute_combination_query
 igraph_attribute_combination_query.restype = handle_igraph_error_t
-igraph_attribute_combination_query.argtypes = [POINTER(igraph_attribute_combination_t), c_char_p, POINTER(c_int), POINTER(igraph_function_pointer_t)]
+igraph_attribute_combination_query.argtypes = [POINTER(igraph_attribute_combination_t), c_char_p, POINTER(c_int), POINTER(c_void_p)]
 
 # Error handling and interruptions
 

src/codegen/run.py

@@ -353,6 +353,8 @@ def main():
         SOURCE_FOLDER / "igraph_ctypes" / "types.py",
         "._internal.types",
         match=(
+            "AttributeCombinationSpecification",
+            "AttributeCombinationSpecificationEntry",
             "BoolArray",
             "EdgeLike",
             "EdgeSelector",

src/igraph_ctypes/_internal/attributes/combinations.py

@@ -0,0 +1,165 @@
+from ctypes import c_void_p
+from numpy import mean, median
+from typing import Any, Callable, Iterable
+
+from igraph_ctypes._internal.enums import AttributeCombinationType, AttributeType
+from igraph_ctypes._internal.types import IntArray
+
+from .value_list import AttributeValueList
+
+
+Handler = Callable[[AttributeValueList, list[IntArray], c_void_p], Iterable[Any] | None]
+
+
+def apply_attribute_combinations(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_type: int,
+    comb_func: c_void_p,
+) -> Iterable[Any] | None:
+    """Applies an igraph attribute combination specification entry to a
+    vector of attributes.
+
+    Args:
+        values: an attribute value list from the old graph where the entries have
+            to be combined into a new atribute value list
+        mapping: list of integer arrays where the i-th entry lists the indices
+            from the values array that are to be merged into the i-th entry of
+            the returned value list
+        comb_type: type of attribute combination to apply; one of the constants
+            from the AttributeCombinationType_ enum
+        comb_func: pointer to a Python function to invoke for custom, user-defined
+            attribute combinations (i.e. when comb_type is equal to
+            `AttributeCombinationType.FUNCTION`)
+
+    Returns:
+        an iterable of the combined values or `None` if the values should be ignored
+        (i.e. when `comb_type` is `AttributeCombinationType.IGNORE`)
+    """
+    if comb_type == AttributeCombinationType.IGNORE:
+        return None
+
+    try:
+        handler = _handlers[comb_type]
+    except IndexError:
+        handler = _combine_ignore
+
+    return handler(values, mapping, comb_func)
+
+
+def _combine_ignore(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> None:
+    return None
+
+
+def _combine_with_function(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> None:
+    raise NotImplementedError  # TODO(ntamas)
+
+
+def _combine_sum(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    return (values[item].sum() for item in mapping)
+
+
+def _combine_prod(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    return (values[item].prod() for item in mapping)
+
+
+def _combine_min(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    return (values[item].min() for item in mapping)
+
+
+def _combine_max(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    return (values[item].min() for item in mapping)
+
+
+def _combine_random(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    raise NotImplementedError  # TODO(ntamas)
+
+
+def _combine_first(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    indices = [item[0] for item in mapping]
+    return values[indices]
+
+
+def _combine_last(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    indices = [item[-1] for item in mapping]
+    return values[indices]
+
+
+def _combine_mean(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    return (mean(values[item]) for item in mapping)
+
+
+def _combine_median(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    return (median(values[item]) for item in mapping)
+
+
+def _combine_concat(
+    values: AttributeValueList,
+    mapping: list[IntArray],
+    comb_func: c_void_p,
+) -> Iterable[Any]:
+    if values.type != AttributeType.STRING:
+        raise TypeError(f"cannot concatenate attributes of type {values.type}")
+    return ("".join(values[item]) for item in mapping)
+
+
+_handlers: list[Handler] = [
+    _combine_ignore,
+    _combine_first,
+    _combine_with_function,
+    _combine_sum,
+    _combine_prod,
+    _combine_min,
+    _combine_max,
+    _combine_random,
+    _combine_first,
+    _combine_last,
+    _combine_mean,
+    _combine_median,
+    _combine_concat,
+]
+"""Table of attribute combination handler functions."""

src/igraph_ctypes/_internal/attributes/handler.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
-from ctypes import cast, pointer, c_void_p
+from ctypes import cast, c_int, pointer, c_void_p
 from math import nan
 from typing import Any, Callable, Optional, TYPE_CHECKING
 
 from igraph_ctypes._internal.conversion import (
     igraph_vector_int_t_to_numpy_array_view,
+    igraph_vector_int_list_t_to_list_of_numpy_array_view,
     numpy_array_to_igraph_vector_bool_t_view,
     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_attribute_combination_query,
     igraph_error,
     igraph_es_as_vector,
     igraph_vector_resize,
@@ -34,6 +36,7 @@
 )
 from igraph_ctypes._internal.utils import nop, protect_with, protect_with_default
 
+from .combinations import apply_attribute_combinations
 from .storage import (
     DictAttributeStorage,
     assign_storage_to_graph,
@@ -193,6 +196,28 @@ def permute_edges(self, graph, to, mapping):
     def combine_edges(self, graph, to, mapping, combinations):
         assert not _are_pointers_equal(graph, to)
 
+        mapping_arrays = igraph_vector_int_list_t_to_list_of_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()
+
+        for name, values in old_attrs.items():
+            comb_type = c_int()
+            comb_func = c_void_p()
+
+            igraph_attribute_combination_query(
+                combinations,
+                name.encode("utf-8"),
+                comb_type,
+                comb_func,
+            )
+
+            new_values = apply_attribute_combinations(
+                values, mapping_arrays, comb_type.value, comb_func
+            )
+            if new_values is not None:
+                new_attrs.set(name, new_values, type=values.type, _check_length=False)
+
     def get_info(self, graph, gnames, gtypes, vnames, vtypes, enames, etypes):
         storage = get_storage_from_graph(graph)
 

src/igraph_ctypes/_internal/attributes/map.py

@@ -1,6 +1,7 @@
 from collections.abc import MutableMapping
 from typing import Iterable, Iterator, TypeVar
 
+from .enums import AttributeType
 from .value_list import AttributeValueList
 
 __all__ = ("AttributeMap",)
@@ -62,6 +63,7 @@ def set(
         self,
         key: str,
         value: T | Iterable[T],
+        type: AttributeType | None = None,
         _check_length: bool = True,
     ) -> None:
         """Assigns a value to _all_ the attribute values corresponding to the
@@ -85,12 +87,12 @@ def set(
         if isinstance(value, (bytes, str)):
             # strings and bytes are iterable but they are treated as if not
             avl = AttributeValueList(
-                [value] * length, fixed_length=True
+                [value] * length, type=type, fixed_length=True
             )  # type: ignore
         elif isinstance(value, Iterable):
             # 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
+            avl = AttributeValueList(value, type=type, fixed_length=True)  # type: ignore
             if _check_length and len(avl) != length:
                 raise RuntimeError(
                     f"attribute value list length must be {length}, got {len(avl)}"
@@ -99,7 +101,7 @@ def set(
             # all other values are assumed to be a common value for all
             # vertices or edges
             avl = AttributeValueList(
-                [value] * length, fixed_length=True
+                [value] * length, type=type, fixed_length=True
             )  # type: ignore
 
         assert avl.fixed_length

src/igraph_ctypes/_internal/attributes/value_list.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from math import ceil
-from numpy.typing import NDArray
+from numpy.typing import DTypeLike, NDArray
 from types import EllipsisType
 from typing import (
     Any,
@@ -112,7 +112,23 @@ def __init__(
         fixed_length: bool = False,
         _wrap: bool = False,
     ):
-        """Constructor."""
+        """Constructor.
+
+        Creates a new attribute value list from an iterable of items.
+
+        The input should typically be a list, tuple, NumPy array or any other
+        iterable. However, if you have an iterable on which you can iterate
+        only _once_, you also need to specify the igraph attribute type
+        explicitly. This is because the constructor will attempt to infer the
+        attribute type if it is not given, but by doing so it will consume the
+        iterable once.
+
+        Args:
+            items: the iterable of items to store in the list
+            type: the igraph attribute type of the attribute that this list
+                will belong to
+            fixed_length: whether the list is fixed-length
+        """
         if _wrap:
             # Special case, not for public use. items is a NumPy array and
             # we can wrap it as is. Must be called only when no one else has
@@ -188,6 +204,11 @@ def fixed_length(self) -> bool:
         """Returns whether the list is fixed-length."""
         return self._fixed_length
 
+    @property
+    def dtype(self) -> DTypeLike:
+        """Returns the NumPy attribute type of this list."""
+        return igraph_to_numpy_attribute_type(self._type)
+
     @property
     def type(self) -> AttributeType:
         """Returns the igraph attribute type of this list."""