sas2parquet 0.1.0__py3-none-any.whl

sas2parquet/cli.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+"""CLI entrypoint for sas2parquet."""
+import argparse
+import sys
+from pathlib import Path
+from .convert import main as _convert_main  # Import your existing main()
+
+def main():
+    parser = argparse.ArgumentParser(description="SAS to Parquet converter")
+    parser.add_argument("sas_file", nargs="?", help="Single SAS file to convert")
+    parser.add_argument("parquet_file", nargs="?", help="Output Parquet file")
+    parser.add_argument("--dir-mode", action="store_true", 
+                       help="Process entire SAS_INPUT_DIR (ignores file args)")
+    
+    args = parser.parse_args()
+    
+    # Patch sys.argv for your convert.main() if single file mode
+    if args.sas_file and not args.dir_mode:
+        sys.argv = [sys.argv[0], str(Path(args.sas_file)), str(Path(args.parquet_file))]
+    
+    _convert_main()
+
+if __name__ == "__main__":
+    main()

sas2parquet/convert.py

@@ -0,0 +1,381 @@
+import os
+import gc
+import re
+import warnings
+import traceback
+import sys
+from pathlib import Path
+from datetime import datetime
+import pandas as pd
+import polars as pl
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pyreadstat
+
+# --- Suppress pandas FutureWarnings ---
+warnings.simplefilter(action='ignore', category=FutureWarning)
+
+# --- Configuration ---
+# Put your .sas7bdat files inside SAS_INPUT_DIR (including subfolders).
+SAS_INPUT_DIR = Path("sasdata")
+
+# IMPORTANT:
+# parquetdata/ and logging/ are created NEXT TO sasdata/ (i.e., in the same parent directory).
+PARQUET_INPUT_DIR = SAS_INPUT_DIR.parent / "parquetdata"
+LOG_DIR = SAS_INPUT_DIR.parent / "logging"
+LOG_FILE_PATH = LOG_DIR / f"conversion_{datetime.now():%Y%m%d_%H%M%S}.log"
+
+KNOWN_DATETIME_COLUMNS = [
+    'RPNA_DATE_UTC','RPNA_TIME_UTC','RPA_DATE_UTC','TIMESTAMP_UTC',
+    'EVENT_START_DATE_UTC','EVENT_END_DATE_UTC',
+    'REPORTING_START_DATE_UTC','REPORTING_END_DATE_UTC',
+    'RANGE_START','RANGE_END','TTIMESTAMP_UTC','RRANGE_START'
+]
+COLUMNS_TO_FORCE_AS_STRING = ['MATURITY','EARNINGS_TYPE']
+ENCODING_TEST_ORDER = ['utf-8','latin1','cp1252']
+ZSTD_COMPRESSION_LEVEL = 6
+
+AVAILABLE_RAM_GB = 96
+RAM_USAGE_FACTOR = 0.5
+ESTIMATED_BYTES_PER_CELL = 10
+MIN_CHUNK_SIZE = 100_000
+MAX_CHUNK_SIZE = 10_000_000
+
+
+# --- Logger ---
+class Logger:
+    def __init__(self, path):
+        self.terminal = sys.stdout
+
+        # Ensure log folder exists
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        self.logfile = open(path, 'w', encoding='utf-8')
+
+    def write(self, msg):
+        self.terminal.write(msg)
+        self.logfile.write(msg)
+
+    def flush(self):
+        self.terminal.flush()
+        self.logfile.flush()
+
+    def close(self):
+        self.logfile.close()
+
+
+# --- Mismatch report ---
+def create_diff_report(sas_s: pl.Series, par_s: pl.Series, mask: pl.Series) -> str:
+    cnt = int(mask.sum())
+    sas_ex = sas_s.filter(mask).head(5).alias(f"{sas_s.name}_SAS")
+    par_ex = par_s.filter(mask).head(5).alias(f"{par_s.name}_PARQ")
+    df_ex = pl.DataFrame([sas_ex, par_ex])
+    return f"Mismatch in '{sas_s.name}' ({cnt} rows):\n{df_ex}"
+
+
+# --- Deep comparison ---
+def compare_and_report_diffs(sas_path: Path, parquet_path: Path):
+    print(f"\n🔎 Comparing {sas_path.name} ↔ {parquet_path.name}")
+    issues = []
+    try:
+        _, sas_meta = pyreadstat.read_sas7bdat(sas_path, metadataonly=True)
+        pq_meta = pq.read_metadata(parquet_path)
+
+        # 1) metadata dims
+        if (sas_meta.number_rows != pq_meta.num_rows
+            or sas_meta.number_columns != pq_meta.num_columns):
+            return "❌ MISMATCH", [
+                f"Dimension mismatch: SAS=({sas_meta.number_rows},{sas_meta.number_columns}) "
+                f"vs Parquet=({pq_meta.num_rows},{pq_meta.num_columns})"
+            ]
+
+        # 2) actual row-count
+        CH = MAX_CHUNK_SIZE
+        sas_cnt = sum(c.shape[0] for c in pd.read_sas(sas_path, chunksize=CH))
+        pq_cnt  = sum(b.num_rows for b in
+                      pq.ParquetFile(parquet_path).iter_batches(batch_size=CH))
+        if sas_cnt != pq_cnt:
+            return "❌ MISMATCH", [f"Row count mismatch: SAS={sas_cnt} vs Parquet={pq_cnt}"]
+
+        # 3) column order
+        sas_cols = sas_meta.column_names
+        pq_cols  = pq_meta.schema.names
+        if sas_cols != pq_cols:
+            return "❌ MISMATCH", [
+                f"Column/order mismatch:\n  SAS:     {sas_cols}\n  Parquet: {pq_cols}"
+            ]
+
+        # 4) chunked compare
+        sas_it = pd.read_sas(sas_path, chunksize=CH)
+        pq_it  = pq.ParquetFile(parquet_path).iter_batches(batch_size=CH)
+        chunk_i = 0
+
+        # SAS→UNIX epoch offset µs
+        offset_us = int((pd.Timestamp("1970-01-01") -
+                         pd.Timestamp("1960-01-01")).total_seconds() * 1e6)
+
+        int_types   = {pl.Int8,pl.Int16,pl.Int32,pl.Int64,
+                       pl.UInt8,pl.UInt16,pl.UInt32,pl.UInt64}
+        float_types = {pl.Float32,pl.Float64}
+        num_types   = int_types | float_types
+
+        while True:
+            chunk_i += 1
+            sas_chunk = next(sas_it, None)
+            pq_batch  = next(pq_it, None)
+            if sas_chunk is None and pq_batch is None:
+                break
+            if sas_chunk is None or pq_batch is None:
+                issues.append("Chunk count mismatch")
+                break
+
+            psas = pl.from_pandas(sas_chunk)
+            ppq_raw = pl.from_arrow(pq_batch)
+
+            # normalize empty strings -> nulls in parquet side
+            ppq = ppq_raw.with_columns([
+                pl.when(pl.col(c) == "").then(None).otherwise(pl.col(c)).alias(c)
+                for c, d in zip(ppq_raw.columns, ppq_raw.dtypes)
+                if d == pl.Utf8
+            ])
+
+            # 4a) numeric comparison
+            for col in psas.columns:
+                scol = psas.get_column(col)
+                pcol = ppq.get_column(col)
+                ds, dp = scol.dtype, pcol.dtype
+                if ds in num_types and dp in num_types:
+                    # unify int<->float
+                    if ds in float_types and dp in int_types:
+                        pcol = pcol.cast(ds)
+                    elif dp in float_types and ds in int_types:
+                        scol = scol.cast(dp)
+                    mask = (scol != pcol) | (scol.is_null() != pcol.is_null())
+                    if mask.any():
+                        issues.append(f"Chunk {chunk_i} numeric mismatch '{col}'")
+                        issues.append(create_diff_report(scol, pcol, mask))
+                    continue
+
+            # 4b) datetime & string
+            for col in psas.columns:
+                sser = psas.get_column(col)
+                pser = ppq.get_column(col)
+
+                # epoch check
+                if sser.dtype == pl.Datetime("us") and pser.dtype == pl.Datetime("us"):
+                    raw = sas_chunk[col]
+                    if pd.api.types.is_datetime64_ns_dtype(raw):
+                        raw_us = raw.view('int64') // 1000
+                    else:
+                        raw_us = (raw * 1e6 + offset_us).astype('Int64')
+                    pus = pser.cast(pl.Int64)
+                    if not raw_us.equals(pus.to_pandas()):
+                        msk = pus.to_pandas() != raw_us
+                        issues.append(f"Chunk {chunk_i} epoch mismatch '{col}'")
+                        issues.append(create_diff_report(
+                            pl.Series(raw_us, name=col + "_SAS_us"),
+                            pus.alias(col + "_PARQ_us"),
+                            pl.Series(msk)
+                        ))
+                        continue
+
+                # string compare (with date-only normalization)
+                s_str = sser.cast(pl.Utf8)
+                p_str = pser.cast(pl.Utf8)
+                mask  = (s_str != p_str) | (s_str.is_null() != p_str.is_null())
+                m0    = s_str.str.ends_with(" 00:00:00.000")
+                d0    = p_str.str.contains(r'^\d{4}-\d{2}-\d{2}$')
+                sd    = s_str.str.slice(0, 10) == p_str
+                mask &= ~(m0 & d0 & sd)
+                if mask.any():
+                    issues.append(
+                        f"Chunk {chunk_i} value mismatch '{col}' ({int(mask.sum())} rows)"
+                    )
+                    issues.append(create_diff_report(s_str, p_str, mask))
+
+            if issues:
+                break
+
+        return ("✔️ IDENTICAL", []) if not issues else ("❌ MISMATCH", issues)
+
+    except Exception as e:
+        return "❗ CRITICAL ERROR", [str(e), traceback.format_exc()]
+    finally:
+        gc.collect()
+
+
+# --- Reconversion + validation ---
+def reconvert_file_ultimate(sas_path: Path, parquet_path: Path) -> bool:
+    print(f"🛠️ Fixing {sas_path.name}...")
+
+    # 1) metadata & encoding
+    _, meta0 = pyreadstat.read_sas7bdat(sas_path, metadataonly=True)
+    enc0 = getattr(meta0, 'file_encoding', None)
+    if enc0:
+        encoding = enc0
+        print(f"   Detected encoding from metadata: {encoding}")
+    else:
+        encoding = None
+        for e in ENCODING_TEST_ORDER:
+            try:
+                pyreadstat.read_sas7bdat(sas_path, metadataonly=True, encoding=e)
+                encoding = e
+                break
+            except Exception:
+                pass
+        if not encoding:
+            print("   ❌ Unable to detect encoding; skipping")
+            return False
+        print(f"   Fallback encoding: {encoding}")
+
+    cols = meta0.column_names
+    read_types = getattr(meta0, 'readstat_variable_types', {}) or {}
+
+    # SAS formats if available
+    fmt_map = {}
+    if hasattr(meta0, 'formats'):
+        for name, fmt in zip(meta0.column_names, meta0.formats):
+            fmt_map[name] = fmt or ""
+
+    # infer content types from first few chunks
+    content, inf, cnt = {}, {}, 0
+    it = pd.read_sas(sas_path, chunksize=MIN_CHUNK_SIZE, encoding=encoding)
+    for chunk in it:
+        tbl = pa.Table.from_pandas(chunk.convert_dtypes(), preserve_index=False)
+        for f in tbl.schema:
+            inf.setdefault(f.name, []).append(f.type)
+        cnt += 1
+        if cnt >= 5:
+            break
+    for c in cols:
+        ts = inf.get(c, [])
+        content[c] = ts[0] if len(set(ts)) == 1 else pa.string()
+
+    meta_types = {
+        c: (pa.float64() if read_types.get(c) == 'double' else pa.string())
+        for c in cols
+    }
+
+    special_up = {x.upper() for x in KNOWN_DATETIME_COLUMNS + COLUMNS_TO_FORCE_AS_STRING}
+    conflicts  = [c for c in cols if c.upper() not in special_up and meta_types[c] != content[c]]
+    strat = 'metadata-first' if len(conflicts) <= 5 else 'content-first'
+    print(f"   Strategy={strat}, conflicts={len(conflicts)}")
+
+    overrides = {}
+    for attempt in range(1, 21):
+        print(f"   Attempt {attempt}…")
+        fields = []
+        for c in cols:
+            # 1) SAS-declared numeric → float64
+            if read_types.get(c) == 'double':
+                at = pa.float64()
+            else:
+                cu = c.upper()
+                # 2) forced-string
+                if cu in {x.upper() for x in COLUMNS_TO_FORCE_AS_STRING}:
+                    at = pa.string()
+                else:
+                    fmt = fmt_map.get(c, "").upper()
+                    # 3) datetime/date/time
+                    if (cu in {x.upper() for x in KNOWN_DATETIME_COLUMNS}
+                        or any(x in fmt for x in ('DATE', 'TIME', 'DATETIME'))):
+                        if 'DATE' in fmt and 'DATETIME' not in fmt:
+                            at = pa.date32()
+                        elif 'TIME' in fmt and 'DATETIME' not in fmt:
+                            at = pa.time64('ms')
+                        else:
+                            at = pa.timestamp('ms')
+                    # 4) fallback
+                    else:
+                        at = pa.string()
+
+            # apply any dynamic override
+            if c in overrides:
+                at = overrides[c]
+
+            fields.append(pa.field(c, at))
+
+        schema = pa.schema(fields)
+
+        tgt       = int(AVAILABLE_RAM_GB * (1024**3) * RAM_USAGE_FACTOR)
+        row_bytes = meta0.number_columns * ESTIMATED_BYTES_PER_CELL or 1
+        cs        = max(MIN_CHUNK_SIZE, min(MAX_CHUNK_SIZE, int(tgt / row_bytes)))
+
+        parquet_path.parent.mkdir(parents=True, exist_ok=True)
+        writer = pq.ParquetWriter(
+            parquet_path,
+            schema,
+            compression='zstd',
+            compression_level=ZSTD_COMPRESSION_LEVEL
+        )
+        try:
+            for chunk in pd.read_sas(sas_path, chunksize=cs, encoding=encoding):
+                writer.write_table(
+                    pa.Table.from_pandas(chunk, schema=schema, preserve_index=False)
+                )
+            writer.close()
+            print("   ✅ Conversion succeeded")
+
+            st, dt = compare_and_report_diffs(sas_path, parquet_path)
+            print(f"   🔍 Validation: {st}")
+            for d in dt:
+                print("     -", d.replace("\n", "\n       "))
+            return True
+
+        except (pa.lib.ArrowTypeError, pa.lib.ArrowNotImplementedError) as e:
+            writer.close()
+            mm = re.search(r"column\s+`?(\w+)`?", str(e))
+            if mm:
+                bad = mm.group(1)
+                print(f"   ⚠️ Override '{bad}' and retry…")
+                try:
+                    df0 = next(pd.read_sas(sas_path, chunksize=MIN_CHUNK_SIZE, encoding=encoding))
+                    itype = pa.Table.from_pandas(df0[[bad]]).schema.field(bad).type
+                    overrides[bad] = itype
+                except Exception:
+                    overrides[bad] = pa.string()
+                continue
+            else:
+                print("   ❌ Unrecoverable:", e)
+                break
+
+        except Exception:
+            writer.close()
+            print("   ❌ Conversion failed:", traceback.format_exc())
+            break
+
+    print(f"   ❌ All attempts failed for {sas_path.name}")
+    return False
+
+
+# --- Main loop ---
+def main():
+    orig = sys.stdout
+    sys.stdout = Logger(LOG_FILE_PATH)
+    try:
+        print("🚀 SAS → Parquet Hybrid Fix & Validate (full folder)\n")
+        files = list(SAS_INPUT_DIR.rglob("*.sas7bdat"))
+        if not files:
+            print("❌ No SAS files found. Exiting.")
+            return
+
+        print(f"Found {len(files)} files.\n" + "="*60)
+        for sas in files:
+            rel = sas.relative_to(SAS_INPUT_DIR)
+            print(f"\n🗂 Processing: {rel}")
+
+            # Mirror structure under parquetdata/ (which lives next to sasdata/)
+            pqf = (PARQUET_INPUT_DIR / rel).with_suffix('.parquet')
+
+            reconvert_file_ultimate(sas, pqf)
+            print("-"*60)
+
+        print("\n✅ All done. See log at:", LOG_FILE_PATH)
+    finally:
+        sys.stdout.close()
+        sys.stdout = orig
+
+
+if __name__ == "__main__":
+    main()

sas2parquet-0.1.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: sas2parquet
+Version: 0.1.0
+Summary: SAS → Parquet Hybrid Converter & Validator
+License-File: LICENSE
+Author: Zaman Ziabakhshganji
+Author-email: zaman.ganji@gmail.com
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: narwhals (==2.13.0)
+Requires-Dist: numpy (==2.3.5)
+Requires-Dist: pandas (==2.3.3)
+Requires-Dist: polars (==1.36.1)
+Requires-Dist: polars-runtime-32 (==1.36.1)
+Requires-Dist: py4j (==0.10.9.9)
+Requires-Dist: pyarrow (==22.0.0)
+Requires-Dist: pyreadstat (==1.3.2)
+Requires-Dist: pyspark (==4.0.1)
+Requires-Dist: pytest (>=9.0.2,<10.0.0)
+Requires-Dist: python-dateutil (==2.9.0.post0)
+Requires-Dist: pytz (==2025.2)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: six (==1.17.0)
+Requires-Dist: tzdata (==2025.2)
+Description-Content-Type: text/markdown
+
+# sas2parquet
+
+[![PyPI version](https://badge.fury.io/py/sas2parquet.svg)](https://pypi.org/project/sas2parquet/)
+[![Python versions](https://img.shields.io/pypi/pyversions/sas2parquet.svg)](https://pypi.org/project/sas2parquet/)
+[![License](https://img.shields.io/pypi/l/sas2parquet.svg)](https://github.com/yourusername/sas2parquet/blob/main/LICENSE)
+
+**The ultimate SAS (.sas7bdat) to Parquet converter** - handles problematic files that fail with standard tools. Automatic encoding detection, intelligent type inference, schema repair, and pixel-perfect validation.
+
+## ✨ Features
+
+| Feature | Description |
+|---------|-------------|
+| 🔄 **Auto Encoding** | Detects UTF-8, Latin1, CP1252 from metadata/fallback |
+| 🧠 **Smart Types** | Infers datetime, numeric, string with 20+ fallback attempts |
+| ✅ **Validation** | Compares SAS vs Parquet chunk-by-chunk (numeric + string) |
+| 📊 **Memory Safe** | Chunked processing (96GB RAM optimized, configurable) |
+| 💾 **ZSTD** | Level 6 compression for maximum efficiency |
+| 📝 **Detailed Logs** | Mismatch reports + full conversion trace |
+| 🎯 **Two Modes** | Single file OR recursive directory processing |
+
+## Quick Start
+
+### Install
+```bash
+pip install sas2parquet
+```
+
+### Single File
+```bash
+sas2parquet input.sas output.parquet
+```
+
+### Batch Directory (Recommended)
+```bash
+sas2parquet --dir-mode
+```
+
+## 📁 Directory Mode (Default Workflow)
+
+### How it works
+
+- You provide a `sasdata/` directory containing all `.sas7bdat` files (including nested subfolders).
+- The tool automatically creates a `parquetdata/` directory in the same parent folder as `sasdata/`.
+- All files are converted to Parquet and written into `parquetdata/`, mirroring the original folder structure.
+
+```text
+your-project/
+├── sasdata/
+│   ├── file1.sas7bdat
+│   └── nested.sas7bdat
+├── parquetdata/
+│   ├── file1.parquet
+│   └── nested.parquet
+└── logging/
+    └── conversion_20260205_1145.log
+```
+
+Just run:
+```bash
+sas2parquet --dir-mode
+```
+
+## 🛠️ CLI Reference
+```bash
+sas2parquet --help
+```
+
+```text
+usage: sas2parquet [-h] [--dir-mode] [sas_file] [parquet_file]
+
+Robust SAS to Parquet converter with validation
+```
+
+## 📊 Example Output
+```text
+🚀 SAS → Parquet Hybrid Fix & Validate (full folder)
+Found 3 files.
+============================================================
+...
+```
+
+## ⚙️ Configuration (Advanced)
+
+Edit `src/sas2parquet/convert.py` constants:
+
+```python
+AVAILABLE_RAM_GB = 96
+RAM_USAGE_FACTOR = 0.5
+ZSTD_COMPRESSION_LEVEL = 6
+MIN_CHUNK_SIZE = 100_000
+MAX_CHUNK_SIZE = 10_000_000
+```
+
+## 🧪 Validation Details
+Each file undergoes 4-stage validation:
+1. Metadata
+2. Exact counts
+3. Column order
+4. Value comparison
+
+## 💻 Development
+```bash
+git clone <repo>
+cd sas2parquet
+pip install -e .
+```
+
+
+## 🧪 Testing
+
+This project includes a comprehensive **pytest** test suite covering:
+
+- Schema inference and overrides
+- SAS ↔ Parquet validation logic
+- Error handling and retry behavior
+- Directory mirroring (`sasdata/ → parquetdata/`)
+- Logging and CLI execution paths
+
+### Run tests
+
+```bash
+pip install -e .[dev]
+pytest -q
+```
+
+## 📦 Dependencies
+- pandas>=2.0
+- polars>=0.20
+- pyarrow>=15.0
+- pyreadstat>=1.4
+
+## 📄 License
+MIT License
+

sas2parquet-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+sas2parquet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sas2parquet/cli.py,sha256=Gap4-lrHE3a-tOTRljqmRP6uX-epLFHnOYN0pdffU-g,879
+sas2parquet/convert.py,sha256=36hsDLM0uQF2tuwd9U8k3U5zEZtwQcEJWta3v4SkoXc,13950
+sas2parquet-0.1.0.dist-info/METADATA,sha256=unNq979clzDKKLnxRFr5tebDI9L-i81LiNiPSJW-Nx8,4347
+sas2parquet-0.1.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+sas2parquet-0.1.0.dist-info/entry_points.txt,sha256=pg57h0xD_3R9ZC_YfxLLfu_2p1JNhF8xDNS6v7kiSBY,52
+sas2parquet-0.1.0.dist-info/licenses/LICENSE,sha256=ouRycIMUGF1zCj49-ijn1wIlTNknZEoLwAHUp0ifH-g,1066
+sas2parquet-0.1.0.dist-info/RECORD,,

sas2parquet-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sas2parquet-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sas2parquet=sas2parquet.cli:main
+

sas2parquet-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 EDC-IXLab
+
+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.