Merge pull request smartFCA#30 from EgorDudyrev/fix/bitarray3.0

Update code for the new version of bitarray package (v3.0.0)

Author: EgorDudyrev

caspailleur/base_functions.py

@@ -49,7 +49,7 @@ def extension(description: Union[Iterable[int], bitarray], crosses_per_columns:
         -> Union[set[int], bitarray]:
     """Select the indices of rows described by `description`"""
     column_type = type(crosses_per_columns[0])
-    description = description.itersearch(True) if isinstance(description, bitarray) else description
+    description = description.search(True) if isinstance(description, bitarray) else description
 
     total_extent = column_type(maximal_extent(crosses_per_columns))
     extent = reduce(column_type.__and__, (crosses_per_columns[attr_i] for attr_i in description), total_extent)
@@ -89,7 +89,7 @@ def closure(
     """
     result = intention(extension(description, crosses_per_columns), crosses_per_columns)
     if not isinstance(description, bitarray) and isinstance(result, bitarray):
-        return (i for i in result.itersearch(True))
+        return (i for i in result.search(True))  # convert ba.searchiterator into an interator
     return result
 
 
@@ -105,4 +105,4 @@ def isets2bas(itemsets: Iterable[Iterable[int]], length: int) -> Iterator[fbarra
     --------
     isets2bas([ [0, 1], [1,3,4] ], 5) --> [bitarray('01000'), bitarray('01011')]
     """
-    return io.isets2bas(itemsets, )
+    return io.isets2bas(itemsets, length)

caspailleur/indices.py

@@ -32,7 +32,7 @@ def delta_stability_by_extents(extents: list[fbarray]) -> Iterator[int]:
 def delta_stability_by_description(
         description: Union[Iterable[int], bitarray], crosses_per_columns: list[fbarray], extent: fbarray = None
 ) -> int:
-    description = set(description.itersearch(True)) if isinstance(description, bitarray) else set(description)
+    description = set(description.search(True)) if isinstance(description, bitarray) else set(description)
 
     extent = extension(description, crosses_per_columns) if extent is None else extent
     out_attrs = [(m_i, m_ext) for m_i, m_ext in enumerate(crosses_per_columns) if m_i not in description]
@@ -115,14 +115,13 @@ def distributivity_index(
 
     n_distr = n_trans_parents
 
-    for intent_idx, intent in tqdm(
-            enumerate(intents), total=len(intents),
-            disable=not use_tqdm, desc='enumerate intents'
-    ):
+    intents_iterator = tqdm(enumerate(intents), total=len(intents), disable=not use_tqdm, desc='enumerate intents')
+    for intent_idx, intent in intents_iterator:
         distr_ancestors = deque([
             (mother, father)
-            for mother in parents[intent_idx].itersearch(True) for father in parents[intent_idx].itersearch(True)
-            if mother < father and intents[mother] | intents[father] == intent
+            for mother in parents[intent_idx].search(True)
+            for father in parents[intent_idx].search(True, mother+1)
+            if intents[mother] | intents[father] == intent
         ])
 
         visited_pairs = set()
@@ -138,11 +137,11 @@ def distributivity_index(
             mother_intent, father_intent = intents[mother], intents[father]
 
             distr_ancestors.extend([
-                (mother, gfather) for gfather in parents[father].itersearch(True)
+                (mother, gfather) for gfather in parents[father].search(True)
                 if mother_intent | intents[gfather] == intent
             ])
             distr_ancestors.extend([
-                (gmother, father) for gmother in parents[mother].itersearch(True)
+                (gmother, father) for gmother in parents[mother].search(True)
                 if intents[gmother] | father_intent == intent
             ])
 

caspailleur/io.py

@@ -74,7 +74,7 @@ def bas2isets(bitarrays: Iterable[fbarray]) -> Iterator[FrozenSet[int]]:
     bas2isets([ bitarray('01000'), bitarray('01011') ]) --> [ [0,1], [1,3,4] ]
     """
     for bar in bitarrays:
-        yield frozenset(bar.itersearch(True))
+        yield frozenset(bar.search(True))
 
 
 def to_named_itemsets(data: ContextType) -> NamedItemsetContextType:
@@ -428,7 +428,7 @@ def transpose_context(data: ContextType) -> ContextType:
         n_objs, n_attrs = len(crosses_data), len(crosses_data[0])
         transposed = [bazeros(n_objs) for _ in range(n_attrs)]
         for obj_i, ba in enumerate(crosses_data):
-            for attr_i in ba.itersearch(True):
+            for attr_i in ba.search(True):
                 transposed[attr_i][obj_i] = True
         transposed = list(map(bitarray, transposed))
 
@@ -475,7 +475,7 @@ def identify_supported_context_type(context: ContextType) -> Optional[typing.Typ
 def verbalise(description: Union[bitarray, Iterable[int]], names: list[str]) -> Iterable[str]:
     """Convert every index i (or every True i-th element of a bitarray) into a human-readable string `names[i]`"""
     if isinstance(description, bitarray):
-        return {names[i] for i in description.itersearch(True)}
+        return {names[i] for i in description.search(True)}
 
     if isinstance(description, Generator):
         return (names[i] for i in description)

caspailleur/mine_equivalence_classes.py

@@ -157,7 +157,7 @@ def list_attribute_concepts(intents: list[fbarray]) -> list[int]:
     attr_concepts = [-1] * len(intents[0])
     found_attrs = bazeros(len(intents[0]))
     for intent_i, intent in enumerate(intents):
-        for m in intent.itersearch(True):
+        for m in intent.search(True):
             if attr_concepts[m] == -1:
                 attr_concepts[m] = intent_i
         found_attrs |= intent
@@ -193,7 +193,7 @@ def iter_equivalence_class(attribute_extents: list[fbarray], intent: fbarray = N
 
     total_extent = extension(intent, attribute_extents)
 
-    stack = [[m] for m in intent.itersearch(True)][::-1]
+    stack = [[m] for m in intent.search(True, right=True)]
 
     yield intent
     while stack:
@@ -211,7 +211,7 @@ def iter_equivalence_class(attribute_extents: list[fbarray], intent: fbarray = N
 
         # conj == total_extent
         yield attrs_to_eval
-        stack += [attrs_to_remove+[m] for m in intent.itersearch(True) if m > last_attr][::-1]
+        stack += [attrs_to_remove+[m] for m in intent.search(True, last_attr+1, right=True)]
 
 
 def iter_equivalence_class_levelwise(
@@ -320,7 +320,7 @@ def iter_keys_of_intent(intent: fbarray, attr_extents: list[fbarray], support_su
     support = extent.count()
 
     def subdescriptions(description: fbarray) -> Iterator[fbarray]:
-        return (description & ~single_attrs[m_i] for m_i in description.itersearch(True))
+        return (description & ~single_attrs[m_i] for m_i in description.search(True))
 
     key_candidates = deque([intent])
     while key_candidates:
@@ -385,7 +385,7 @@ def list_keys(intents: list[fbarray], only_passkeys: bool = False) -> dict[fbarr
     n_attrs, n_intents = len(intents[-1]), len(intents)
     attrs_descendants = [bazeros(n_intents) for _ in range(n_attrs)]
     for intent_i, intent in enumerate(intents):
-        for m in intent.itersearch(True):
+        for m in intent.search(True):
             attrs_descendants[m][intent_i] = True
 
     # assuming that every subset of a key is a key => extending not-a-key cannot result in a key
@@ -400,13 +400,13 @@ def list_keys(intents: list[fbarray], only_passkeys: bool = False) -> dict[fbarr
     attrs_to_test = deque([m_ba for m_ba in single_attrs])
     while attrs_to_test:
         attrs = attrs_to_test.popleft()
-        attrs_indices = list(attrs.itersearch(True))
+        attrs_indices = list(attrs.search(True))
 
         if any(attrs & (~single_attrs[m]) not in keys_dict for m in attrs_indices):
             continue
 
         common_descendants = ~bazeros(n_intents)
-        for m in attrs.itersearch(True):
+        for m in attrs.search(True):
             common_descendants &= attrs_descendants[m]
         if not common_descendants.any():
             continue
@@ -464,7 +464,7 @@ def list_keys_for_extents(
     testing_stack = deque(single_attrs)  # iteration order is inspired by Talky-G algorithm
     while testing_stack:
         attrs = testing_stack.pop()
-        attrs_indices = list(attrs.itersearch(True))
+        attrs_indices = list(attrs.search(True))
         sub_descriptions = [attrs & (~single_attrs[m]) for m in attrs_indices]
 
         # check that every subset of attrs is a key

caspailleur/order.py

@@ -23,7 +23,7 @@ def topological_sorting(elements: list[fbarray], ascending: bool = True) -> tupl
         THe mapping from the original indices to the indices of topologically sorted array.
     """
     ascending = 1 if ascending else -1
-    ars_topsort = sorted(elements, key=lambda el: (el.count() * ascending, tuple(el.itersearch(True))))
+    ars_topsort = sorted(elements, key=lambda el: (el.count() * ascending, tuple(el.search(True))))
 
     el_idx_map = {el: i for i, el in enumerate(ars_topsort)}
     orig_to_topsort_indices_map = [el_idx_map[el] for el in elements]
@@ -44,7 +44,7 @@ def inverse_order(order: List[fbarray]) -> List[fbarray]:
     """Reverse the given order. So that new_order[i][j] = order[j][i]"""
     inversed = [bazeros(len(order[0])) for _ in order]
     for el_i, ordered in enumerate(order):
-        for el_j in ordered.itersearch(True):
+        for el_j in ordered.search(True):
             inversed[el_j][el_i] = True
 
     return [fbarray(ordered) for ordered in inversed]
@@ -67,25 +67,25 @@ def sort_intents_inclusion(intents: List[fbarray], use_tqdm=False, return_transi
 
     attrs_descendants = [bitarray(zero_intents) for _ in range(n_attrs)]
     for intent_i, intent in enumerate(intents):
-        for m in intent.itersearch(True):
+        for m in intent.search(True):
             attrs_descendants[m][intent_i] = True
 
     for intent_i in tqdm(range(n_intents-1, -1, -1), disable=not use_tqdm, desc='Sorting intents'):
         intent = intents[intent_i]
 
         common_descendants = bitarray(~zero_intents)
-        for m in intent.itersearch(True):
+        for m in intent.search(True):
             common_descendants &= attrs_descendants[m]
 
         children = bitarray(zero_intents)
-        for new_m in (all_attrs & ~intent).itersearch(True):
+        for new_m in (all_attrs & ~intent).search(True):
             meet_idx = (common_descendants & attrs_descendants[new_m]).find(True)
             if meet_idx == -1:  # no meet found
                 continue
             children[meet_idx] = True
 
         trans_children = bitarray(zero_intents)
-        for child in children.itersearch(True):
+        for child in children.search(True):
             trans_children |= trans_lattice[child]
         trans_lattice[intent_i] = fbarray(children | trans_children)
         lattice[intent_i] = fbarray(children & ~trans_children)
@@ -101,14 +101,14 @@ def close_transitive_subsumption(subsumption_list: List[fbarray]) -> List[fbarra
     So that in the returned list `trans_subsumption_list`,
     `trans_subsumption_list[i]` contains indices of all intents, smaller that intent with index `i`
     """
-    assert all([max(subsumed.itersearch(True)) < i for i, subsumed in enumerate(subsumption_list) if subsumed.any()]), \
+    assert all([subsumed.index(True, right=True) < i for i, subsumed in enumerate(subsumption_list) if subsumed.any()]), \
         "`subsumption_list` relation should be defined on a list, topologically sorted by descending order." \
         " So all subsumption_list of element `i` should have smaller indices"
 
     trans_subsumption_list = []
     for subsumed in subsumption_list:
         trans_subsumed = bitarray(subsumed)
-        for el_i in subsumed.itersearch(True):
+        for el_i in subsumed.search(True):
             trans_subsumed |= trans_subsumption_list[el_i]
         trans_subsumption_list.append(fbarray(trans_subsumed))
     return trans_subsumption_list
@@ -120,16 +120,15 @@ def open_transitive_subsumption(trans_subsumption_list: List[fbarray]) -> List[f
     So that in the returned list `subsumption_list`,
     `subsumption_list[i]` contains indices of the biggest intents, smaller that intent with index `i`
     """
-    assert all([
-        max(subsumed.itersearch(True)) < i for i, subsumed in enumerate(trans_subsumption_list) if subsumed.any()
-    ]),\
+    assert all([subsumed.index(True, right=True) < i for i, subsumed in enumerate(trans_subsumption_list)
+                if subsumed.any()]), \
         "`trans_subsumption_list` relation should be defined on a list, topologically sorted by descending order." \
         " So all trans_subsumption_list of element `i` should have smaller indices"
 
     subsumption_list = []
     for trans_subsumed in trans_subsumption_list:
         subsumed = bitarray(trans_subsumed)
-        for el_i in list(subsumed.itersearch(True))[::-1]:
+        for el_i in subsumed.search(True, right=True):
             if subsumed[el_i]:
                 subsumed &= ~trans_subsumption_list[el_i]
         subsumption_list.append(fbarray(subsumed))

pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
 ]
 keywords = ["python", "fca", "itemset-mining"]
 dependencies = [
-    'numpy>=1.20', 'scikit-mine>=1', 'bitarray>=2.5.1, <3', 'tqdm', 'deprecation'
+    'numpy>=1.20', 'scikit-mine>=1', 'bitarray>=3.0.0', 'tqdm', 'deprecation'
 ]
 requires-python = ">=3.8"
 

requirements.txt

@@ -4,7 +4,7 @@
 #
 #    pip-compile pyproject.toml
 #
-bitarray==2.7.3
+bitarray==3.0.0
     # via caspailleur (pyproject.toml)
 contourpy==1.0.7
     # via matplotlib