fixed issues

Author: project-2-2-2

gsppy/accelerate.py

@@ -76,7 +76,7 @@ def _env_backend() -> str:
 
 def _encode_transactions(transactions: List[Tuple[str, ...]]) -> Tuple[List[List[int]], Dict[int, str], Dict[str, int]]:
     """Encode transactions of strings into integer IDs.
-    
+
     Parameters:
         transactions: List of transactions where each transaction is a tuple of strings.
 
@@ -184,6 +184,9 @@ def support_counts(
     - "python": force pure-Python fallback
     - otherwise: try Rust first and fall back to Python
     """
+    # Intentionally fallback to Python for non-contiguous queries.
+    # The acceleration path is currently disabled for non-contiguous cases 
+    # to facilitate testing and validation of the contiguous logic.
     if not contiguous:
         return support_counts_python(
             transactions, candidates, min_support_abs, batch_size, contiguous 
@@ -258,7 +261,6 @@ def support_counts(
         for enc_cand, freq in result:
             out_rust[tuple(inv_vocab[i] for i in enc_cand)] = int(freq)
         return out_rust
-    
     # auto: try rust then fallback
     if _rust_available:
         try:

gsppy/gsp.py

@@ -230,13 +230,13 @@ def _support_python(
         """
         # Split candidates into batches
         batches = list(split_into_batches(items, batch_size))
-        subsequence_checker = is_subsequence_in_list if contiguous else is_subsequence_non_contiguous
+        #subsequence_checker = is_subsequence_in_list if contiguous else is_subsequence_non_contiguous
 
         # Use multiprocessing pool to calculate frequency in parallel, batch-wise
         with mp.Pool(processes=mp.cpu_count()) as pool:
             batch_results = pool.starmap(
                 self._worker_batch,  # Process a batch at a time
-                [(batch, self.transactions, min_support,subsequence_checker) for batch in batches],
+                [(batch, self.transactions, min_support,contiguous) for batch in batches],
             )
 
         # Flatten the list of results and convert to a dictionary
@@ -279,6 +279,7 @@ def search(
         min_support: float = 0.2,
         max_k: Optional[int] = None,
         backend: Optional[str] = None,
+        batch_size: int = 100,
         contiguous: bool = False,
     ) -> List[Dict[Tuple[str, ...], int]]:
         """

gsppy/utils.py

@@ -68,13 +68,13 @@ def is_subsequence_in_list(subsequence: Tuple[str, ...], sequence: Tuple[str, ..
     # Use any to check if any slice matches the sequence
     return any(sequence[i : i + len_sub] == subsequence for i in range(len_seq - len_sub + 1))
 
-@lru_cache(maxsize=None)
+@lru_cache(maxsize=32768)
 def is_subsequence_non_contiguous(subsequence: Tuple[str, ...], sequence: Tuple[str, ...]) -> bool:
     """
     Check if a subsequence exists within a sequence, allowing for gaps (non-contiguous).
     """
     if not subsequence:
-        return False
+        return True
     it = iter(sequence)
     return all(item in it for item in subsequence)
 

tests/test_gsp.py

@@ -268,3 +268,25 @@ def test_gsp_enhancement_contiguous_vs_non_contiguous():
     found_ac_contiguous = any(('a', 'c') in d for d in result_contiguous)
     assert found_ac_contiguous is False, \
         "The pattern ('a', 'c') should NOT be found with a strict contiguous search."
+
+def test_non_contiguous_multiprocessing():
+    # Dataset where ('a','c') is a non‑contiguous subsequence but not a contiguous one.
+    sequences = [
+        ['a', 'b', 'c'],
+        ['a', 'c'],
+        ['b', 'c', 'a'],
+        ['a', 'b', 'c', 'd'],
+    ]
+    gsp = GSP(sequences)
+
+    # Use a tiny batch size to force multiple batches and trigger multiprocessing.
+    result_non_contig = gsp.search(min_support=0.5, contiguous=False, backend='python', batch_size=1)
+    # In non‑contiguous mode, ('a','c') should be considered frequent (support = 3/4).
+    assert any(('a', 'c') in level for level in result_non_contig), \
+        "Expected to find ('a','c') as a non‑contiguous frequent subsequence"
+    print(result_non_contig)
+    # Also verify that contiguous search does not report ('a','c').
+    result_contig = gsp.search(min_support=0.5, contiguous=True, backend='python', batch_size=1)
+    print(result_contig)
+    assert not any(('a', 'c') in level for level in result_contig), \
+        "('a','c') should not appear in a strict contiguous search"