splurge-dsv 2025.1.0__py3-none-any.whl

splurge_dsv/text_file_helper.py

@@ -0,0 +1,343 @@
+"""
+Text file utility functions for common file operations.
+
+This module provides helper methods for working with text files, including
+line counting, file previewing, and file loading capabilities. The TextFileHelper
+class implements static methods for efficient file operations without requiring
+class instantiation.
+
+Key features:
+- Line counting for text files
+- File previewing with configurable line limits
+- Complete file loading with header/footer skipping
+- Streaming file loading with configurable chunk sizes
+- Configurable whitespace handling and encoding
+- Secure file path validation
+- Resource management with context managers
+
+Copyright (c) 2025 Jim Schilling
+
+Please preserve this header and all related material when sharing!
+
+This module is licensed under the MIT License.
+"""
+
+from collections import deque
+from os import PathLike
+from pathlib import Path
+from typing import Iterator
+
+from splurge_dsv.exceptions import (
+    SplurgeParameterError,
+    SplurgeFileEncodingError
+)
+from splurge_dsv.path_validator import PathValidator
+from splurge_dsv.resource_manager import safe_file_operation
+
+
+class TextFileHelper:
+    """
+    Utility class for text file operations.
+    All methods are static and memory efficient.
+    """
+
+    DEFAULT_ENCODING = "utf-8"
+    DEFAULT_MAX_LINES = 100
+    DEFAULT_CHUNK_SIZE = 500
+    DEFAULT_MIN_CHUNK_SIZE = 100
+    DEFAULT_SKIP_HEADER_ROWS = 0
+    DEFAULT_SKIP_FOOTER_ROWS = 0
+    DEFAULT_STRIP = True
+    DEFAULT_MODE = "r"
+
+    @classmethod
+    def line_count(
+        cls,
+        file_path: PathLike[str] | str,
+        *,
+        encoding: str = DEFAULT_ENCODING
+    ) -> int:
+        """
+        Count the number of lines in a text file.
+
+        This method efficiently counts lines by iterating through the file
+        without loading it entirely into memory.
+
+        Args:
+            file_path: Path to the text file
+            encoding: File encoding to use (default: 'utf-8')
+
+        Returns:
+            int: Number of lines in the file
+
+        Raises:
+            SplurgeFileNotFoundError: If the specified file doesn't exist
+            SplurgeFilePermissionError: If there are permission issues
+            SplurgeFileEncodingError: If the file cannot be decoded with the specified encoding
+            SplurgePathValidationError: If file path validation fails
+        """
+        # Validate file path
+        validated_path = PathValidator.validate_path(
+            Path(file_path),
+            must_exist=True,
+            must_be_file=True,
+            must_be_readable=True
+        )
+        
+        with safe_file_operation(validated_path, encoding=encoding, mode=cls.DEFAULT_MODE) as stream:
+            return sum(1 for _ in stream)
+
+    @classmethod
+    def preview(
+        cls,
+        file_path: PathLike[str] | str,
+        *,
+        max_lines: int = DEFAULT_MAX_LINES,
+        strip: bool = DEFAULT_STRIP,
+        encoding: str = DEFAULT_ENCODING,
+        skip_header_rows: int = DEFAULT_SKIP_HEADER_ROWS
+    ) -> list[str]:
+        """
+        Preview the first N lines of a text file.
+
+        This method reads up to max_lines from the beginning of the file,
+        optionally stripping whitespace from each line and skipping header rows.
+
+        Args:
+            file_path: Path to the text file
+            max_lines: Maximum number of lines to read (default: 100)
+            strip: Whether to strip whitespace from lines (default: True)
+            encoding: File encoding to use (default: 'utf-8')
+            skip_header_rows: Number of rows to skip from the start (default: 0)
+
+        Returns:
+            list[str]: List of lines from the file
+
+        Raises:
+            SplurgeParameterError: If max_lines < 1
+            SplurgeFileNotFoundError: If the specified file doesn't exist
+            SplurgeFilePermissionError: If there are permission issues
+            SplurgeFileEncodingError: If the file cannot be decoded with the specified encoding
+            SplurgePathValidationError: If file path validation fails
+        """
+        if max_lines < 1:
+            raise SplurgeParameterError(
+                "TextFileHelper.preview: max_lines is less than 1",
+                details="max_lines must be at least 1"
+            )
+               
+        # Validate file path
+        validated_path = PathValidator.validate_path(
+            Path(file_path),
+            must_exist=True,
+            must_be_file=True,
+            must_be_readable=True
+        )
+        
+        skip_header_rows = max(skip_header_rows, cls.DEFAULT_SKIP_HEADER_ROWS)
+        lines: list[str] = []
+        
+        with safe_file_operation(validated_path, encoding=encoding, mode=cls.DEFAULT_MODE) as stream:
+            # Skip header rows
+            for _ in range(skip_header_rows):
+                if not stream.readline():
+                    return lines
+            
+            # Read up to max_lines after skipping headers
+            for _ in range(max_lines):
+                line = stream.readline()
+                if not line:
+                    break
+                lines.append(line.strip() if strip else line.rstrip("\n"))
+        
+        return lines
+
+    @classmethod
+    def read_as_stream(
+        cls,
+        file_path: PathLike[str] | str,
+        *,
+        strip: bool = DEFAULT_STRIP,
+        encoding: str = DEFAULT_ENCODING,
+        skip_header_rows: int = DEFAULT_SKIP_HEADER_ROWS,
+        skip_footer_rows: int = DEFAULT_SKIP_FOOTER_ROWS,
+        chunk_size: int = DEFAULT_CHUNK_SIZE
+    ) -> Iterator[list[str]]:
+        """
+        Read a text file as a stream of line chunks.
+
+        This method yields chunks of lines from the file, allowing for
+        memory-efficient processing of large files. Each chunk contains
+        up to chunk_size lines. Uses a sliding window approach to handle
+        footer row skipping without loading the entire file into memory.
+
+        Args:
+            file_path: Path to the text file
+            strip: Whether to strip whitespace from lines (default: True)
+            encoding: File encoding to use (default: 'utf-8')
+            skip_header_rows: Number of rows to skip from the start (default: 0)
+            skip_footer_rows: Number of rows to skip from the end (default: 0)
+            chunk_size: Number of lines per chunk (default: 500)
+
+        Yields:
+            List[str]: Chunks of lines from the file
+
+        Raises:
+            SplurgeFileNotFoundError: If the specified file doesn't exist
+            SplurgeFilePermissionError: If there are permission issues
+            SplurgeFileEncodingError: If the file cannot be decoded with the specified encoding
+            SplurgePathValidationError: If file path validation fails
+        """
+        # Ensure minimum chunk size
+        chunk_size = max(chunk_size, cls.DEFAULT_MIN_CHUNK_SIZE)
+        skip_header_rows = max(skip_header_rows, cls.DEFAULT_SKIP_HEADER_ROWS)
+        skip_footer_rows = max(skip_footer_rows, cls.DEFAULT_SKIP_FOOTER_ROWS)
+        
+        # Validate file path
+        validated_path = PathValidator.validate_path(
+            Path(file_path),
+            must_exist=True,
+            must_be_file=True,
+            must_be_readable=True
+        )               
+        
+        with safe_file_operation(validated_path, encoding=encoding, mode=cls.DEFAULT_MODE) as stream:
+            # Skip header rows
+            for _ in range(skip_header_rows):
+                if not stream.readline():
+                    return
+            
+            # Use a sliding window to handle footer skipping efficiently
+            if skip_footer_rows > 0:
+                # Buffer to hold the last skip_footer_rows lines
+                buffer: deque[str] = deque(maxlen=skip_footer_rows + 1)
+                current_chunk: list[str] = []
+                
+                for line in stream:
+                    processed_line = line.strip() if strip else line.rstrip("\n")
+                    
+                    # Add current line to buffer
+                    buffer.append(processed_line)
+                    
+                    # Wait until the buffer is full (skip_footer_rows + 1 lines) before processing lines.
+                    # This ensures we have enough lines to reliably identify and skip the footer rows at the end.
+                    if len(buffer) < skip_footer_rows + 1:
+                        continue
+                    
+                    # Once the buffer contains more than skip_footer_rows lines, the oldest line (removed with popleft)
+                    # is guaranteed not to be part of the footer and can be safely processed and added to the current chunk.
+                    safe_line = buffer.popleft()
+                    current_chunk.append(safe_line)
+                    
+                    # Yield chunk when it reaches the desired size
+                    if len(current_chunk) >= chunk_size:
+                        yield current_chunk
+                        current_chunk = []
+                
+                # At the end, the buffer contains exactly the footer rows to skip
+                # All other lines have already been processed and yielded
+                
+                # Yield any remaining lines in the final chunk
+                if current_chunk:
+                    yield current_chunk
+            else:
+                # No footer skipping needed - simple streaming
+                chunk: list[str] = []
+                
+                for line in stream:
+                    processed_line = line.strip() if strip else line.rstrip("\n")
+                    chunk.append(processed_line)
+                    
+                    # Yield chunk when it reaches the desired size
+                    if len(chunk) >= chunk_size:
+                        yield chunk
+                        chunk = []
+                
+                # Yield any remaining lines in the final chunk
+                if chunk:
+                    yield chunk
+
+    @classmethod
+    def read(
+        cls,
+        file_path: PathLike[str] | str,
+        *,
+        strip: bool = DEFAULT_STRIP,
+        encoding: str = DEFAULT_ENCODING,
+        skip_header_rows: int = DEFAULT_SKIP_HEADER_ROWS,
+        skip_footer_rows: int = DEFAULT_SKIP_FOOTER_ROWS
+    ) -> list[str]:
+        """
+        Read the entire contents of a text file into a list of strings.
+
+        This method reads the complete file into memory, with options to
+        strip whitespace from each line and skip header/footer rows.
+
+        Args:
+            file_path: Path to the text file
+            strip: Whether to strip whitespace from lines (default: True)
+            encoding: File encoding to use (default: 'utf-8')
+            skip_header_rows: Number of rows to skip from the start (default: 0)
+            skip_footer_rows: Number of rows to skip from the end (default: 0)
+
+        Returns:
+            List[str]: List of all lines from the file, excluding skipped rows
+
+        Raises:
+            SplurgeFileNotFoundError: If the specified file doesn't exist
+            SplurgeFilePermissionError: If there are permission issues
+            SplurgeFileEncodingError: If the file cannot be decoded with the specified encoding
+            SplurgePathValidationError: If file path validation fails
+        """
+        # Validate file path
+        validated_path = PathValidator.validate_path(
+            Path(file_path),
+            must_exist=True,
+            must_be_file=True,
+            must_be_readable=True
+        )
+                      
+        skip_header_rows = max(skip_header_rows, cls.DEFAULT_SKIP_HEADER_ROWS)
+        skip_footer_rows = max(skip_footer_rows, cls.DEFAULT_SKIP_FOOTER_ROWS)
+        
+        with safe_file_operation(validated_path, encoding=encoding, mode=cls.DEFAULT_MODE) as stream:
+            for _ in range(skip_header_rows):
+                if not stream.readline():
+                    return []
+            
+            try:
+                if skip_footer_rows > 0:
+                    # Buffer to hold the last skip_footer_rows + 1 lines
+                    buffer = deque(maxlen=skip_footer_rows + 1)
+                    result: list[str] = []
+                    
+                    for line in stream:
+                        processed_line = line.strip() if strip else line.rstrip("\n")
+                        
+                        # Add current line to buffer
+                        buffer.append(processed_line)
+                        
+                        # Wait until the buffer is full (skip_footer_rows + 1 lines) before processing lines.
+                        # This ensures we have enough lines to reliably identify and skip the footer rows at the end.
+                        if len(buffer) < skip_footer_rows + 1:
+                            continue
+                        
+                        # Once the buffer contains more than skip_footer_rows lines, the oldest line (removed with popleft)
+                        # is guaranteed not to be part of the footer and can be safely processed and added to the result.
+                        safe_line = buffer.popleft()
+                        result.append(safe_line)
+                    
+                    # At the end, the buffer contains exactly the footer rows to skip
+                    # All other lines have already been processed and added to result
+                    return result
+                else:
+                    result: list[str] = []
+                    for line in stream:
+                        processed_line = line.strip() if strip else line.rstrip("\n")
+                        result.append(processed_line)
+                    return result
+            except UnicodeDecodeError as e:
+                raise SplurgeFileEncodingError(
+                    f"Encoding error reading file: {validated_path}",
+                    details=str(e)
+                )

splurge_dsv-2025.1.0.dist-info/METADATA

@@ -0,0 +1,292 @@
+Metadata-Version: 2.4
+Name: splurge-dsv
+Version: 2025.1.0
+Summary: A utility library for working with DSV (Delimited String Values) files
+Author: Jim Schilling
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jim-schilling/splurge-dsv
+Project-URL: Repository, https://github.com/jim-schilling/splurge-dsv
+Project-URL: Documentation, https://github.com/jim-schilling/splurge-dsv#readme
+Project-URL: Bug Tracker, https://github.com/jim-schilling/splurge-dsv/issues
+Keywords: dsv,csv,tsv,delimited,parsing,file-processing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Filters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0.0; extra == "dev"
+Dynamic: license-file
+
+# splurge-dsv
+
+A robust Python library for parsing and processing delimited-separated value (DSV) files with advanced features for data validation, streaming, and error handling.
+
+## Features
+
+### 🔧 Core Functionality
+- **Multi-format DSV Support**: Parse CSV, TSV, pipe-delimited, semicolon-delimited, and custom delimiter files
+- **Flexible Parsing Options**: Configurable whitespace handling, bookend removal, and encoding support
+- **Memory-Efficient Streaming**: Process large files without loading entire content into memory
+- **Header/Footer Skipping**: Skip specified numbers of rows from start or end of files
+- **Unicode Support**: Full Unicode character and delimiter support
+
+### 🛡️ Security & Validation
+- **Path Validation**: Comprehensive file path security validation with traversal attack prevention
+- **File Permission Checks**: Automatic file accessibility and permission validation
+- **Encoding Validation**: Robust encoding error detection and handling
+- **Resource Management**: Automatic file handle cleanup and resource management
+
+### 📊 Advanced Processing
+- **Chunked Processing**: Configurable chunk sizes for streaming large datasets
+- **Mixed Content Handling**: Support for quoted and unquoted values in the same file
+- **Line Ending Flexibility**: Automatic handling of different line ending formats
+- **Error Recovery**: Graceful error handling with detailed error messages
+
+### 🧪 Testing & Quality
+- **Comprehensive Test Suite**: 90%+ code coverage with 250+ tests
+- **Cross-Platform Support**: Tested on Windows, Linux, and macOS
+- **Type Safety**: Full type annotations and validation
+- **Documentation**: Complete API documentation with examples
+
+## Installation
+
+```bash
+pip install splurge-dsv
+```
+
+## Quick Start
+
+### Basic CSV Parsing
+
+```python
+from splurge_dsv import DsvHelper
+
+# Parse a simple CSV string
+data = DsvHelper.parse("a,b,c", delimiter=",")
+print(data)  # ['a', 'b', 'c']
+
+# Parse a CSV file
+rows = DsvHelper.parse_file("data.csv", delimiter=",")
+for row in rows:
+    print(row)  # ['col1', 'col2', 'col3']
+```
+
+### Streaming Large Files
+
+```python
+from splurge_dsv import DsvHelper
+
+# Stream a large CSV file in chunks
+for chunk in DsvHelper.parse_stream("large_file.csv", delimiter=",", chunk_size=1000):
+    for row in chunk:
+        process_row(row)
+```
+
+### Advanced Parsing Options
+
+```python
+from splurge_dsv import DsvHelper
+
+# Parse with custom options
+data = DsvHelper.parse(
+    '"a","b","c"',
+    delimiter=",",
+    bookend='"',
+    strip=True,
+    bookend_strip=True
+)
+print(data)  # ['a', 'b', 'c']
+
+# Skip header and footer rows
+rows = DsvHelper.parse_file(
+    "data.csv",
+    delimiter=",",
+    skip_header_rows=1,
+    skip_footer_rows=2
+)
+```
+
+### Text File Operations
+
+```python
+from splurge_dsv import TextFileHelper
+
+# Count lines in a file
+line_count = TextFileHelper.line_count("data.txt")
+
+# Preview first N lines
+preview = TextFileHelper.preview("data.txt", max_lines=10)
+
+# Read entire file with options
+lines = TextFileHelper.read(
+    "data.txt",
+    strip=True,
+    skip_header_rows=1,
+    skip_footer_rows=1
+)
+
+# Stream file content
+for chunk in TextFileHelper.read_as_stream("large_file.txt", chunk_size=500):
+    process_chunk(chunk)
+```
+
+### Path Validation
+
+```python
+from splurge_dsv import PathValidator
+
+# Validate a file path
+valid_path = PathValidator.validate_path(
+    "data.csv",
+    must_exist=True,
+    must_be_file=True,
+    must_be_readable=True
+)
+
+# Check if path is safe
+is_safe = PathValidator.is_safe_path("user_input_path.txt")
+```
+
+## API Reference
+
+### DsvHelper
+
+Main class for DSV parsing operations.
+
+#### Methods
+
+- `parse(content, delimiter, strip=True, bookend=None, bookend_strip=True)` - Parse a single string
+- `parses(content_list, delimiter, strip=True, bookend=None, bookend_strip=True)` - Parse multiple strings
+- `parse_file(file_path, delimiter, strip=True, bookend=None, bookend_strip=True, skip_header_rows=0, skip_footer_rows=0, encoding='utf-8')` - Parse a file
+- `parse_stream(file_path, delimiter, strip=True, bookend=None, bookend_strip=True, skip_header_rows=0, skip_footer_rows=0, encoding='utf-8', chunk_size=500)` - Stream parse a file
+
+### TextFileHelper
+
+Utility class for text file operations.
+
+#### Methods
+
+- `line_count(file_path, encoding='utf-8')` - Count lines in a file
+- `preview(file_path, max_lines=100, strip=True, encoding='utf-8', skip_header_rows=0)` - Preview file content
+- `read(file_path, strip=True, encoding='utf-8', skip_header_rows=0, skip_footer_rows=0)` - Read entire file
+- `read_as_stream(file_path, strip=True, encoding='utf-8', skip_header_rows=0, skip_footer_rows=0, chunk_size=500)` - Stream read file
+
+### PathValidator
+
+Security-focused path validation utilities.
+
+#### Methods
+
+- `validate_path(file_path, must_exist=False, must_be_file=False, must_be_readable=False, allow_relative=False, base_directory=None)` - Validate file path
+- `is_safe_path(file_path)` - Check if path is safe
+- `sanitize_filename(filename, default_name='file')` - Sanitize filename
+
+### ResourceManager
+
+Context managers for safe resource handling.
+
+#### Classes
+
+- `FileResourceManager` - Context manager for file operations
+- `StreamResourceManager` - Context manager for stream operations
+
+#### Functions
+
+- `safe_file_operation(file_path, mode='r', encoding='utf-8', ...)` - Safe file operation context manager
+- `safe_stream_operation(stream, auto_close=True)` - Safe stream operation context manager
+
+## Error Handling
+
+The library provides comprehensive error handling with custom exception classes:
+
+- `SplurgeParameterError` - Invalid parameter values
+- `SplurgeFileNotFoundError` - File not found
+- `SplurgeFilePermissionError` - File permission issues
+- `SplurgeFileEncodingError` - File encoding problems
+- `SplurgePathValidationError` - Path validation failures
+- `SplurgeResourceAcquisitionError` - Resource acquisition failures
+- `SplurgeResourceReleaseError` - Resource cleanup failures
+
+## Development
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest tests/ -v
+
+# Run with coverage
+pytest tests/ --cov=splurge_dsv --cov-report=html
+
+# Run specific test file
+pytest tests/test_dsv_helper.py -v
+```
+
+### Code Quality
+
+The project follows strict coding standards:
+- PEP 8 compliance
+- Type annotations for all functions
+- Google-style docstrings
+- 90%+ test coverage requirement
+- Comprehensive error handling
+
+## Changelog
+
+### 2025.1.0 (2025-08-25)
+
+#### 🎉 Major Features
+- **Complete DSV Parser**: Full-featured delimited-separated value parser with support for CSV, TSV, and custom delimiters
+- **Streaming Support**: Memory-efficient streaming for large files with configurable chunk sizes
+- **Advanced Parsing Options**: Bookend removal, whitespace handling, and encoding support
+- **Header/Footer Skipping**: Skip specified numbers of rows from start or end of files
+
+#### 🛡️ Security Enhancements
+- **Path Validation System**: Comprehensive file path security validation with traversal attack prevention
+- **File Permission Checks**: Automatic file accessibility and permission validation
+- **Encoding Validation**: Robust encoding error detection and handling
+
+#### 🔧 Core Components
+- **DsvHelper**: Main DSV parsing class with parse, parses, parse_file, and parse_stream methods
+- **TextFileHelper**: Utility class for text file operations (line counting, preview, reading, streaming)
+- **PathValidator**: Security-focused path validation utilities
+- **ResourceManager**: Context managers for safe resource handling
+- **StringTokenizer**: Core string parsing functionality
+
+#### 🧪 Testing & Quality
+- **Comprehensive Test Suite**: 250+ tests with 90%+ code coverage
+- **Cross-Platform Testing**: Tested on Windows, Linux, and macOS
+- **Type Safety**: Full type annotations throughout the codebase
+- **Error Handling**: Custom exception hierarchy with detailed error messages
+
+#### 📚 Documentation
+- **Complete API Documentation**: Google-style docstrings for all public methods
+- **Usage Examples**: Comprehensive examples for all major features
+- **Error Documentation**: Detailed error handling documentation
+
+#### 🚀 Performance
+- **Memory Efficiency**: Streaming support for large files
+- **Optimized Parsing**: Efficient string tokenization and processing
+- **Resource Management**: Automatic cleanup and resource management
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+## Support
+
+For support, please open an issue on the GitHub repository or contact the maintainers.

splurge_dsv-2025.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+splurge_dsv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+splurge_dsv/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+splurge_dsv/dsv_helper.py,sha256=gv9Wwf_soqdXuZWkBpxSyvJVqryKDfEoSf9SoAaRX1A,9651
+splurge_dsv/exceptions.py,sha256=tPVLXxf8LPc0yd8L8xjik331B4-NUVYfyd6ifPLUtm4,3052
+splurge_dsv/path_validator.py,sha256=2vXsNnmRTLbdYedDrF5kQZsOUvfLhSxkXyRj26OZyj8,10036
+splurge_dsv/resource_manager.py,sha256=fldvZQpzznANf4ahHre_lSqQ5_FUWndFuSlyccBylGE,13013
+splurge_dsv/string_tokenizer.py,sha256=GDAtJht-d9vt8Kb4yglxfl2iMfSMWGT3esksISNklMU,4203
+splurge_dsv/text_file_helper.py,sha256=htYT1Z0aKuQt24X2IfSKnFHB1AOY3dV7lRU8Vr6iqn0,14237
+splurge_dsv-2025.1.0.dist-info/licenses/LICENSE,sha256=fPgtg-tIFHinQvJH0arRfv50AuxikD5eHw6rrPy2A5w,1091
+splurge_dsv-2025.1.0.dist-info/METADATA,sha256=MUa4M1124GYLHmOYzLIne6-s_biC8wFi9a1PaBEmMXA,10282
+splurge_dsv-2025.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+splurge_dsv-2025.1.0.dist-info/top_level.txt,sha256=D6Si3FTfpRYqH7kzM7tSQAyaKbbraO6UPLpcqcY4XXM,12
+splurge_dsv-2025.1.0.dist-info/RECORD,,

splurge_dsv-2025.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

splurge_dsv-2025.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jim Schilling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

splurge_dsv-2025.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+splurge_dsv