feat: first (nonfunctional) prototype of an attribute handler

Author: ntamas

src/codegen/run.py

@@ -123,6 +123,7 @@ def generate_enums(  # noqa: C901
         "Degseq": "DegreeSequenceMode",
         "EdgeorderType": "EdgeOrder",
         "EitType": "EdgeIteratorType",
+        "ErrorType": "ErrorCode",
         "EsType": "EdgeSequenceType",
         "FasAlgorithm": "FeedbackArcSetAlgorithm",
         "FileformatType": "FileFormat",

src/igraph_ctypes/_internal/attributes.py

@@ -1,5 +1,17 @@
-from ctypes import c_char_p, c_int, c_void_p, CFUNCTYPE, POINTER, Structure
+from ctypes import (
+    c_char_p,
+    c_int,
+    c_void_p,
+    pointer,
+    py_object,
+    CFUNCTYPE,
+    POINTER,
+    Structure,
+)
+from dataclasses import dataclass, field, replace
+from typing import Any, Callable, Dict, Optional
 
+from .refcount import incref, decref, refcount
 from .types import (
     igraph_bool_t,
     igraph_error_t,
@@ -14,6 +26,9 @@
     igraph_vector_t,
     igraph_vs_t,
 )
+from .utils import protect
+
+__all__ = ("AttributeHandlerBase", "DictAttributeHandler")
 
 
 p_igraph_t = POINTER(igraph_t)
@@ -94,26 +109,32 @@ class igraph_attribute_table_t(Structure):
         "get_type": CFUNCTYPE(
             igraph_error_t, p_igraph_t, POINTER(c_int), c_int, c_char_p
         ),
-        "get_numeric_graph_attr": CFUNCTYPE(p_igraph_t, c_char_p, p_vector_t),
-        "get_string_graph_attr": CFUNCTYPE(p_igraph_t, c_char_p, p_strvector_t),
-        "get_bool_graph_attr": CFUNCTYPE(p_igraph_t, c_char_p, p_vector_bool_t),
+        "get_numeric_graph_attr": CFUNCTYPE(
+            igraph_error_t, p_igraph_t, c_char_p, p_vector_t
+        ),
+        "get_string_graph_attr": CFUNCTYPE(
+            igraph_error_t, p_igraph_t, c_char_p, p_strvector_t
+        ),
+        "get_bool_graph_attr": CFUNCTYPE(
+            igraph_error_t, p_igraph_t, c_char_p, p_vector_bool_t
+        ),
         "get_numeric_vertex_attr": CFUNCTYPE(
-            p_igraph_t, c_char_p, igraph_vs_t, p_vector_t
+            igraph_error_t, p_igraph_t, c_char_p, igraph_vs_t, p_vector_t
         ),
         "get_string_vertex_attr": CFUNCTYPE(
-            p_igraph_t, c_char_p, igraph_vs_t, p_strvector_t
+            igraph_error_t, p_igraph_t, c_char_p, igraph_vs_t, p_strvector_t
         ),
         "get_bool_vertex_attr": CFUNCTYPE(
-            p_igraph_t, c_char_p, igraph_vs_t, p_vector_bool_t
+            igraph_error_t, p_igraph_t, c_char_p, igraph_vs_t, p_vector_bool_t
         ),
         "get_numeric_edge_attr": CFUNCTYPE(
-            p_igraph_t, c_char_p, igraph_es_t, p_vector_t
+            igraph_error_t, p_igraph_t, c_char_p, igraph_es_t, p_vector_t
         ),
         "get_string_edge_attr": CFUNCTYPE(
-            p_igraph_t, c_char_p, igraph_es_t, p_strvector_t
+            igraph_error_t, p_igraph_t, c_char_p, igraph_es_t, p_strvector_t
         ),
         "get_bool_edge_attr": CFUNCTYPE(
-            p_igraph_t, c_char_p, igraph_es_t, p_vector_bool_t
+            igraph_error_t, p_igraph_t, c_char_p, igraph_es_t, p_vector_bool_t
         ),
     }
 
@@ -139,3 +160,186 @@ class igraph_attribute_table_t(Structure):
         ("get_string_edge_attr", TYPES["get_string_edge_attr"]),
         ("get_bool_edge_attr", TYPES["get_bool_edge_attr"]),
     ]
+
+
+################################################################################
+
+
+class AttributeHandlerBase:
+    """Base class for igraph attribute handlers."""
+
+    _table: Optional[igraph_attribute_table_t] = None
+    _table_ptr = None
+
+    def _get_attribute_handler_functions(self) -> Dict[str, Callable]:
+        """Returns an ``igraph_attribute_table_t`` instance that can be used
+        to register this attribute handler in the core igraph library.
+        """
+        return {
+            key: igraph_attribute_table_t.TYPES[key](
+                protect(getattr(self, key, self._nop))
+            )
+            for key in igraph_attribute_table_t.TYPES.keys()
+        }
+
+    @property
+    def _as_parameter_(self):
+        if self._table_ptr is None:
+            self._table = igraph_attribute_table_t(
+                **self._get_attribute_handler_functions()
+            )
+            self._table_ptr = pointer(self._table)
+        return self._table_ptr
+
+    @staticmethod
+    def _nop():
+        pass
+
+
+@dataclass(frozen=True)
+class _DictAttributeStorage:
+    """Dictionary-based storage area for the graph, vertex and edge attributes
+    of a graph.
+    """
+
+    graph_attributes: Dict[str, Any] = field(default_factory=dict)
+    vertex_attributes: Dict[str, Any] = field(default_factory=dict)
+    edge_attributes: Dict[str, Any] = field(default_factory=dict)
+
+    def clear(self) -> None:
+        """Clears the storage area, removing all attributes from the
+        attribute dictionaries.
+        """
+        self.graph_attributes.clear()
+        self.vertex_attributes.clear()
+        self.edge_attributes.clear()
+
+    def copy(
+        self,
+        copy_graph_attributes: bool = True,
+        copy_vertex_attributes: bool = True,
+        copy_edge_attributes: bool = True,
+    ):
+        """Creates a shallow copy of the storage area."""
+        return self.__class__(
+            self.graph_attributes.copy() if copy_graph_attributes else {},
+            self.vertex_attributes.copy() if copy_vertex_attributes else {},
+            self.edge_attributes.copy() if copy_edge_attributes else {},
+        )
+
+
+_MISSING = object()
+
+
+def _assign_storage_to_graph(graph, storage: Any = _MISSING):
+    """Assigns an attribute storage object to a graph, taking care of
+    increasing or decreasing the reference count of the storage object if needed.
+    """
+    try:
+        old_storage = graph.contents.attr
+    except ValueError:
+        # No storage yet, this is OK
+        old_storage = _MISSING
+
+    if old_storage is storage:
+        # Nothing to do
+        return
+
+    if old_storage is not _MISSING:
+        decref(old_storage)
+
+    if storage is not _MISSING:
+        graph.contents.attr = py_object(incref(storage))
+    else:
+        graph.contents.attr = py_object()
+
+
+def _detach_storage_from_graph(graph):
+    return _assign_storage_to_graph(graph, _MISSING)
+
+
+class DictAttributeHandler(AttributeHandlerBase):
+    """Attribute handler implementation that stores graph, vertex and edge
+    attributes in dictionaries.
+    """
+
+    def init(self, graph, attr):
+        _assign_storage_to_graph(graph, _DictAttributeStorage())
+
+    def destroy(self, graph) -> None:
+        storage: _DictAttributeStorage = graph.contents.attr
+        storage.clear()
+        _detach_storage_from_graph(graph)
+
+    def copy(
+        self,
+        to,
+        graph,
+        copy_graph_attributes: bool,
+        copy_vertex_attributes: bool,
+        copy_edge_attributes: bool,
+    ):
+        try:
+            storage = incref(
+                graph.contents.attr.copy(
+                    copy_graph_attributes, copy_vertex_attributes, copy_edge_attributes
+                )
+            )
+            to.contents.attr = py_object(storage)
+        except Exception as ex:
+            print(repr(ex))
+            raise
+
+    def add_vertices(self, graph, n: int, attr) -> None:
+        pass
+
+    def permute_vertices(self, graph, to, mapping):
+        pass
+
+    def combine_vertices(self, graph, to, mapping, combinations):
+        pass
+
+    def add_edges(self, graph, edges, attr) -> None:
+        pass
+
+    def permute_edges(self, graph, to, mapping):
+        pass
+
+    def combine_edges(self, graph, to, mapping, combinations):
+        pass
+
+    def get_info(self, graph, gnames, gtypes, vnames, vtypes, enames, etypes):
+        pass
+
+    def has_attr(self, graph, type, name) -> bool:
+        return False
+
+    def get_type(self, graph, type, elemtype, name):
+        pass
+
+    def get_numeric_graph_attr(self, graph, name, value):
+        pass
+
+    def get_string_graph_attr(self, graph, name, value):
+        pass
+
+    def get_boolean_graph_attr(self, graph, name, value):
+        pass
+
+    def get_numeric_vertex_attr(self, graph, name, vs, value):
+        pass
+
+    def get_string_vertex_attr(self, graph, name, vs, value):
+        pass
+
+    def get_boolean_vertex_attr(self, graph, name, vs, value):
+        pass
+
+    def get_numeric_edge_attr(self, graph, name, es, value):
+        pass
+
+    def get_string_edge_attr(self, graph, name, es, value):
+        pass
+
+    def get_boolean_edge_attr(self, graph, name, es, value):
+        pass

src/igraph_ctypes/_internal/enums.py

@@ -414,7 +414,7 @@ class MatrixStorage(IntEnum):
     COLUMN_MAJOR = 1
 
 
-class ErrorType(IntEnum):
+class ErrorCode(IntEnum):
     """Python counterpart of an ``igraph_error_type_t`` enum."""
 
     SUCCESS = 0
@@ -559,7 +559,7 @@ class LeadingEigenvectorCommunityHistory(IntEnum):
     'EdgeSequenceType',
     'EigenAlgorithm',
     'ErdosRenyi',
-    'ErrorType',
+    'ErrorCode',
     'FeedbackArcSetAlgorithm',
     'FileFormat',
     'FloydWarshallAlgorithm',

src/igraph_ctypes/_internal/errors.py

@@ -1,3 +1,6 @@
+from typing import Optional, Type, Union
+
+from .enums import ErrorCode
 from .types import igraph_error_t
 
 __all__ = ("handle_igraph_error_t",)
@@ -11,7 +14,46 @@ def handle_igraph_error_t(code: igraph_error_t) -> None:
         error_state = _get_last_error_state()
         if error_state:
             error_state.raise_error()
-        elif code == 13:  # IGRAPH_INTERRUPTED; does not call error handler
+        elif code == ErrorCode.INTERRUPTED:
             raise KeyboardInterrupt
         else:
             raise RuntimeError(f"igraph returned error code {code}")
+
+
+def igraph_error_t_to_python_exception_class(code: int) -> Optional[Type[Exception]]:
+    """Converts an igraph error code into an appropriate Python exception class.
+
+    See `python_exception_to_igraph_error_t()` for the reverse operation.
+    """
+    if code == 0:
+        return None
+    elif code == ErrorCode.UNIMPLEMENTED:
+        return NotImplementedError
+    elif code == ErrorCode.ENOMEM:
+        return MemoryError
+    else:
+        return RuntimeError
+
+
+def python_exception_to_igraph_error_t(
+    exc: Optional[Union[Exception, Type[Exception]]]
+) -> int:
+    """Converts a Python exception class into an appropriate igraph error code.
+
+    See `igraph_error_t_to_python_exception_class()` for the reverse operation.
+    """
+    # TODO(ntamas): more sophisticated conversion, preserving the
+    # exception message if possible?
+
+    if exc is None:
+        return 0
+
+    if isinstance(exc, Exception):
+        exc = exc.__class__
+
+    if issubclass(exc, NotImplementedError):
+        return ErrorCode.UNIMPLEMENTED
+    elif issubclass(exc, MemoryError):
+        return ErrorCode.ENOMEM
+    else:
+        return ErrorCode.FAILURE

src/igraph_ctypes/_internal/functions.py

@@ -3604,7 +3604,7 @@ def bipartite_game_gnp(n1: int, n2: int, p: float, directed: bool = False, mode:
     return graph, types
 
 
-def bipartite_game_gnm(n1: int, n2: int, m: int, directed: bool = False, mode: NeighborMode = NeighborMode.ALL) -> Tuple[Graph, BoolArray]:
+def bipartite_game_gnm(n1: int, n2: int, m: int, directed: bool = False, mode: NeighborMode = NeighborMode.ALL, multiple: bool = False) -> Tuple[Graph, BoolArray]:
     """Type-annotated wrapper for ``igraph_bipartite_game_gnm``."""
     # Prepare input arguments
     c_graph = _Graph()
@@ -3614,9 +3614,10 @@ def bipartite_game_gnm(n1: int, n2: int, m: int, directed: bool = False, mode: N
     c_m = m
     c_directed = any_to_igraph_bool_t(directed)
     c_mode = c_int(mode)
+    c_multiple = any_to_igraph_bool_t(multiple)
 
     # Call wrapped function
-    igraph_bipartite_game_gnm(c_graph, c_types, c_n1, c_n2, c_m, c_directed, c_mode)
+    igraph_bipartite_game_gnm(c_graph, c_types, c_n1, c_n2, c_m, c_directed, c_mode, c_multiple)
 
     # Prepare output arguments
     graph = _create_graph_from_boxed(c_graph)

src/igraph_ctypes/_internal/lib.py

@@ -1293,7 +1293,7 @@ def _load_igraph_c_library():
 
 igraph_bipartite_game_gnm = _lib.igraph_bipartite_game_gnm
 igraph_bipartite_game_gnm.restype = handle_igraph_error_t
-igraph_bipartite_game_gnm.argtypes = [POINTER(igraph_t), POINTER(igraph_vector_bool_t), igraph_integer_t, igraph_integer_t, igraph_integer_t, igraph_bool_t, igraph_neimode_t]
+igraph_bipartite_game_gnm.argtypes = [POINTER(igraph_t), POINTER(igraph_vector_bool_t), igraph_integer_t, igraph_integer_t, igraph_integer_t, igraph_bool_t, igraph_neimode_t, igraph_bool_t]
 
 igraph_bipartite_game = _lib.igraph_bipartite_game
 igraph_bipartite_game.restype = handle_igraph_error_t