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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gsppy
-Version: 3.5.0
+Version: 4.0.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>
@@ -32,14 +32,20 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dataframe
+Requires-Dist: pandas-stubs>=2.3.3.260113; extra == 'dataframe'
+Requires-Dist: pandas>=3.0.0; extra == 'dataframe'
+Requires-Dist: polars>=1.37.1; extra == 'dataframe'
+Requires-Dist: pyarrow>=10.0.0; extra == 'dataframe'
 Provides-Extra: dev
 Requires-Dist: cython==3.2.4; extra == 'dev'
 Requires-Dist: hatch==1.16.3; extra == 'dev'
@@ -50,9 +56,9 @@ Requires-Dist: pyright==1.1.408; extra == 'dev'
 Requires-Dist: pytest-benchmark==5.2.3; extra == 'dev'
 Requires-Dist: pytest-cov==7.0.0; extra == 'dev'
 Requires-Dist: pytest==9.0.2; extra == 'dev'
-Requires-Dist: ruff==0.14.13; extra == 'dev'
+Requires-Dist: ruff==0.14.14; extra == 'dev'
 Requires-Dist: tox==4.34.1; extra == 'dev'
-Requires-Dist: ty==0.0.12; extra == 'dev'
+Requires-Dist: ty==0.0.14; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs-gen-files<1,>=0.5; extra == 'docs'
 Requires-Dist: mkdocs-literate-nav<1,>=0.6; extra == 'docs'
@@ -71,7 +77,7 @@ Description-Content-Type: text/markdown
 
 [![PyPI Downloads](https://img.shields.io/pypi/dm/gsppy.svg?style=flat-square)](https://pypi.org/project/gsppy/)
 [![PyPI version](https://badge.fury.io/py/gsppy.svg)](https://pypi.org/project/gsppy)
-![](https://img.shields.io/badge/python-3.10+-blue.svg)
+![](https://img.shields.io/badge/python-3.11+-blue.svg)
 
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/jacksonpradolima/gsp-py/badge)](https://securityscorecards.dev/viewer/?uri=github.com/jacksonpradolima/gsp-py)
 [![SLSA provenance](https://github.com/jacksonpradolima/gsp-py/actions/workflows/slsa-provenance.yml/badge.svg)](https://github.com/jacksonpradolima/gsp-py/actions/workflows/slsa-provenance.yml)
@@ -89,7 +95,7 @@ Description-Content-Type: text/markdown
 Sequence Pattern (GSP)** algorithm. Ideal for market basket analysis, temporal mining, and user journey discovery.
 
 > [!IMPORTANT]
-> GSP-Py is compatible with Python 3.10 and later versions!
+> GSP-Py is compatible with Python 3.11 and later versions!
 
 ---
 
@@ -105,6 +111,7 @@ Sequence Pattern (GSP)** algorithm. Ideal for market basket analysis, temporal m
 6. [💡 Usage](#usage)
     - [✅ Example: Analyzing Sales Data](#example-analyzing-sales-data)
     - [📊 Explanation: Support and Results](#explanation-support-and-results)
+    - [📊 DataFrame Input Support](#dataframe-input-support)
     - [⏱️ Temporal Constraints](#temporal-constraints)
 7. [⌨️ Typing](#typing)
 8. [🌟 Planned Features](#planned-features)
@@ -356,6 +363,34 @@ Your input file should be either:
   Bread,Milk,Diaper,Coke
   ```
 
+- **SPM/GSP Format**: Uses delimiters to separate elements and sequences. This format is commonly used in sequential pattern mining datasets.
+  - `-1`: Marks the end of an element (itemset)
+  - `-2`: Marks the end of a sequence (transaction)
+  
+  Example:
+  ```text
+  1 2 -1 3 -1 -2
+  4 -1 5 6 -1 -2
+  1 -1 2 3 -1 -2
+  ```
+  
+  The above represents:
+  - Transaction 1: `[[1, 2], [3]]` → flattened to `[1, 2, 3]`
+  - Transaction 2: `[[4], [5, 6]]` → flattened to `[4, 5, 6]`
+  - Transaction 3: `[[1], [2, 3]]` → flattened to `[1, 2, 3]`
+  
+  String tokens are also supported:
+  ```text
+  A B -1 C -1 -2
+  D -1 E F -1 -2
+  ```
+
+- **Parquet/Arrow Files**: Modern columnar data formats (requires 'gsppy[dataframe]')
+  ```bash
+  pip install 'gsppy[dataframe]'
+  ```
+  This installs optional dependencies: `polars`, `pandas`, and `pyarrow` for DataFrame support.
+
 ### Running the CLI
 
 Use the following command to run GSPPy on your data:
@@ -370,9 +405,16 @@ Or for CSV files:
 gsppy --file path/to/transactions.csv --min_support 0.3 --backend rust
 ```
 
+For SPM/GSP format files, use the `--format spm` option:
+
+```bash
+gsppy --file path/to/data.txt --format spm --min_support 0.3
+```
+
 #### CLI Options
 
-- `--file`: Path to your input file (JSON or CSV). **Required**.
+- `--file`: Path to your input file (JSON, CSV, or SPM format). **Required**.
+- `--format`: File format to use. Options: `auto` (default, auto-detect from extension), `json`, `csv`, `spm`, `parquet`, `arrow`.
 - `--min_support`: Minimum support threshold as a fraction (e.g., `0.3` for 30%). Default is `0.2`.
 - `--backend`: Backend to use for support counting. One of `auto` (default), `python`, `rust`, or `gpu`.
 - `--verbose`: Enable detailed logging with timestamps, log levels, and process IDs for debugging and traceability.
@@ -517,6 +559,83 @@ Verbose mode provides:
 
 For complete documentation on logging, see [docs/logging.md](docs/logging.md).
 
+### 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:
+- `-1` to mark the end of an element (itemset)
+- `-2` to mark the end of a sequence (transaction)
+
+#### Using the SPM Loader
+
+```python
+from gsppy.utils import read_transactions_from_spm
+from gsppy import GSP
+
+# Load SPM format file
+transactions = read_transactions_from_spm('data.txt')
+
+# Run GSP algorithm
+gsp = GSP(transactions)
+result = gsp.search(min_support=0.3)
+```
+
+#### SPM Format Examples
+
+**Simple sequence file (`data.txt`):**
+```text
+1 2 -1 3 -1 -2
+4 -1 5 6 -1 -2
+1 -1 2 3 -1 -2
+```
+
+This represents:
+- Transaction 1: Items [1, 2] followed by item [3] → flattened to [1, 2, 3]
+- Transaction 2: Item [4] followed by items [5, 6] → flattened to [4, 5, 6]
+- Transaction 3: Item [1] followed by items [2, 3] → flattened to [1, 2, 3]
+
+**String tokens are also supported:**
+```text
+A B -1 C -1 -2
+D -1 E F -1 -2
+```
+
+#### Token Mapping
+
+For workflows requiring conversion between string tokens and integer IDs, use the `TokenMapper`:
+
+```python
+from gsppy.utils import read_transactions_from_spm
+from gsppy import TokenMapper
+
+# Load with mappings
+transactions, str_to_int, int_to_str = read_transactions_from_spm(
+    'data.txt', 
+    return_mappings=True
+)
+
+print("String to Int:", str_to_int)
+# Output: {'1': 0, '2': 1, '3': 2, '4': 3, '5': 4, '6': 5}
+
+print("Int to String:", int_to_str)
+# Output: {0: '1', 1: '2', 2: '3', 3: '4', 4: '5', 5: '6'}
+
+# Use the TokenMapper class directly
+mapper = TokenMapper()
+id_a = mapper.add_token("A")
+id_b = mapper.add_token("B")
+print(f"A -> {id_a}, B -> {id_b}")
+# Output: A -> 0, B -> 1
+```
+
+#### Edge Cases Handled
+
+The SPM loader gracefully handles:
+- Empty lines (skipped)
+- Missing `-2` delimiter at end of line
+- Extra or consecutive delimiters
+- Mixed-length elements in sequences
+- Both integer and string tokens
+
 ### Output
 
 The algorithm will return a list of patterns with their corresponding support.
@@ -583,6 +702,208 @@ result = gsp.search(min_support=0.5)  # Need at least 2/4 sequences
 
 ---
 
+## 📊 DataFrame Input Support
+
+GSP-Py supports **Polars and Pandas DataFrames** as input, enabling high-performance workflows with modern data formats like Arrow and Parquet. This feature is particularly useful for large-scale data engineering pipelines and integration with existing data processing workflows.
+
+### Installation
+
+Install GSP-Py with DataFrame support:
+
+```bash
+pip install 'gsppy[dataframe]'
+```
+
+This installs the optional dependencies: `polars`, `pandas`, and `pyarrow`.
+
+### DataFrame Input Formats
+
+GSP-Py supports two DataFrame formats:
+
+#### 1. Grouped Format (Transaction ID + Item Columns)
+
+Use when your data has separate rows for each item in a transaction:
+
+```python
+import polars as pl
+from gsppy import GSP
+
+# Polars DataFrame with transaction_id and item columns
+df = pl.DataFrame({
+    "transaction_id": [1, 1, 2, 2, 2, 3, 3],
+    "item": ["Bread", "Milk", "Bread", "Diaper", "Beer", "Milk", "Coke"],
+})
+
+# Run GSP directly on the DataFrame
+gsp = GSP(df, transaction_col="transaction_id", item_col="item")
+patterns = gsp.search(min_support=0.3)
+
+for level, freq_patterns in enumerate(patterns, start=1):
+    print(f"\n{level}-Sequence Patterns:")
+    for pattern, support in freq_patterns.items():
+        print(f"  {pattern}: {support}")
+```
+
+#### 2. Sequence Format (List Column)
+
+Use when each row contains a complete transaction as a list:
+
+```python
+import pandas as pd
+from gsppy import GSP
+
+# Pandas DataFrame with sequences as lists
+df = pd.DataFrame({
+    "transaction": [
+        ["Bread", "Milk"],
+        ["Bread", "Diaper", "Beer"],
+        ["Milk", "Coke"],
+    ]
+})
+
+gsp = GSP(df, sequence_col="transaction")
+patterns = gsp.search(min_support=0.3)
+```
+
+### DataFrame with Timestamps
+
+DataFrames support temporal constraints for time-aware pattern mining:
+
+```python
+import polars as pl
+from gsppy import GSP
+
+# Grouped format with timestamps
+df = pl.DataFrame({
+    "transaction_id": [1, 1, 1, 2, 2, 2],
+    "item": ["Login", "Browse", "Purchase", "Login", "Browse", "Purchase"],
+    "timestamp": [0, 2, 5, 0, 1, 15],  # Time in seconds
+})
+
+# Find patterns where consecutive events occur within 10 seconds
+gsp = GSP(
+    df,
+    transaction_col="transaction_id",
+    item_col="item",
+    timestamp_col="timestamp",
+    maxgap=10
+)
+patterns = gsp.search(min_support=0.5)
+```
+
+For sequence format with timestamps:
+
+```python
+import pandas as pd
+from gsppy import GSP
+
+df = pd.DataFrame({
+    "sequence": [["A", "B", "C"], ["A", "D"]],
+    "timestamps": [[1, 2, 3], [1, 5]],  # Timestamps per item
+})
+
+gsp = GSP(df, sequence_col="sequence", timestamp_col="timestamps", maxgap=3)
+patterns = gsp.search(min_support=0.5)
+```
+
+### Working with Parquet and Arrow Files
+
+DataFrames enable seamless integration with columnar storage formats:
+
+```python
+import polars as pl
+from gsppy import GSP
+
+# Read directly from Parquet
+df = pl.read_parquet("transactions.parquet")
+
+# Run GSP with automatic schema detection
+gsp = GSP(df, transaction_col="txn_id", item_col="product")
+patterns = gsp.search(min_support=0.2)
+
+# Or use Pandas with Arrow backend
+import pandas as pd
+df_pandas = pd.read_parquet("transactions.parquet", engine="pyarrow")
+gsp = GSP(df_pandas, transaction_col="txn_id", item_col="product")
+patterns = gsp.search(min_support=0.2)
+```
+
+### Performance Considerations
+
+DataFrames offer performance benefits for large datasets:
+
+- **Polars**: Leverages Arrow for zero-copy operations and parallel processing
+- **Pandas**: Compatible with Arrow backend for efficient memory usage
+- **Parquet/Arrow**: Columnar storage enables efficient filtering and reading
+- **Schema validation**: Errors are caught early with clear messages
+
+### DataFrame Schema Requirements
+
+**Grouped Format:**
+- `transaction_col`: Column containing transaction/sequence IDs (any type)
+- `item_col`: Column containing items (any type, converted to strings)
+- `timestamp_col` (optional): Column containing timestamps (numeric)
+
+**Sequence Format:**
+- `sequence_col`: Column containing lists of items
+- `timestamp_col` (optional): Column containing lists of timestamps (must match sequence lengths)
+
+### Error Handling
+
+GSP-Py provides clear error messages for schema issues:
+
+```python
+import polars as pl
+from gsppy import GSP
+
+df = pl.DataFrame({
+    "txn_id": [1, 2],
+    "product": ["A", "B"],
+})
+
+# ❌ Missing required column
+try:
+    gsp = GSP(df, transaction_col="txn_id", item_col="item")  # 'item' doesn't exist
+except ValueError as e:
+    print(f"Error: {e}")  # "Column 'item' not found in DataFrame"
+
+# ❌ Invalid format specification
+try:
+    gsp = GSP(df)  # Must specify either sequence_col or both transaction_col and item_col
+except ValueError as e:
+    print(f"Error: {e}")  # "Must specify either 'sequence_col' or both 'transaction_col' and 'item_col'"
+```
+
+### Backward Compatibility
+
+Traditional list-based input continues to work:
+
+```python
+from gsppy import GSP
+
+# Lists still work as before
+transactions = [["A", "B"], ["A", "C"], ["B", "C"]]
+gsp = GSP(transactions)
+patterns = gsp.search(min_support=0.5)
+```
+
+DataFrame parameters cannot be mixed with list input:
+
+```python
+transactions = [["A", "B"], ["C", "D"]]
+
+# ❌ This raises an error
+gsp = GSP(transactions, transaction_col="txn")  # ValueError: DataFrame parameters cannot be used with list input
+```
+
+### Examples and Tests
+
+For complete examples and edge cases, see:
+- [`tests/test_dataframe.py`](tests/test_dataframe.py) - Comprehensive test suite
+- DataFrame adapter documentation in [`gsppy/dataframe_adapters.py`](gsppy/dataframe_adapters.py)
+
+---
+
 ## ⏱️ Temporal Constraints
 
 GSP-Py supports **time-constrained sequential pattern mining** with three powerful temporal constraints: `mingap`, `maxgap`, and `maxspan`. These constraints enable domain-specific applications such as medical event mining, retail analytics, and temporal user journey discovery.
@@ -590,7 +911,7 @@ GSP-Py supports **time-constrained sequential pattern mining** with three powerf
 ### Temporal Constraint Parameters
 
 - **`mingap`**: Minimum time gap required between consecutive items in a pattern
-- **`maxgap`**: Maximum time gap allowed between consecutive items in a pattern  
+- **`maxgap`**: Maximum time gap allowed between consecutive items in a pattern
 - **`maxspan`**: Maximum time span from the first to the last item in a pattern
 
 ### Using Temporal Constraints
@@ -705,6 +1026,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 +1173,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-4.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+gsppy/__init__.py,sha256=OtUaUNorr3nCc-d-lc4JHvxGJsGtOqcSw-8J_zP7Zng,2251
+gsppy/accelerate.py,sha256=rDho3ysADETpuhT2SF9voBjd3XRaQUzuA5k_baNACF8,11020
+gsppy/cli.py,sha256=SJtF7azZeBZpvcBhhRkXWyRpJMce_h96SLRqiSVUtu0,22440
+gsppy/dataframe_adapters.py,sha256=urAu32a4YsMRnm0yGvxT_XrRHfB_EYWClHH2f4OHH8w,15773
+gsppy/enums.py,sha256=2LxMWGJNWMgjhCWv_nzKWXi4iHU1S12qns3DpBUraAw,1265
+gsppy/gsp.py,sha256=nCwzsVkOn4DqqCbxGCucpsHp9FZqGEphdJcc3fpHhrY,32743
+gsppy/pruning.py,sha256=hOoQoH1k_gzACBy6qr_cvwth9WDmKuLmJyVRDbHjFFM,14779
+gsppy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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-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,,