gsppy 4.0.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

gsppy/__init__.py

@@ -24,6 +24,12 @@ from gsppy.pruning import (
     FrequencyBasedPruning,
     create_default_pruning_strategy,
 )
+from gsppy.sequence import (
+    Sequence,
+    sequences_to_dict,
+    dict_to_sequences,
+    to_sequence,
+)
 from gsppy.token_mapper import TokenMapper
 
 # DataFrame adapters are optional - import only if dependencies are available
@@ -63,6 +69,10 @@ __all__ = [
     "TemporalAwarePruning",
     "CombinedPruning",
     "create_default_pruning_strategy",
+    "Sequence",
+    "sequences_to_dict",
+    "dict_to_sequences",
+    "to_sequence",
     "TokenMapper",
 ]
 

gsppy/cli.py

@@ -35,7 +35,7 @@ import csv
 import sys
 import json
 import logging
-from typing import Any, Dict, List, Tuple, Union, Optional, cast
+from typing import Any, List, Tuple, Union, Optional, cast
 
 import click
 
@@ -608,7 +608,7 @@ def main(
     # Initialize and run GSP algorithm
     try:
         gsp = GSP(transactions, mingap=mingap, maxgap=maxgap, maxspan=maxspan, verbose=verbose)
-        patterns: List[Dict[Tuple[str, ...], int]] = gsp.search(min_support=min_support)
+        patterns = gsp.search(min_support=min_support, return_sequences=False)
         logger.info("Frequent Patterns Found:")
         for i, level in enumerate(patterns, start=1):
             logger.info(f"\n{i}-Sequence Patterns:")

gsppy/gsp.py

@@ -90,7 +90,7 @@ from __future__ import annotations
 import math
 import logging
 import multiprocessing as mp
-from typing import TYPE_CHECKING, Dict, List, Tuple, Union, Optional, cast
+from typing import TYPE_CHECKING, Dict, List, Tuple, Union, Literal, Optional, cast, overload
 from itertools import chain
 from collections import Counter
 
@@ -102,6 +102,7 @@ from gsppy.utils import (
     is_subsequence_in_list_with_time_constraints,
 )
 from gsppy.pruning import PruningStrategy, create_default_pruning_strategy
+from gsppy.sequence import Sequence, dict_to_sequences
 from gsppy.accelerate import support_counts as support_counts_accel
 
 if TYPE_CHECKING:
@@ -590,13 +591,37 @@ class GSP:
         """
         logger.info("Run %d: %d candidates filtered to %d.", run, len(candidates), len(self.freq_patterns[run - 1]))
 
+    @overload
     def search(
         self,
         min_support: float = 0.2,
         max_k: Optional[int] = None,
         backend: Optional[str] = None,
         verbose: Optional[bool] = None,
-    ) -> List[Dict[Tuple[str, ...], int]]:
+        *,
+        return_sequences: Literal[False] = False,
+    ) -> List[Dict[Tuple[str, ...], int]]: ...
+
+    @overload
+    def search(
+        self,
+        min_support: float = 0.2,
+        max_k: Optional[int] = None,
+        backend: Optional[str] = None,
+        verbose: Optional[bool] = None,
+        *,
+        return_sequences: Literal[True],
+    ) -> List[List[Sequence]]: ...
+
+    def search(
+        self,
+        min_support: float = 0.2,
+        max_k: Optional[int] = None,
+        backend: Optional[str] = None,
+        verbose: Optional[bool] = None,
+        *,
+        return_sequences: bool = False,
+    ) -> Union[List[Dict[Tuple[str, ...], int]], List[List[Sequence]]]:
         """
         Execute the Generalized Sequential Pattern (GSP) mining algorithm.
 
@@ -617,11 +642,20 @@ class GSP:
                                     Note: temporal constraints always use Python backend.
             verbose (Optional[bool]): Override instance verbosity setting for this search.
                                      If None, uses the instance's verbose setting.
+            return_sequences (bool): If True, returns patterns as Sequence objects instead of
+                                    Dict[Tuple[str, ...], int]. Defaults to False for backward
+                                    compatibility. When True, returns List[List[Sequence]] where
+                                    each Sequence contains items, support count, and can be extended
+                                    with additional metadata.
 
         Returns:
-            List[Dict[Tuple[str, ...], int]]: A list of dictionaries containing frequent patterns
-                                              at each k-sequence level, with patterns as keys
-                                              and their support counts as values.
+            Union[List[Dict[Tuple[str, ...], int]], List[List[Sequence]]]:
+                If return_sequences is False (default):
+                    A list of dictionaries containing frequent patterns at each k-sequence level,
+                    with patterns as keys and their support counts as values.
+                If return_sequences is True:
+                    A list of lists containing Sequence objects at each k-sequence level,
+                    where each Sequence encapsulates the pattern items and support count.
 
         Raises:
             ValueError: If the minimum support threshold is not in the range `(0.0, 1.0]`.
@@ -632,7 +666,7 @@ class GSP:
             - Status updates for each iteration until the algorithm terminates.
 
         Examples:
-            Basic usage without temporal constraints:
+            Basic usage without temporal constraints (default tuple-based):
 
             ```python
             from gsppy.gsp import GSP
@@ -645,6 +679,28 @@ class GSP:
 
             gsp = GSP(transactions)
             patterns = gsp.search(min_support=0.3)
+            # Returns: [{('Bread',): 4, ('Milk',): 4, ...}, {('Bread', 'Milk'): 3, ...}, ...]
+            ```
+
+            Using Sequence objects for richer pattern representation:
+
+            ```python
+            from gsppy.gsp import GSP
+
+            transactions = [
+                ["Bread", "Milk"],
+                ["Bread", "Diaper", "Beer", "Eggs"],
+                ["Milk", "Diaper", "Beer", "Coke"],
+            ]
+
+            gsp = GSP(transactions)
+            patterns = gsp.search(min_support=0.3, return_sequences=True)
+            # Returns: [[Sequence(('Bread',), support=4), Sequence(('Milk',), support=4), ...], ...]
+
+            # Access pattern details
+            for level_patterns in patterns:
+                for seq in level_patterns:
+                    print(f"Pattern: {seq.items}, Support: {seq.support}")
             ```
 
             Usage with temporal constraints (requires timestamped transactions):
@@ -682,6 +738,9 @@ class GSP:
                 f"Using temporal constraints: mingap={self.mingap}, maxgap={self.maxgap}, maxspan={self.maxspan}"
             )
 
+        # Clear freq_patterns for this search (allow reusing the GSP instance)
+        self.freq_patterns = []
+
         # Convert fractional support to absolute count (ceil to preserve threshold semantics)
         abs_min_support = int(math.ceil(len(self.transactions) * float(min_support)))
 
@@ -729,4 +788,9 @@ class GSP:
             self.verbose = original_verbose
             self._configure_logging()
 
-        return self.freq_patterns[:-1]
+        # Return results in the requested format
+        result = self.freq_patterns[:-1]
+        if return_sequences:
+            # Convert Dict[Tuple[str, ...], int] to List[Sequence] for each level
+            return [dict_to_sequences(level_patterns) for level_patterns in result]
+        return result

gsppy/sequence.py

@@ -0,0 +1,371 @@
+"""
+Sequence abstraction for GSP-Py algorithms.
+
+This module provides a Sequence class that encapsulates a pattern's elements,
+associated transaction indices or counts, and any extra metadata (such as pattern
+support, provenance, or timestamps). This abstraction enhances maintainability,
+clarity, and future extensibility of GSP-Py's core logic.
+
+The Sequence class is designed to be:
+- Immutable and hashable (can be used as dictionary keys)
+- Backward compatible with tuple representations
+- Efficient for multiprocessing (pickleable)
+- Extensible for future metadata additions
+
+Author: Jackson Antonio do Prado Lima
+Email: jacksonpradolima@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Tuple, Union, Iterator, Optional, cast
+from dataclasses import field, dataclass
+from typing_extensions import override
+
+
+@dataclass(frozen=True, slots=True)
+class Sequence:
+    """
+    Represents a sequential pattern with associated metadata.
+
+    This class encapsulates a pattern (sequence of items) along with its
+    support count, transaction indices, and optional temporal metadata.
+    The class is immutable and hashable, allowing it to be used as dictionary
+    keys while providing a richer interface than bare tuples.
+
+    Attributes:
+        items (Tuple[str, ...]): The pattern elements as an immutable tuple.
+        support (int): The support count (number of transactions containing this pattern).
+                      Defaults to 0 for candidate sequences not yet evaluated.
+        transaction_indices (Optional[Tuple[int, ...]]): Indices of transactions that
+                                                         contain this pattern. Optional
+                                                         as it may not always be tracked
+                                                         to save memory.
+        metadata (Optional[dict]): Additional metadata such as timestamps, confidence,
+                                   lift, or other pattern-specific information.
+
+    Examples:
+        Create a simple sequence:
+        >>> seq = Sequence(items=("A", "B", "C"), support=5)
+        >>> seq.length
+        3
+        >>> seq.items
+        ('A', 'B', 'C')
+
+        Create from tuple for backward compatibility:
+        >>> seq = Sequence.from_tuple(("A", "B"))
+        >>> seq.items
+        ('A', 'B')
+
+        Use as dictionary key:
+        >>> patterns = {seq: 10}
+        >>> seq in patterns
+        True
+    """
+
+    items: Tuple[str, ...]
+    support: int = 0
+    transaction_indices: Optional[Tuple[int, ...]] = None
+    metadata: Optional[Dict[str, Any]] = field(default=None, compare=False, hash=False)
+
+    def __post_init__(self) -> None:
+        """Validate the sequence after initialization."""
+        # Normalize items to tuple for immutability
+        object.__setattr__(self, "items", tuple(self.items))
+
+        if not self.items:
+            raise ValueError("Sequence items cannot be empty")
+
+        if self.support < 0:
+            raise ValueError("Support count cannot be negative")
+
+        if self.transaction_indices is not None:
+            object.__setattr__(self, "transaction_indices", tuple(self.transaction_indices))
+
+    @property
+    def length(self) -> int:
+        """Return the length of the sequence (number of items)."""
+        return len(self.items)
+
+    @property
+    def first_item(self) -> str:
+        """Return the first item in the sequence."""
+        return self.items[0]
+
+    @property
+    def last_item(self) -> str:
+        """Return the last item in the sequence."""
+        return self.items[-1]
+
+    def as_tuple(self) -> Tuple[str, ...]:
+        """
+        Return the pattern as a plain tuple for backward compatibility.
+
+        Returns:
+            Tuple[str, ...]: The sequence items as a tuple.
+        """
+        return self.items
+
+    @classmethod
+    def from_tuple(
+        cls,
+        items: Tuple[str, ...],
+        support: int = 0,
+        transaction_indices: Optional[Tuple[int, ...]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Sequence:
+        """
+        Create a Sequence from a tuple of items.
+
+        This is a convenience method for backward compatibility with code
+        that uses plain tuples to represent patterns.
+
+        Parameters:
+            items (Tuple[str, ...]): The pattern elements.
+            support (int): The support count. Defaults to 0.
+            transaction_indices (Optional[Tuple[int, ...]]): Transaction indices.
+            metadata (Optional[dict]): Additional metadata.
+
+        Returns:
+            Sequence: A new Sequence instance.
+
+        Examples:
+            >>> seq = Sequence.from_tuple(("A", "B", "C"), support=5)
+            >>> seq.items
+            ('A', 'B', 'C')
+            >>> seq.support
+            5
+        """
+        return cls(
+            items=items,
+            support=support,
+            transaction_indices=transaction_indices,
+            metadata=metadata,
+        )
+
+    @classmethod
+    def from_item(cls, item: str, support: int = 0) -> Sequence:
+        """
+        Create a singleton Sequence from a single item.
+
+        Parameters:
+            item (str): The single item.
+            support (int): The support count. Defaults to 0.
+
+        Returns:
+            Sequence: A new Sequence instance containing only the item.
+
+        Examples:
+            >>> seq = Sequence.from_item("A", support=10)
+            >>> seq.items
+            ('A',)
+            >>> seq.length
+            1
+        """
+        return cls(items=(item,), support=support)
+
+    def extend(self, item: str, support: int = 0) -> Sequence:
+        """
+        Create a new Sequence by extending this one with an additional item.
+
+        This is used during candidate generation to create k+1 sequences
+        from k sequences.
+
+        Parameters:
+            item (str): The item to append.
+            support (int): The support count for the new sequence. Defaults to 0.
+
+        Returns:
+            Sequence: A new Sequence with the item appended.
+
+        Examples:
+            >>> seq = Sequence.from_tuple(("A", "B"))
+            >>> new_seq = seq.extend("C")
+            >>> new_seq.items
+            ('A', 'B', 'C')
+        """
+        return Sequence(
+            items=self.items + (item,),
+            support=support,
+            transaction_indices=None,  # New sequence, no indices yet
+            metadata=self.metadata.copy() if self.metadata else None,
+        )
+
+    def with_support(self, support: int, transaction_indices: Optional[Tuple[int, ...]] = None) -> Sequence:
+        """
+        Create a new Sequence with updated support information.
+
+        This is used after calculating support to update the sequence
+        with its actual support count and optionally transaction indices.
+
+        Parameters:
+            support (int): The new support count.
+            transaction_indices (Optional[Tuple[int, ...]]): Transaction indices.
+
+        Returns:
+            Sequence: A new Sequence with updated support information.
+
+        Examples:
+            >>> seq = Sequence.from_tuple(("A", "B"))
+            >>> supported_seq = seq.with_support(5, (0, 2, 4))
+            >>> supported_seq.support
+            5
+        """
+        return Sequence(
+            items=self.items,
+            support=support,
+            transaction_indices=transaction_indices,
+            metadata=self.metadata,
+        )
+
+    def with_metadata(self, **kwargs: Any) -> Sequence:
+        """
+        Create a new Sequence with additional or updated metadata.
+
+        Parameters:
+            **kwargs: Metadata key-value pairs to add or update.
+
+        Returns:
+            Sequence: A new Sequence with updated metadata.
+
+        Examples:
+            >>> seq = Sequence.from_tuple(("A", "B"), support=5)
+            >>> seq_with_meta = seq.with_metadata(confidence=0.75, lift=1.2)
+            >>> seq_with_meta.metadata
+            {'confidence': 0.75, 'lift': 1.2}
+        """
+        new_metadata: Dict[str, Any] = (self.metadata or {}).copy()
+        new_metadata.update(kwargs)
+        return Sequence(
+            items=self.items,
+            support=self.support,
+            transaction_indices=self.transaction_indices,
+            metadata=new_metadata,
+        )
+
+    @override
+    def __repr__(self) -> str:
+        """Return a string representation of the Sequence."""
+        parts = [f"items={self.items}", f"support={self.support}"]
+        if self.transaction_indices is not None:
+            parts.append(f"transaction_indices={self.transaction_indices}")
+        if self.metadata:
+            parts.append(f"metadata={self.metadata}")
+        return f"Sequence({', '.join(parts)})"
+
+    @override
+    def __str__(self) -> str:
+        """Return a human-readable string representation."""
+        return f"{self.items} (support={self.support})"
+
+    def __len__(self) -> int:
+        """Return the length of the sequence."""
+        return len(self.items)
+
+    def __getitem__(self, index: Union[int, slice]) -> Union[str, Tuple[str, ...]]:
+        """
+        Access items by index or slice.
+
+        Parameters:
+            index: Integer index or slice object.
+
+        Returns:
+            str or Tuple[str, ...]: Single item or tuple of items.
+        """
+        return self.items[index]
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over the items in the sequence."""
+        return iter(self.items)
+
+    def __contains__(self, item: str) -> bool:
+        """Check if an item is in the sequence."""
+        return item in self.items
+
+
+# Utility functions for working with Sequences and tuples
+
+
+def sequences_to_dict(sequences: List[Sequence]) -> dict[Tuple[str, ...], int]:
+    """
+    Convert a list of Sequence objects to a dictionary mapping tuples to support counts.
+
+    This function provides backward compatibility with code expecting the
+    traditional Dict[Tuple[str, ...], int] format.
+
+    Parameters:
+        sequences (List[Sequence]): List of Sequence objects.
+
+    Returns:
+        dict[Tuple[str, ...], int]: Dictionary mapping pattern tuples to support counts.
+
+    Examples:
+        >>> seqs = [Sequence(("A",), 5), Sequence(("B",), 3)]
+        >>> sequences_to_dict(seqs)
+        {('A',): 5, ('B',): 3}
+    """
+    return {seq.items: seq.support for seq in sequences}
+
+
+def dict_to_sequences(pattern_dict: dict[Tuple[str, ...], int]) -> List[Sequence]:
+    """
+    Convert a dictionary of patterns to a list of Sequence objects.
+
+    This function converts the traditional Dict[Tuple[str, ...], int] format
+    to Sequence objects.
+
+    Parameters:
+        pattern_dict (dict[Tuple[str, ...], int]): Dictionary mapping tuples to support.
+
+    Returns:
+        List[Sequence]: List of Sequence objects.
+
+    Examples:
+        >>> patterns = {("A",): 5, ("B",): 3}
+        >>> seqs = dict_to_sequences(patterns)
+        >>> len(seqs)
+        2
+    """
+    return [Sequence.from_tuple(items, support=support) for items, support in pattern_dict.items()]
+
+
+def is_sequence_or_tuple(obj: Any) -> bool:
+    """
+    Check if an object is a Sequence instance or a tuple.
+
+    Parameters:
+        obj: Object to check.
+
+    Returns:
+        bool: True if obj is a Sequence or tuple, False otherwise.
+    """
+    return isinstance(obj, (Sequence, tuple))
+
+
+def to_sequence(obj: object, support: int = 0) -> Sequence:
+    """
+    Convert various input types to a Sequence object.
+
+    Parameters:
+        obj: Input object (Sequence, tuple, or string).
+        support: Support count to use if creating a new Sequence.
+
+    Returns:
+        Sequence: A Sequence object.
+
+    Examples:
+        >>> to_sequence(("A", "B"), support=5)
+        Sequence(items=('A', 'B'), support=5)
+        >>> seq = Sequence(("X",), 3)
+        >>> to_sequence(seq)
+        Sequence(items=('X',), support=3)
+    """
+    if isinstance(obj, Sequence):
+        return obj
+    if isinstance(obj, tuple):
+        if not all(isinstance(item, str) for item in obj):  # pyright: ignore[reportUnknownVariableType]
+            raise TypeError("Tuple items must be strings")
+        return Sequence.from_tuple(cast(Tuple[str, ...], obj), support=support)
+    if isinstance(obj, str):
+        return Sequence.from_item(obj, support=support)
+    raise TypeError(f"Cannot convert {type(obj)} to Sequence")

{gsppy-4.0.0.dist-info → gsppy-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gsppy
-Version: 4.0.0
+Version: 4.1.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>
@@ -559,6 +559,82 @@ Verbose mode provides:
 
 For complete documentation on logging, see [docs/logging.md](docs/logging.md).
 
+### Using Sequence Objects for Rich Pattern Representation
+
+GSP-Py 4.0+ introduces a **Sequence abstraction class** that provides a richer, more maintainable way to work with sequential patterns. The Sequence class encapsulates pattern items, support counts, and optional metadata in an immutable, hashable object.
+
+#### Traditional Dict-based Output (Default)
+
+```python
+from gsppy import GSP
+
+transactions = [
+    ['Bread', 'Milk'],
+    ['Bread', 'Diaper', 'Beer', 'Eggs'],
+    ['Milk', 'Diaper', 'Beer', 'Coke']
+]
+
+gsp = GSP(transactions)
+result = gsp.search(min_support=0.3)
+
+# Returns: [{('Bread',): 4, ('Milk',): 4, ...}, {('Bread', 'Milk'): 3, ...}, ...]
+for level_patterns in result:
+    for pattern, support in level_patterns.items():
+        print(f"Pattern: {pattern}, Support: {support}")
+```
+
+#### Sequence Objects (New Feature)
+
+```python
+from gsppy import GSP
+
+transactions = [
+    ['Bread', 'Milk'],
+    ['Bread', 'Diaper', 'Beer', 'Eggs'],
+    ['Milk', 'Diaper', 'Beer', 'Coke']
+]
+
+gsp = GSP(transactions)
+result = gsp.search(min_support=0.3, return_sequences=True)
+
+# Returns: [[Sequence(('Bread',), support=4), ...], [Sequence(('Bread', 'Milk'), support=3), ...], ...]
+for level_patterns in result:
+    for seq in level_patterns:
+        print(f"Pattern: {seq.items}, Support: {seq.support}, Length: {seq.length}")
+        # Access sequence properties
+        print(f"  First item: {seq.first_item}, Last item: {seq.last_item}")
+        # Check if item is in sequence
+        if "Milk" in seq:
+            print(f"  Contains Milk!")
+```
+
+#### Key Benefits of Sequence Objects
+
+1. **Rich API**: Access pattern properties like `length`, `first_item`, `last_item`
+2. **Type Safety**: IDE autocomplete and better type hints
+3. **Immutable & Hashable**: Can be used as dictionary keys
+4. **Extensible**: Add metadata for confidence, lift, or custom properties
+5. **Backward Compatible**: Convert to/from dict format as needed
+
+```python
+from gsppy import Sequence, sequences_to_dict, dict_to_sequences
+
+# Create custom sequences
+seq = Sequence.from_tuple(("A", "B", "C"), support=5)
+
+# Extend sequences
+extended = seq.extend("D")  # Creates Sequence(("A", "B", "C", "D"))
+
+# Add metadata
+seq_with_meta = seq.with_metadata(confidence=0.85, lift=1.5)
+
+# Convert between formats for compatibility
+seq_result = gsp.search(min_support=0.3, return_sequences=True)
+dict_format = sequences_to_dict(seq_result[0])  # Convert to dict
+```
+
+For a complete example, see [examples/sequence_example.py](examples/sequence_example.py).
+
 ### Loading SPM/GSP Format Files
 
 GSP-Py supports loading datasets in the classical SPM/GSP delimiter format, which is widely used in sequential pattern mining research. This format uses:

{gsppy-4.0.0.dist-info → gsppy-4.1.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
-gsppy/__init__.py,sha256=OtUaUNorr3nCc-d-lc4JHvxGJsGtOqcSw-8J_zP7Zng,2251
+gsppy/__init__.py,sha256=2RKQOByljT55UYgCJrSLSMNlMyu0AjsQtvvqUaWahyA,2444
 gsppy/accelerate.py,sha256=rDho3ysADETpuhT2SF9voBjd3XRaQUzuA5k_baNACF8,11020
-gsppy/cli.py,sha256=SJtF7azZeBZpvcBhhRkXWyRpJMce_h96SLRqiSVUtu0,22440
+gsppy/cli.py,sha256=dn5V5mcun0Hu3A5IgtBbJp3nZs4t21zYOenTsqktJY8,22424
 gsppy/dataframe_adapters.py,sha256=urAu32a4YsMRnm0yGvxT_XrRHfB_EYWClHH2f4OHH8w,15773
 gsppy/enums.py,sha256=2LxMWGJNWMgjhCWv_nzKWXi4iHU1S12qns3DpBUraAw,1265
-gsppy/gsp.py,sha256=nCwzsVkOn4DqqCbxGCucpsHp9FZqGEphdJcc3fpHhrY,32743
+gsppy/gsp.py,sha256=uFnTNrEkWinBUXYqv0eM2M0bpB2CibKo_yIfh4RAYaM,35429
 gsppy/pruning.py,sha256=hOoQoH1k_gzACBy6qr_cvwth9WDmKuLmJyVRDbHjFFM,14779
 gsppy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gsppy/sequence.py,sha256=BBtaThzlEgtrL5eMXNn4fge-VkniLUT1TeGOL6hbpSg,12353
 gsppy/token_mapper.py,sha256=JhPe_IZMnbM3GzdQwzleYIkE2aVw01QoYdG1TXWoCqw,2818
 gsppy/utils.py,sha256=Ys5B9aJxJBCEXe51HK00nq3-Yf7fIGntoOzSvxSFlro,17592
-gsppy-4.0.0.dist-info/METADATA,sha256=6p3zWP9LFtQ8WfW0PXFdvgYJ-LA0wCzVTBQZ_u1Up4k,43059
-gsppy-4.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-gsppy-4.0.0.dist-info/entry_points.txt,sha256=smvmcIWk424ARIGKOC_BM42hpT_SptKPcIeqs-8u8lM,41
-gsppy-4.0.0.dist-info/licenses/LICENSE,sha256=AlXanKSqFzo_o-87gp3Qw3XzbmnfxYy7O0xJOcQGWJo,1086
-gsppy-4.0.0.dist-info/RECORD,,
+gsppy-4.1.0.dist-info/METADATA,sha256=6KTEiLxg67lhyVzdCm_VnBL9h8pYuqYLOQZhzu2kPXc,45593
+gsppy-4.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gsppy-4.1.0.dist-info/entry_points.txt,sha256=smvmcIWk424ARIGKOC_BM42hpT_SptKPcIeqs-8u8lM,41
+gsppy-4.1.0.dist-info/licenses/LICENSE,sha256=AlXanKSqFzo_o-87gp3Qw3XzbmnfxYy7O0xJOcQGWJo,1086
+gsppy-4.1.0.dist-info/RECORD,,