sparkless-testing 0.1.0__py3-none-any.whl

sparkless_testing/utils.py

@@ -0,0 +1,209 @@
+"""
+Test utilities for sparkless-testing.
+
+Helper functions for common test patterns and compatibility handling.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from .engine import get_engine
+
+
+def detect_spark_type(spark: Any) -> str:
+    """
+    Detect if spark session is PySpark or mock.
+
+    Args:
+        spark: SparkSession instance to check
+
+    Returns:
+        'pyspark', 'mock', or 'unknown'
+    """
+    # Fast-path: PySpark sessions have a JVM bridge
+    if hasattr(spark, "sparkContext") and hasattr(spark.sparkContext, "_jsc"):
+        return "pyspark"
+
+    try:
+        spark_module = type(spark).__module__
+        if "pyspark" in spark_module:
+            return "pyspark"
+        # Detect sparkless/mock sessions by module path
+        if "sparkless" in spark_module or "mock" in spark_module:
+            return "mock"
+    except Exception:
+        pass
+
+    # Fallback to engine name if available
+    try:
+        engine_config = get_engine()
+        engine_name = engine_config.engine_name
+        if engine_name in {"mock", "sparkless"}:
+            return "mock"
+        if engine_name == "pyspark":
+            return "pyspark"
+    except Exception:
+        pass
+
+    return "unknown"
+
+
+def is_dataframe_like(obj: Any) -> bool:
+    """
+    Check if object is DataFrame-like using structural typing.
+
+    Checks for essential DataFrame methods: count, columns (property), filter.
+
+    Args:
+        obj: Object to check
+
+    Returns:
+        True if object has DataFrame-like interface, False otherwise
+    """
+    # columns is typically a property (not callable), count and filter are methods
+    return (
+        hasattr(obj, "count")
+        and hasattr(obj, "columns")
+        and hasattr(obj, "filter")
+        and callable(getattr(obj, "count", None))
+        and callable(getattr(obj, "filter", None))
+    )
+
+
+def create_test_dataframe(
+    spark: Any,
+    data: Any,
+    schema: Any | None = None,
+    **kwargs: Any,
+) -> Any:
+    """
+    High-level helper for creating test DataFrames.
+
+    Provides a consistent API for creating DataFrames in tests.
+    Handles PySpark 3.5+ schema argument position differences.
+
+    Args:
+        spark: SparkSession instance (PySpark or mock-spark)
+        data: Data to create DataFrame from (list of tuples, list of dicts, etc.)
+        schema: Schema definition (list of strings, StructType, or None)
+        **kwargs: Additional arguments passed to createDataFrame
+
+    Returns:
+        DataFrame instance
+
+    Raises:
+        TypeError: If spark is not a valid SparkSession
+        ValueError: If data is invalid or schema is incompatible
+        RuntimeError: If DataFrame creation fails after all retry attempts
+    """
+    if not hasattr(spark, "createDataFrame"):
+        raise TypeError(
+            f"spark parameter must have a createDataFrame method, got {type(spark).__name__}"
+        )
+
+    create_df = spark.createDataFrame
+    last_error: Exception | None = None
+
+    # Call createDataFrame method
+    # Handle PySpark 3.5+ schema argument issues
+    if schema is None:
+        try:
+            return create_df(data, **kwargs)
+        except (TypeError, ValueError) as e:
+            raise ValueError(
+                f"Failed to create DataFrame from data: {e}. Data type: {type(data).__name__}"
+            ) from e
+        except Exception as e:
+            raise RuntimeError(f"Unexpected error creating DataFrame: {e}") from e
+    else:
+        # Try different calling patterns to handle PySpark version differences
+        # Pattern 1: Positional schema (PySpark 3.5+)
+        try:
+            if kwargs:
+                return create_df(data, schema, **kwargs)
+            else:
+                return create_df(data, schema)
+        except (TypeError, ValueError) as e:
+            error_str = str(e)
+            last_error = e
+
+            # Check if this is the PySpark StructType error (known PySpark 3.5+ bug)
+            if "NOT_LIST_OR_NONE_OR_STRUCT" in error_str:
+                # Try without kwargs
+                try:
+                    return create_df(data, schema)
+                except (TypeError, ValueError) as e2:
+                    last_error = e2
+                    # Last resort: try with schema as keyword
+                    try:
+                        return create_df(data, schema=schema, **kwargs)
+                    except (TypeError, ValueError) as e3:
+                        last_error = e3
+                        # Final fallback: try without kwargs and keyword schema
+                        try:
+                            return create_df(data, schema=schema)
+                        except (TypeError, ValueError) as e4:
+                            last_error = e4
+            else:
+                # For other errors, try keyword argument (older PySpark)
+                try:
+                    return create_df(data, schema=schema, **kwargs)
+                except (TypeError, ValueError) as e2:
+                    last_error = e2
+                    # Final fallback: try without kwargs and keyword schema
+                    try:
+                        return create_df(data, schema=schema)
+                    except (TypeError, ValueError) as e3:
+                        last_error = e3
+
+        # If we get here, all attempts failed
+        if last_error:
+            raise ValueError(
+                f"Failed to create DataFrame with schema after multiple attempts. "
+                f"Last error: {last_error}. "
+                f"Data type: {type(data).__name__}, Schema type: {type(schema).__name__}"
+            ) from last_error
+        else:
+            raise RuntimeError("Failed to create DataFrame: unknown error occurred")
+
+
+def get_spark_mode() -> str:
+    """
+    Get SPARK_MODE from environment variable.
+
+    Returns:
+        'mock', 'pyspark', or 'auto' (default)
+    """
+    return os.environ.get("SPARK_MODE", "auto").lower()
+
+
+def get_warehouse_dir() -> str | None:
+    """
+    Get custom warehouse directory from environment variable.
+
+    Returns:
+        Warehouse directory path or None
+    """
+    return os.environ.get("SPARK_TEST_WAREHOUSE_DIR")
+
+
+def get_app_name_prefix() -> str:
+    """
+    Get app name prefix from environment variable.
+
+    Returns:
+        App name prefix (default: 'sparkless-testing')
+    """
+    return os.environ.get("SPARK_TEST_APP_NAME", "sparkless-testing")
+
+
+__all__ = [
+    "detect_spark_type",
+    "is_dataframe_like",
+    "create_test_dataframe",
+    "get_spark_mode",
+    "get_warehouse_dir",
+    "get_app_name_prefix",
+]

sparkless_testing-0.1.0.dist-info/METADATA

@@ -0,0 +1,445 @@
+Metadata-Version: 2.4
+Name: sparkless-testing
+Version: 0.1.0
+Summary: Easy testing with sparkless or PySpark on demand
+Author-email: Odos Matthews <odosmatthews@gmail.com>
+Maintainer-email: Odos Matthews <odosmatthews@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/eddiethedean/sparkless-testing
+Project-URL: Repository, https://github.com/eddiethedean/sparkless-testing
+Project-URL: Issues, https://github.com/eddiethedean/sparkless-testing/issues
+Keywords: spark,pyspark,testing,pytest,sparkless,data-engineering,unit-testing,fixtures
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest>=7.0.0
+Provides-Extra: mock
+Requires-Dist: sparkless>=3.19.0; extra == "mock"
+Provides-Extra: pyspark
+Requires-Dist: pyspark<3.6.0,>=3.5.0; extra == "pyspark"
+Provides-Extra: delta
+Requires-Dist: delta-spark<4.0.0,>=3.0.0; extra == "delta"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: sparkless>=3.19.0; extra == "dev"
+Requires-Dist: pyspark<3.6.0,>=3.5.0; extra == "dev"
+Requires-Dist: delta-spark<4.0.0,>=3.0.0; extra == "dev"
+Dynamic: license-file
+
+# sparkless-testing
+
+> **Easy testing with sparkless or PySpark on demand**
+
+A Python package that simplifies running tests with either **sparkless** (mock) or **PySpark** (real) engines on demand. Write tests once, run them with either engine seamlessly.
+
+## Why sparkless-testing?
+
+- 🚀 **Fast Mock Testing**: Use `sparkless` for lightning-fast unit tests without JVM overhead
+- 🔄 **Real Engine Validation**: Test against real PySpark to catch integration issues
+- 🎯 **Single Test Suite**: Write tests once, run with both engines automatically
+- 🔧 **Zero Configuration**: Automatic engine detection and session management
+- ⚡ **Parallel Ready**: Optimized for parallel test execution with pytest-xdist
+
+## Features
+
+- **Automatic Engine Detection** - Automatically detects and configures available engines
+- **Pytest Fixtures** - Ready-to-use fixtures for both engines
+- **Session Management** - Automatic session creation, cleanup, and isolation
+- **Test Utilities** - Helpers for common test patterns
+- **Parametrization Support** - Run tests with both engines automatically
+- **Parallel Testing Support** - Optimized for parallel test execution with pytest-xdist
+
+## Installation
+
+```bash
+pip install sparkless-testing
+```
+
+For specific engines:
+
+```bash
+# Install with mock engine (sparkless)
+pip install sparkless-testing[mock]
+
+# Install with PySpark engine
+pip install sparkless-testing[pyspark]
+
+# Install with Delta Lake support
+pip install sparkless-testing[delta]
+
+# Install with all engines
+pip install sparkless-testing[dev]
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+import pytest
+from sparkless_testing import pytest_fixtures
+
+# Use the spark_session fixture
+def test_my_function(spark_session):
+    df = spark_session.createDataFrame([{"id": 1, "name": "Alice"}])
+    assert df.count() == 1
+    assert df.collect()[0]["name"] == "Alice"
+```
+
+### Explicit Engine Selection
+
+```python
+def test_mock_only(mock_spark_session):
+    # Only runs with sparkless
+    df = mock_spark_session.createDataFrame([{"id": 1}])
+    assert df.count() == 1
+
+def test_pyspark_only(pyspark_session):
+    # Only runs with PySpark
+    df = pyspark_session.createDataFrame([{"id": 1}])
+    assert df.count() == 1
+```
+
+### Using Functions and Types
+
+```python
+def test_with_functions(spark_session, spark_functions, spark_types):
+    F = spark_functions
+    Types = spark_types
+    
+    df = spark_session.createDataFrame([{"name": "Alice"}])
+    result = df.select(F.upper(F.col("name"))).collect()
+    assert result[0][0] == "ALICE"
+```
+
+**Note**: Always use `spark_functions` together with `spark_session`. PySpark functions like `F.col()` require an active SparkContext, which is provided by the `spark_session` fixture.
+
+### Parametrized Tests (Both Engines)
+
+You can run tests with both engines in two ways:
+
+**Option 1: Using the decorator**
+```python
+@pytest.mark.parametrize_engines
+def test_both_engines(spark_session):
+    # Runs with both engines automatically
+    df = spark_session.createDataFrame([{"id": 1}])
+    assert df.count() == 1
+```
+
+**Option 2: Using the `both_engines` fixture**
+```python
+def test_both_engines(both_engines):
+    spark, engine_type = both_engines
+    # Runs with both engines automatically
+    df = spark.createDataFrame([{"id": 1}])
+    assert df.count() == 1
+    # engine_type will be EngineType.MOCK or EngineType.PYSPARK
+```
+
+### Environment-Based Configuration
+
+```bash
+# Run tests with mock engine
+SPARK_MODE=mock pytest tests/
+
+# Run tests with PySpark engine
+SPARK_MODE=pyspark pytest tests/
+
+# Auto-detect (default)
+SPARK_MODE=auto pytest tests/
+```
+
+### Pytest Markers
+
+```python
+@pytest.mark.spark_engine("mock")
+def test_mock_specific(spark_session):
+    # Forces mock engine
+    pass
+
+@pytest.mark.spark_engine("pyspark")
+def test_pyspark_specific(spark_session):
+    # Forces PySpark engine
+    pass
+```
+
+## Configuration
+
+### Environment Variables
+
+- `SPARK_MODE`: `mock`, `pyspark`, or `auto` (default: `auto`)
+- `SPARK_TEST_WAREHOUSE_DIR`: Custom warehouse directory for PySpark tests
+- `SPARK_TEST_APP_NAME`: Custom app name prefix (default: `sparkless-testing`)
+
+### Programmatic Configuration
+
+```python
+from sparkless_testing import (
+    EngineType,
+    SessionConfig,
+    auto_configure_engine,
+    create_session,
+    create_pyspark_session,
+)
+
+# Auto-configure based on availability
+auto_configure_engine()
+
+# Or specify preferred engine
+auto_configure_engine(EngineType.MOCK)
+
+# Create session manually
+spark = create_session(engine_type=EngineType.MOCK)
+
+# Create session with custom configuration
+config = SessionConfig(
+    app_name="my-test",
+    enable_delta=True,
+    shuffle_partitions=2,
+)
+spark = create_pyspark_session(config=config)
+# ... use spark ...
+spark.stop()
+```
+
+## API Reference
+
+### Engine Configuration
+
+- `EngineType`: Enum for engine types (`MOCK`, `PYSPARK`, `AUTO`)
+- `configure_engine()`: Manually configure engine components
+- `get_engine()`: Get current engine configuration
+- `detect_available_engines()`: Check which engines are installed
+- `auto_configure_engine()`: Automatically configure based on availability
+
+### Session Factory
+
+- `create_mock_session()`: Create sparkless session
+- `create_pyspark_session()`: Create PySpark session
+- `create_session()`: Factory function that creates appropriate session
+- `SessionConfig`: Configuration dataclass for session creation
+  - `app_name`: Application name for the Spark session
+  - `warehouse_dir`: Custom warehouse directory (optional)
+  - `enable_delta`: Enable Delta Lake support (default: `True` for programmatic use, `False` in test fixtures)
+  - `enable_ui`: Enable Spark UI (default: `False`)
+  - `shuffle_partitions`: Number of shuffle partitions (default: `1`)
+  - `parallelism`: Default parallelism (default: `1`)
+  - `adaptive_enabled`: Enable adaptive query execution (default: `False`)
+
+### Test Utilities
+
+- `detect_spark_type(spark)`: Detect if session is PySpark or mock
+- `create_test_dataframe(spark, data, schema)`: Compatibility wrapper for DataFrame creation
+- `is_dataframe_like(obj)`: Check if object is DataFrame-like
+
+### Pytest Fixtures
+
+- `spark_session`: Main fixture (auto-detects engine based on `SPARK_MODE` or markers)
+- `mock_spark_session`: Explicitly use sparkless (mock) engine
+- `pyspark_session`: Explicitly use PySpark (real) engine
+- `both_engines`: Fixture that yields `(spark, engine_type)` for both engines (parametrized)
+- `spark_functions`: Functions module (F) for current engine
+- `spark_types`: Types module for current engine
+- `spark_engine_type`: Current engine type as string (`"mock"` or `"pyspark"`)
+
+**Note**: Test fixtures automatically disable Delta Lake for parallel testing compatibility. To use Delta Lake, create sessions programmatically with `enable_delta=True` in `SessionConfig`.
+
+## Advanced Usage
+
+### Custom Session Configuration
+
+```python
+from sparkless_testing import SessionConfig, create_pyspark_session
+
+def test_with_custom_config():
+    config = SessionConfig(
+        app_name="custom-test",
+        warehouse_dir="/tmp/my-warehouse",
+        enable_delta=True,
+        enable_ui=True,
+        shuffle_partitions=4,
+        parallelism=4,
+    )
+    spark = create_pyspark_session(config=config)
+    # ... your test code ...
+    spark.stop()
+```
+
+### Parallel Test Execution
+
+```bash
+# Run tests in parallel with pytest-xdist
+pytest -n 2  # Use 2 workers
+pytest -n auto  # Auto-detect worker count
+```
+
+**Best Practices for Parallel Testing:**
+- Mock (sparkless) tests can run with high parallelism (`-n 10+`)
+- PySpark tests work best with fewer workers (`-n 2` or `-n 4`)
+- Test fixtures automatically disable Delta Lake to avoid conflicts
+- Each test gets a unique session name and warehouse directory
+
+### Using Test Utilities
+
+```python
+from sparkless_testing.utils import create_test_dataframe, detect_spark_type
+
+def test_with_utilities(spark_session):
+    # Create DataFrame with schema handling
+    data = [("Alice", 25), ("Bob", 30)]
+    schema = ["name", "age"]
+    df = create_test_dataframe(spark_session, data, schema)
+    
+    # Detect engine type
+    engine = detect_spark_type(spark_session)
+    assert engine in ("mock", "pyspark")
+```
+
+## Examples
+
+### Complete Test Example
+
+```python
+import pytest
+from sparkless_testing.pytest_fixtures import spark_session, spark_functions
+
+def test_data_transformation(spark_session, spark_functions):
+    F = spark_functions
+    
+    # Create test data
+    data = [
+        {"id": 1, "name": "Alice", "age": 25},
+        {"id": 2, "name": "Bob", "age": 30},
+    ]
+    df = spark_session.createDataFrame(data)
+    
+    # Transform data
+    result = (
+        df.filter(F.col("age") > 25)
+        .select("name", "age")
+        .collect()
+    )
+    
+    # Assertions
+    assert len(result) == 1
+    assert result[0]["name"] == "Bob"
+```
+
+### Using with Both Engines
+
+```python
+@pytest.mark.parametrize_engines
+def test_compatibility(spark_session, spark_engine_type):
+    # This test runs with both engines
+    df = spark_session.createDataFrame([{"value": 42}])
+    
+    # Engine-specific logic if needed
+    if spark_engine_type == "mock":
+        # Mock-specific assertions
+        pass
+    else:
+        # PySpark-specific assertions
+        pass
+    
+    assert df.count() == 1
+```
+
+## Troubleshooting
+
+### Tests Hang with Parallel Execution
+
+If tests hang when using `pytest -n`, try:
+- Use fewer workers: `pytest -n 2` instead of `pytest -n 10`
+- Run PySpark tests sequentially: `pytest -n 0` for PySpark-only tests
+- Use mock engine for faster parallel execution: `SPARK_MODE=mock pytest -n 10`
+
+### Delta Lake Not Available
+
+Delta Lake is disabled by default in test fixtures. To enable:
+```python
+from sparkless_testing import SessionConfig, create_pyspark_session
+
+config = SessionConfig(app_name="test", enable_delta=True)
+spark = create_pyspark_session(config=config)
+```
+
+### SparkContext Errors
+
+Always use `spark_functions` together with `spark_session`:
+```python
+def test_correct(spark_session, spark_functions):  # ✅ Correct
+    F = spark_functions
+    df = spark_session.createDataFrame([{"x": 1}])
+    result = df.select(F.col("x")).collect()
+
+def test_incorrect(spark_functions):  # ❌ May fail with PySpark
+    F = spark_functions
+    # Missing active SparkContext
+```
+
+## Migration Guide
+
+### From Manual Engine Switching
+
+**Before:**
+```python
+import os
+from sparkless import SparkSession as MockSparkSession
+from pyspark.sql import SparkSession as PySparkSession
+
+def test_my_function():
+    if os.environ.get("SPARK_MODE") == "mock":
+        spark = MockSparkSession("test")
+    else:
+        spark = PySparkSession.builder.appName("test").getOrCreate()
+    # ... test code ...
+    spark.stop()
+```
+
+**After:**
+```python
+from sparkless_testing.pytest_fixtures import spark_session
+
+def test_my_function(spark_session):
+    # ... test code ...
+    # spark_session is automatically cleaned up
+```
+
+## Requirements
+
+- Python 3.9+
+- pytest 7.0+
+
+Optional:
+- sparkless>=3.19.0 (for mock engine)
+- pyspark>=3.5.0 (for real engine)
+- delta-spark>=3.0.0 (for Delta Lake support)
+- pytest-xdist (for parallel test execution)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Links
+
+- **GitHub**: [github.com/eddiethedean/sparkless-testing](https://github.com/eddiethedean/sparkless-testing)
+- **Issues**: [github.com/eddiethedean/sparkless-testing/issues](https://github.com/eddiethedean/sparkless-testing/issues)
+
+---
+
+**Made with ❤️ for the data engineering community**
+

sparkless_testing-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sparkless_testing/__init__.py,sha256=cXNVuRYhRyk2BgIpwGHDMu1lLVwnF3JC6MPaSUxEiuA,1839
+sparkless_testing/conftest.py,sha256=TsZDs4Y_-4bQawVrirKpOvHjqN6SDuMwYK9GZ8XOBqc,887
+sparkless_testing/engine.py,sha256=lLlhiCwJzabA4qEfhNgY6_pEVjHiGNvk8qgU-Wcg-3Q,9634
+sparkless_testing/parametrize.py,sha256=Pqbvp2AlsioiuGVJVOlKd5Ldw397tBjlEtkCR9dgTrs,5315
+sparkless_testing/protocols.py,sha256=SzGWpy5extMKxznvT9cyviWwKSJd8ZnH21nCpIq8nSQ,4321
+sparkless_testing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sparkless_testing/pytest_fixtures.py,sha256=WvxFqxHabid4gRISliZU9QaohMfUZHx9FCwcXejwCVI,7312
+sparkless_testing/session.py,sha256=UoQT5Kkp2bhiLMfQRw6qDxkQhIItW4h79EOLbHG9l3I,8597
+sparkless_testing/utils.py,sha256=Km1tKXGvhwtdcDfPgvLYZWhzObylObkIJpeD2Bdi-Ks,6561
+sparkless_testing-0.1.0.dist-info/licenses/LICENSE,sha256=7d2e2UstJQ5UphPnHa3djO30rYc3Q92LascNZuSM4J0,1071
+sparkless_testing-0.1.0.dist-info/METADATA,sha256=0-4Pw54wBWkR88E8mpIgGrQ2jcwUbc3RsLcQFS0gFCg,13313
+sparkless_testing-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sparkless_testing-0.1.0.dist-info/top_level.txt,sha256=hyXY8iujz_qcsS1amyKStVYg7Y0DqmBURJP_EqYKnzk,18
+sparkless_testing-0.1.0.dist-info/RECORD,,

sparkless_testing-0.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
+

sparkless_testing-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Odos Matthews
+
+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.
+

sparkless_testing-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sparkless_testing