black. remove bispy/api, move content to bispy/__init__

Author: fandreuz

bispy/__init__.py

@@ -14,9 +14,41 @@
     to_tuple_list,
 )
 
-from .api.api import (
-    MaxBisimAlgorithm,
-    find_max_bisimulation,
-    saha_iter,
-    total_saha,
-)
+
+class Algorithms(Enum):
+    PaigeTarjan = auto()
+    DovierPiazzaPolicriti = auto()
+
+
+def compute_maximum_bisimulation(
+    graph: nx.DiGraph,
+    initial_partition,
+    algorithm=Algorithm.PaigeTarjan,
+):
+    """Compute the maximum bisimulation of the given graph, possibly using
+    an initial partition (or labeling set). The preferred algorithm may be
+    chosen as well (*Paige-Tarjan* or *Dovier-Piazza-Policriti*).
+
+    Example:
+        >>> import networkx as nx
+        >>> from bispy import compute_maximum_bisimulation, Algorithms
+        >>> graph = nx.balanced_tree(2,3, create_using=nx.DiGraph)
+        >>> compute_maximum_bisimulation(graph)
+        [(3, 4, 5, 6), (7, 8, 9, 10, 11, 12, 13, 14), (1, 2), (0,)]
+        >>> compute_maximum_bisimulation(graph),
+            algorithm=Algorithms.DovierPiazzaPolicriti)
+        [(3, 5, 6), (7, 8, 9, 10, 11, 12, 13, 14), (0,), (2,), (1,), (4,)]
+
+    :param graph: The input graph.
+    :param initial_partition: A partition of the set of nodes of the graph,
+        two nodes in different blocks of this partition cannot be bisimilar.
+        Defaults to the trivial initial partition.
+    :param algorithm: The algorithm used to compute the maximum bisimulation.
+    :returns: The maximum bisimulation of the given graph, with the given
+        initial partition.
+    """
+
+    if algorithm == Algorithms.PaigeTarjan:
+        return paige_tarjan(graph, initial_partition)
+    elif algorithm == Algorithms.DovierPiazzaPolicriti:
+        return dovier_piazza_policriti(graph, initial_partition)

bispy/api/__init__.py

@@ -93,7 +93,8 @@ def split_upper_ranks(partition: RankedPartition, block: _Block):
         # if this is an upper-rank node with respect to the collapsed block, we
         # need to split. the split is not needed if the block is a singoletto.
         if vertex.rank > block.rank and not (
-            vertex.qblock.split_helper_block is None and vertex.qblock.size <= 1
+            vertex.qblock.split_helper_block is None
+            and vertex.qblock.size <= 1
         ):
             # if needed, create the aux block to help during the splitting
             # phase

bispy/api/api.py

@@ -85,7 +85,9 @@ def append_at_rank(self, block: _Block, rank: Union[int, float]):
         :param rank: The input rank.
         """
 
-        self.append_at_index(block, RankedPartition.rank_to_partition_idx(rank))
+        self.append_at_index(
+            block, RankedPartition.rank_to_partition_idx(rank)
+        )
 
     def append_at_index(self, block, index: int):
         """Append a new block in the `index`-th class.

bispy/dovier_piazza_policriti/dovier_piazza_policriti.py

@@ -324,7 +324,8 @@ def paige_tarjan_qblocks(q_partition: List[_QBlock]) -> List[_QBlock]:
         q_partition.extend(new_qblocks)
 
     return [
-        qblock for qblock in filter(lambda qblock: qblock.size > 0, q_partition)
+        qblock
+        for qblock in filter(lambda qblock: qblock.size > 0, q_partition)
     ]
 
 

bispy/dovier_piazza_policriti/ranked_partition.py

@@ -12,7 +12,9 @@ def __init__(self, compound_xblocks, max_rank):
             first_nonempty_index = -1
 
         for compound_xblock in compound_xblocks:
-            rank = compound_xblock.qblocks.first.value.vertexes.first.value.rank
+            rank = (
+                compound_xblock.qblocks.first.value.vertexes.first.value.rank
+            )
             if rank == float("-inf"):
                 self._xblocks[0].append(compound_xblock)
                 first_nonempty_index = 0
@@ -39,7 +41,9 @@ def update_first_nonempty_index(self):
     def append_at_rank(self, xblock, rank):
         rank_index = 0 if rank == float("-inf") else rank + 1
         self._xblocks[rank_index].append(xblock)
-        self._first_nonempty_index = min(self._first_nonempty_index, rank_index)
+        self._first_nonempty_index = min(
+            self._first_nonempty_index, rank_index
+        )
 
     def append(self, xblock):
         self.append_at_rank(xblock, xblock.qblocks.first.value.rank)

bispy/paige_tarjan/paige_tarjan.py

@@ -806,7 +806,9 @@ def saha(
                         if source_vertex.rank < destination_vertex.rank:
                             source_vertex.rank = destination_vertex.rank
 
-                            propagate_nwf(source_vertex.scc, scc_finishing_time)
+                            propagate_nwf(
+                                source_vertex.scc, scc_finishing_time
+                            )
                 else:
                     if source_vertex.rank < destination_vertex.rank:
                         source_vertex.rank = destination_vertex.rank

bispy/saha/ranked_compound_xblocks_container.py

@@ -62,6 +62,26 @@ def add_edge(
             else:
                 return back_to_original(max_bisi, self.node_to_idx)
 
+    def add_edges(
+        self, edges: List[Tuple[Any, Any]], verbose: bool = True
+    ) -> Union[None, List[Tuple[Any]]]:
+        """Add multiple edges and compute the maximum bisimulation
+        incrementally.
+
+        :param edges: A list of edges, represented by 2-tuples.
+        :param verbose: If `True`, the maximum bisimulation will be returned
+            after the last iteration. Otherwise the method returns `None`.
+            Defaults to `True`.
+        :return: The maximim bisimulation after the addition of the last edge
+            if `verbose` is `True`.
+        """
+
+        for idx, edge in enumerate(edges):
+            if idx == len(edges) - 1 and verbose:
+                return self.add_edge(edge)
+            else:
+                self.add_edge(edge, verbose=False)
+
 
 def saha(
     graph, initial_partition=None, is_integer_graph=False

bispy/saha/saha.py

@@ -374,7 +374,9 @@ def decorate_bispy_graph(
                 edge.count.value += 1
 
     if topological_sorted_images:
-        finishing_time_list = compute_counterimage_finishing_time_list(vertexes)
+        finishing_time_list = compute_counterimage_finishing_time_list(
+            vertexes
+        )
         build_vertexes_image(finishing_time_list)
 
     if compute_rank: