gsppy 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

gsppy/__init__.py

@@ -13,6 +13,14 @@ from gsppy.cli import (
     read_transactions_from_json,
 )
 from gsppy.gsp import GSP
+from gsppy.pruning import (
+    PruningStrategy,
+    SupportBasedPruning,
+    FrequencyBasedPruning,
+    TemporalAwarePruning,
+    CombinedPruning,
+    create_default_pruning_strategy,
+)
 
 try:
     __version__ = importlib_metadata.version("gsppy")
@@ -26,4 +34,10 @@ __all__ = [
     "read_transactions_from_json",
     "setup_logging",
     "__version__",
+    "PruningStrategy",
+    "SupportBasedPruning",
+    "FrequencyBasedPruning",
+    "TemporalAwarePruning",
+    "CombinedPruning",
+    "create_default_pruning_strategy",
 ]

gsppy/gsp.py

@@ -99,6 +99,7 @@ from gsppy.utils import (
     generate_candidates_from_previous,
     is_subsequence_in_list_with_time_constraints,
 )
+from gsppy.pruning import PruningStrategy, create_default_pruning_strategy
 from gsppy.accelerate import support_counts as support_counts_accel
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -130,6 +131,7 @@ class GSP:
         maxgap: Optional[float] = None,
         maxspan: Optional[float] = None,
         verbose: bool = False,
+        pruning_strategy: Optional[PruningStrategy] = None,
     ):
         """
         Initialize the GSP algorithm with raw transactional data.
@@ -144,6 +146,9 @@ class GSP:
             maxspan (Optional[float]): Maximum time span from first to last item in patterns.
             verbose (bool): Enable verbose logging output with detailed progress information.
                            Default is False (minimal output).
+            pruning_strategy (Optional[PruningStrategy]): Custom pruning strategy for candidate filtering.
+                                                          If None, a default strategy is created based on
+                                                          temporal constraints.
 
         Attributes Initialized:
             - Processes the input raw transaction dataset.
@@ -162,9 +167,18 @@ class GSP:
         self.maxgap = maxgap
         self.maxspan = maxspan
         self.verbose = verbose
+        self.pruning_strategy: PruningStrategy
         self._configure_logging()
         self._validate_temporal_constraints()
         self._pre_processing(raw_transactions)
+        # Initialize default pruning strategy if none provided
+        if pruning_strategy is None:
+            self.pruning_strategy = create_default_pruning_strategy(
+                mingap=self.mingap, maxgap=self.maxgap, maxspan=self.maxspan
+            )
+            logger.debug("Using default pruning strategy: %s", self.pruning_strategy.get_description())
+        else:
+            self.pruning_strategy = pruning_strategy
 
     def _configure_logging(self) -> None:
         """
@@ -389,6 +403,39 @@ class GSP:
             # Fallback to Python implementation on any acceleration failure
             return self._support_python(items, min_support, batch_size)
 
+    def _apply_pruning(
+        self, freq_patterns: Dict[Tuple[str, ...], int], min_support_count: int
+    ) -> Dict[Tuple[str, ...], int]:
+        """
+        Apply the configured pruning strategy to filter frequent patterns.
+
+        This method uses the pruning strategy to post-process patterns that have
+        already met the minimum support threshold. Additional pruning can be applied
+        based on other criteria such as temporal feasibility or frequency thresholds.
+
+        Parameters:
+            freq_patterns (Dict[Tuple[str, ...], int]): Dictionary of patterns and their support counts.
+            min_support_count (int): Absolute minimum support count threshold.
+
+        Returns:
+            Dict[Tuple[str, ...], int]: Filtered patterns after applying pruning strategy.
+        """
+        if not freq_patterns:
+            return freq_patterns
+
+        pruned_patterns: Dict[Tuple[str, ...], int] = {}
+        context = {"min_support_count": min_support_count}
+
+        for candidate, support_count in freq_patterns.items():
+            if not self.pruning_strategy.should_prune(candidate, support_count, len(self.transactions), context):
+                pruned_patterns[candidate] = support_count
+
+        num_pruned = len(freq_patterns) - len(pruned_patterns)
+        if num_pruned > 0:
+            logger.debug("Pruning strategy filtered out %d additional candidates", num_pruned)
+
+        return pruned_patterns
+
     def _print_status(self, run: int, candidates: List[Tuple[str, ...]]) -> None:
         """
         Log progress information for the current GSP iteration.
@@ -504,7 +551,10 @@ class GSP:
 
         # scan transactions to collect support count for each candidate
         # sequence & filter
-        self.freq_patterns.append(self._support(candidates, abs_min_support, backend=backend))
+        freq_1 = self._support(candidates, abs_min_support, backend=backend)
+        # Apply pruning strategy for additional filtering
+        freq_1 = self._apply_pruning(freq_1, abs_min_support)
+        self.freq_patterns.append(freq_1)
 
         # (k-itemsets/k-sequence = 1)
         k_items = 1
@@ -525,7 +575,10 @@ class GSP:
 
             # candidate pruning - eliminates candidates who are not potentially
             # frequent (using support as threshold)
-            self.freq_patterns.append(self._support(candidates, abs_min_support, backend=backend))
+            freq_k = self._support(candidates, abs_min_support, backend=backend)
+            # Apply pruning strategy for additional filtering
+            freq_k = self._apply_pruning(freq_k, abs_min_support)
+            self.freq_patterns.append(freq_k)
 
             self._print_status(k_items, candidates)
         logger.info("GSP algorithm completed.")

gsppy/pruning.py

@@ -0,0 +1,412 @@
+"""
+Flexible candidate pruning strategies for the GSP algorithm.
+
+This module provides a pluggable pruning system that allows different strategies
+for filtering candidate sequences during pattern mining. The pruning strategies
+can significantly impact performance and pattern discovery based on dataset
+characteristics and mining requirements.
+
+Key Features:
+-------------
+1. **Abstract Pruning Strategy Interface**:
+    - Defines a common interface for all pruning strategies.
+    - Allows custom pruning logic to be easily integrated.
+
+2. **Built-in Pruning Strategies**:
+    - **SupportBasedPruning**: Standard GSP pruning based on minimum support threshold.
+    - **FrequencyBasedPruning**: Prunes candidates with low absolute frequency.
+    - **TemporalAwarePruning**: Prunes candidates that violate temporal constraints.
+    - **CombinedPruning**: Combines multiple pruning strategies.
+
+3. **Performance Optimization**:
+    - Early termination of candidate generation when patterns cannot be extended.
+    - Reduces memory footprint by eliminating non-promising candidates early.
+
+Example Usage:
+--------------
+```python
+from gsppy.gsp import GSP
+from gsppy.pruning import SupportBasedPruning, FrequencyBasedPruning, CombinedPruning
+
+# Use default support-based pruning
+gsp = GSP(transactions)
+patterns = gsp.search(min_support=0.3)
+
+# Use frequency-based pruning with a minimum frequency threshold
+pruner = FrequencyBasedPruning(min_frequency=5)
+gsp = GSP(transactions, pruning_strategy=pruner)
+patterns = gsp.search(min_support=0.3)
+
+# Combine multiple pruning strategies
+combined = CombinedPruning([SupportBasedPruning(), FrequencyBasedPruning(min_frequency=3)])
+gsp = GSP(transactions, pruning_strategy=combined)
+patterns = gsp.search(min_support=0.3)
+```
+
+Author:
+-------
+- **Developed by:** Jackson Antonio do Prado Lima
+- **Email:** jacksonpradolima@gmail.com
+
+License:
+--------
+This implementation is distributed under the MIT License.
+"""
+
+import math
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Mapping, Optional
+from typing_extensions import override
+
+PruningContext = Mapping[str, object]
+
+
+class PruningStrategy(ABC):
+    """
+    Abstract base class for candidate pruning strategies.
+
+    A pruning strategy determines which candidate sequences should be
+    filtered out during the GSP algorithm's candidate generation phase.
+    Custom pruning strategies can be implemented by subclassing this class
+    and implementing the `should_prune` method.
+    """
+
+    @abstractmethod
+    def should_prune(
+        self,
+        candidate: Tuple[str, ...],
+        support_count: int,
+        total_transactions: int,
+        context: Optional[PruningContext] = None,
+    ) -> bool:
+        """
+        Determine whether a candidate sequence should be pruned.
+
+        Parameters:
+            candidate (Tuple[str, ...]): The candidate sequence to evaluate.
+            support_count (int): The support count of the candidate in the dataset.
+            total_transactions (int): Total number of transactions in the dataset.
+            context (Optional[Dict]): Additional context information for pruning decisions.
+                                     May include temporal constraints, pattern length, etc.
+
+        Returns:
+            bool: True if the candidate should be pruned (filtered out), False otherwise.
+        """
+        pass
+
+    def get_description(self) -> str:
+        """
+        Get a human-readable description of the pruning strategy.
+
+        Returns:
+            str: Description of the pruning strategy.
+        """
+        return self.__class__.__name__
+
+
+class SupportBasedPruning(PruningStrategy):
+    """
+    Standard GSP pruning based on minimum support threshold.
+
+    This is the default pruning strategy used in the classic GSP algorithm.
+    Candidates are pruned if their support count is below the minimum support
+    threshold.
+
+    Parameters:
+        min_support_fraction (Optional[float]): Minimum support as a fraction (0.0, 1.0].
+                                                If None, uses the value from search parameters.
+    """
+
+    def __init__(self, min_support_fraction: Optional[float] = None):
+        """
+        Initialize support-based pruning strategy.
+
+        Parameters:
+            min_support_fraction (Optional[float]): Minimum support threshold.
+                                                   If None, uses the value from search.
+        """
+        self.min_support_fraction = min_support_fraction
+
+    @override
+    def should_prune(
+        self,
+        candidate: Tuple[str, ...],
+        support_count: int,
+        total_transactions: int,
+        context: Optional[PruningContext] = None,
+    ) -> bool:
+        """
+        Prune candidates below the minimum support threshold.
+
+        Parameters:
+            candidate: The candidate sequence.
+            support_count: Support count of the candidate.
+            total_transactions: Total number of transactions.
+            context: Optional context with 'min_support_count' key.
+
+        Returns:
+            bool: True if support_count < min_support_count, False otherwise.
+        """
+        # Prioritize user-provided min_support_fraction if set, otherwise use context
+        min_support_count: int
+
+        if self.min_support_fraction is not None:
+            min_support_count = int(math.ceil(total_transactions * self.min_support_fraction))
+        elif context is not None:
+            min_support_value = context.get("min_support_count")
+            if isinstance(min_support_value, int):
+                min_support_count = min_support_value
+            elif isinstance(min_support_value, float):
+                min_support_count = int(math.ceil(min_support_value))
+            else:
+                # Context does not provide a usable threshold
+                return False
+        else:
+            # If no threshold specified, don't prune
+            return False
+
+        return support_count < min_support_count
+
+    @override
+    def get_description(self) -> str:
+        """Get description of this pruning strategy."""
+        if self.min_support_fraction is not None:
+            return f"SupportBasedPruning(min_support={self.min_support_fraction})"
+        return "SupportBasedPruning(dynamic)"
+
+
+class FrequencyBasedPruning(PruningStrategy):
+    """
+    Prunes candidates based on absolute frequency threshold.
+
+    This strategy prunes candidates that appear fewer times than a specified
+    minimum frequency, regardless of the dataset size. Useful for datasets
+    where you want to ensure patterns appear a minimum number of times.
+
+    Parameters:
+        min_frequency (int): Minimum absolute frequency threshold.
+    """
+
+    def __init__(self, min_frequency: int):
+        """
+        Initialize frequency-based pruning strategy.
+
+        Parameters:
+            min_frequency (int): Minimum number of occurrences required.
+        """
+        if min_frequency < 1:
+            raise ValueError("min_frequency must be at least 1")
+        self.min_frequency = min_frequency
+
+    @override
+    def should_prune(
+        self,
+        candidate: Tuple[str, ...],
+        support_count: int,
+        total_transactions: int,
+        context: Optional[PruningContext] = None,
+    ) -> bool:
+        """
+        Prune candidates with frequency below the minimum threshold.
+
+        Parameters:
+            candidate: The candidate sequence.
+            support_count: Support count (frequency) of the candidate.
+            total_transactions: Total number of transactions (unused).
+            context: Optional context (unused).
+
+        Returns:
+            bool: True if support_count < min_frequency, False otherwise.
+        """
+        return support_count < self.min_frequency
+
+    @override
+    def get_description(self) -> str:
+        """Get description of this pruning strategy."""
+        return f"FrequencyBasedPruning(min_frequency={self.min_frequency})"
+
+
+class TemporalAwarePruning(PruningStrategy):
+    """
+    Prunes candidates based on temporal constraint feasibility.
+
+    This strategy can pre-filter candidates that are unlikely to satisfy
+    temporal constraints (mingap, maxgap, maxspan) based on pattern structure
+    and candidate length.
+
+    Parameters:
+        mingap (Optional[float]): Minimum time gap between consecutive items.
+        maxgap (Optional[float]): Maximum time gap between consecutive items.
+        maxspan (Optional[float]): Maximum time span from first to last item.
+        min_support_fraction (Optional[float]): Additional support threshold.
+    """
+
+    def __init__(
+        self,
+        mingap: Optional[float] = None,
+        maxgap: Optional[float] = None,
+        maxspan: Optional[float] = None,
+        min_support_fraction: Optional[float] = None,
+    ):
+        """
+        Initialize temporal-aware pruning strategy.
+
+        Parameters:
+            mingap: Minimum time gap constraint.
+            maxgap: Maximum time gap constraint.
+            maxspan: Maximum time span constraint.
+            min_support_fraction: Additional support threshold.
+        """
+        self.mingap = mingap
+        self.maxgap = maxgap
+        self.maxspan = maxspan
+        self.min_support_fraction = min_support_fraction
+
+    @override
+    def should_prune(
+        self,
+        candidate: Tuple[str, ...],
+        support_count: int,
+        total_transactions: int,
+        context: Optional[PruningContext] = None,
+    ) -> bool:
+        """
+        Prune candidates based on temporal feasibility and support.
+
+        This method performs two checks:
+        1. Support-based pruning (if min_support is specified)
+        2. Temporal feasibility check (pattern length vs constraints)
+
+        Parameters:
+            candidate: The candidate sequence.
+            support_count: Support count of the candidate.
+            total_transactions: Total number of transactions.
+            context: Optional context with 'min_support_count' key.
+
+        Returns:
+            bool: True if candidate should be pruned, False otherwise.
+        """
+        # First check support threshold if specified
+        if self.min_support_fraction is not None:
+            min_support_count = int(math.ceil(total_transactions * self.min_support_fraction))
+            if support_count < min_support_count:
+                return True
+        elif context is not None:
+            min_support_value = context.get("min_support_count")
+            if isinstance(min_support_value, (int, float)):
+                if support_count < int(math.ceil(min_support_value)):
+                    return True
+
+        # Check temporal feasibility
+        # If we have maxspan and mingap, check if pattern length is feasible
+        if self.maxspan is not None and self.mingap is not None and len(candidate) > 1:
+            # Minimum possible span for this pattern length
+            min_possible_span = (len(candidate) - 1) * self.mingap
+            if min_possible_span > self.maxspan:
+                # Pattern is too long to fit within maxspan given mingap
+                return True
+
+        return False
+
+    @override
+    def get_description(self) -> str:
+        """Get description of this pruning strategy."""
+        parts: List[str] = []
+        if self.mingap is not None:
+            parts.append(f"mingap={self.mingap}")
+        if self.maxgap is not None:
+            parts.append(f"maxgap={self.maxgap}")
+        if self.maxspan is not None:
+            parts.append(f"maxspan={self.maxspan}")
+        if self.min_support_fraction is not None:
+            parts.append(f"min_support={self.min_support_fraction}")
+        params = ", ".join(parts) if parts else "no constraints"
+        return f"TemporalAwarePruning({params})"
+
+
+class CombinedPruning(PruningStrategy):
+    """
+    Combines multiple pruning strategies using logical OR.
+
+    A candidate is pruned if ANY of the constituent strategies determines
+    it should be pruned. This allows combining different pruning criteria
+    for more aggressive filtering.
+
+    Parameters:
+        strategies (List[PruningStrategy]): List of pruning strategies to combine.
+    """
+
+    def __init__(self, strategies: List[PruningStrategy]):
+        """
+        Initialize combined pruning strategy.
+
+        Parameters:
+            strategies: List of pruning strategies to apply.
+        """
+        if not strategies:
+            raise ValueError("At least one pruning strategy must be provided")
+        self.strategies = strategies
+
+    @override
+    def should_prune(
+        self,
+        candidate: Tuple[str, ...],
+        support_count: int,
+        total_transactions: int,
+        context: Optional[PruningContext] = None,
+    ) -> bool:
+        """
+        Prune candidate if ANY strategy recommends pruning.
+
+        Parameters:
+            candidate: The candidate sequence.
+            support_count: Support count of the candidate.
+            total_transactions: Total number of transactions.
+            context: Optional context for pruning decisions.
+
+        Returns:
+            bool: True if any strategy recommends pruning, False otherwise.
+        """
+        for strategy in self.strategies:
+            if strategy.should_prune(candidate, support_count, total_transactions, context):
+                return True
+        return False
+
+    @override
+    def get_description(self) -> str:
+        """Get description of this combined pruning strategy."""
+        strategy_descs: List[str] = [s.get_description() for s in self.strategies]
+        return f"CombinedPruning([{', '.join(strategy_descs)}])"
+
+
+def create_default_pruning_strategy(
+    min_support_fraction: Optional[float] = None,
+    mingap: Optional[float] = None,
+    maxgap: Optional[float] = None,
+    maxspan: Optional[float] = None,
+) -> PruningStrategy:
+    """
+    Create an appropriate default pruning strategy based on parameters.
+
+    This factory function selects the best pruning strategy based on the
+    provided parameters:
+    - If temporal constraints are specified, uses TemporalAwarePruning
+    - Otherwise, uses standard SupportBasedPruning
+
+    Parameters:
+        min_support_fraction: Minimum support threshold.
+        mingap: Minimum time gap constraint.
+        maxgap: Maximum time gap constraint.
+        maxspan: Maximum time span constraint.
+
+    Returns:
+        PruningStrategy: An appropriate pruning strategy instance.
+    """
+    has_temporal = mingap is not None or maxgap is not None or maxspan is not None
+
+    if has_temporal:
+        return TemporalAwarePruning(
+            mingap=mingap, maxgap=maxgap, maxspan=maxspan, min_support_fraction=min_support_fraction
+        )
+    else:
+        return SupportBasedPruning(min_support_fraction=min_support_fraction)

{gsppy-3.5.0.dist-info → gsppy-3.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gsppy
-Version: 3.5.0
+Version: 3.6.0
 Summary: GSP (Generalized Sequence Pattern) algorithm in Python
 Project-URL: Homepage, https://github.com/jacksonpradolima/gsp-py
 Author-email: Jackson Antonio do Prado Lima <jacksonpradolima@gmail.com>
@@ -40,6 +40,7 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0.0
+Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: cython==3.2.4; extra == 'dev'
 Requires-Dist: hatch==1.16.3; extra == 'dev'
@@ -705,6 +706,140 @@ result = gsp.search(min_support=0.5)
 
 ---
 
+## 🔧 Flexible Candidate Pruning
+
+GSP-Py supports **flexible candidate pruning strategies** that allow you to customize how candidate sequences are filtered during pattern mining. This enables optimization for different dataset characteristics and mining requirements.
+
+### Built-in Pruning Strategies
+
+#### 1. Support-Based Pruning (Default)
+
+The standard GSP pruning based on minimum support threshold:
+
+```python
+from gsppy.gsp import GSP
+from gsppy.pruning import SupportBasedPruning
+
+# Explicit support-based pruning
+pruner = SupportBasedPruning(min_support_fraction=0.3)
+gsp = GSP(transactions, pruning_strategy=pruner)
+result = gsp.search(min_support=0.3)
+```
+
+#### 2. Frequency-Based Pruning
+
+Prunes candidates based on absolute frequency (minimum number of occurrences):
+
+```python
+from gsppy.pruning import FrequencyBasedPruning
+
+# Require patterns to appear at least 5 times
+pruner = FrequencyBasedPruning(min_frequency=5)
+gsp = GSP(transactions, pruning_strategy=pruner)
+result = gsp.search(min_support=0.2)
+```
+
+**Use case**: When you need patterns to occur a minimum absolute number of times, regardless of dataset size.
+
+#### 3. Temporal-Aware Pruning
+
+Optimizes pruning for time-constrained pattern mining by pre-filtering infeasible patterns:
+
+```python
+from gsppy.pruning import TemporalAwarePruning
+
+# Prune patterns that cannot satisfy temporal constraints
+pruner = TemporalAwarePruning(
+    mingap=1,
+    maxgap=5,
+    maxspan=10,
+    min_support_fraction=0.3
+)
+gsp = GSP(timestamped_transactions, mingap=1, maxgap=5, maxspan=10, pruning_strategy=pruner)
+result = gsp.search(min_support=0.3)
+```
+
+**Use case**: Improves performance for temporal pattern mining by eliminating patterns that cannot satisfy temporal constraints.
+
+#### 4. Combined Pruning
+
+Combines multiple pruning strategies for aggressive filtering:
+
+```python
+from gsppy.pruning import CombinedPruning, SupportBasedPruning, FrequencyBasedPruning
+
+# Apply both support and frequency constraints
+strategies = [
+    SupportBasedPruning(min_support_fraction=0.3),
+    FrequencyBasedPruning(min_frequency=5)
+]
+pruner = CombinedPruning(strategies)
+gsp = GSP(transactions, pruning_strategy=pruner)
+result = gsp.search(min_support=0.3)
+```
+
+**Use case**: When you want to combine multiple filtering criteria for more selective pattern discovery.
+
+### Custom Pruning Strategies
+
+You can create custom pruning strategies by implementing the `PruningStrategy` interface:
+
+```python
+from gsppy.pruning import PruningStrategy
+from typing import Dict, Optional, Tuple
+
+class MyCustomPruner(PruningStrategy):
+    def should_prune(
+        self,
+        candidate: Tuple[str, ...],
+        support_count: int,
+        total_transactions: int,
+        context: Optional[Dict] = None
+    ) -> bool:
+        # Custom pruning logic
+        # Return True to prune (filter out), False to keep
+        pattern_length = len(candidate)
+        # Example: Prune very long patterns with low support
+        if pattern_length > 5 and support_count < 10:
+            return True
+        return False
+
+# Use your custom pruner
+custom_pruner = MyCustomPruner()
+gsp = GSP(transactions, pruning_strategy=custom_pruner)
+result = gsp.search(min_support=0.2)
+```
+
+### Performance Characteristics
+
+Different pruning strategies have different performance tradeoffs:
+
+| Strategy | Pruning Aggressiveness | Use Case | Performance Impact |
+|----------|----------------------|----------|-------------------|
+| **SupportBased** | Moderate | General-purpose mining | Baseline performance |
+| **FrequencyBased** | High (for large datasets) | Require absolute frequency | Faster on large datasets |
+| **TemporalAware** | High (for temporal data) | Time-constrained patterns | Significant speedup for temporal mining |
+| **Combined** | Very High | Selective pattern discovery | Fastest, but may miss edge cases |
+
+### Benchmarking Pruning Strategies
+
+To compare pruning strategies on your dataset:
+
+```bash
+# Compare all strategies
+python benchmarks/bench_pruning.py --n_tx 1000 --vocab 100 --min_support 0.2 --strategy all
+
+# Benchmark a specific strategy
+python benchmarks/bench_pruning.py --n_tx 1000 --vocab 100 --min_support 0.2 --strategy frequency
+
+# Run multiple rounds for averaging
+python benchmarks/bench_pruning.py --n_tx 1000 --vocab 100 --min_support 0.2 --strategy all --rounds 3
+```
+
+See `benchmarks/bench_pruning.py` for the complete benchmarking script.
+
+---
+
 ## ⌨️ Typing
 
 `gsppy` ships inline type information (PEP 561) via a bundled `py.typed` marker. The public API is re-exported from
@@ -718,10 +853,7 @@ larger applications.
 
 We are actively working to improve GSP-Py. Here are some exciting features planned for future releases:
 
-1. **Custom Filters for Candidate Pruning**:
-    - Enable users to define their own pruning logic during the mining process.
-
-2. **Support for Preprocessing and Postprocessing**:
+1. **Support for Preprocessing and Postprocessing**:
     - Add hooks to allow users to transform datasets before mining and customize the output results.
 
 Want to contribute or suggest an

gsppy-3.6.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+gsppy/__init__.py,sha256=CJqssfftIIhjzXijnjLKwvIA4Cfr0CaykQkCWaD-q80,1161
+gsppy/accelerate.py,sha256=rDho3ysADETpuhT2SF9voBjd3XRaQUzuA5k_baNACF8,11020
+gsppy/cli.py,sha256=-viXa8VFIF-QvrHYy1vtDxtMm50sM_tZq5B5DMZ1Jtw,12516
+gsppy/gsp.py,sha256=grDKfnC8rshvDH3xG-HQ2JSWsDZl3qbhyEt6FFlQeeI,27135
+gsppy/pruning.py,sha256=hOoQoH1k_gzACBy6qr_cvwth9WDmKuLmJyVRDbHjFFM,14779
+gsppy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gsppy/utils.py,sha256=dAEq1hEZMN0ZjoocKs_ZIgOI9j_Y6rJEAKneul3zNRo,13501
+gsppy-3.6.0.dist-info/METADATA,sha256=8gBox1RTiigMmzTUBldVsOXc2S8ykI-J-sUC0az-RWM,34082
+gsppy-3.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gsppy-3.6.0.dist-info/entry_points.txt,sha256=smvmcIWk424ARIGKOC_BM42hpT_SptKPcIeqs-8u8lM,41
+gsppy-3.6.0.dist-info/licenses/LICENSE,sha256=AlXanKSqFzo_o-87gp3Qw3XzbmnfxYy7O0xJOcQGWJo,1086
+gsppy-3.6.0.dist-info/RECORD,,

gsppy-3.5.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-gsppy/__init__.py,sha256=NMVa-ZWT449wuxZMF9Ym7p-DChOxOibaaqlpPxksfuo,805
-gsppy/accelerate.py,sha256=rDho3ysADETpuhT2SF9voBjd3XRaQUzuA5k_baNACF8,11020
-gsppy/cli.py,sha256=-viXa8VFIF-QvrHYy1vtDxtMm50sM_tZq5B5DMZ1Jtw,12516
-gsppy/gsp.py,sha256=k72pvdmD6jU4AId2rrHQrJ4FBUgtkuC0ntEY8QHGi5c,24486
-gsppy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gsppy/utils.py,sha256=dAEq1hEZMN0ZjoocKs_ZIgOI9j_Y6rJEAKneul3zNRo,13501
-gsppy-3.5.0.dist-info/METADATA,sha256=ix2X_VEUTved_DaTsSJMERT-CZ34TUYF0XMC2KeNeuE,29747
-gsppy-3.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-gsppy-3.5.0.dist-info/entry_points.txt,sha256=smvmcIWk424ARIGKOC_BM42hpT_SptKPcIeqs-8u8lM,41
-gsppy-3.5.0.dist-info/licenses/LICENSE,sha256=AlXanKSqFzo_o-87gp3Qw3XzbmnfxYy7O0xJOcQGWJo,1086
-gsppy-3.5.0.dist-info/RECORD,,