eosframes 1.1.0__py3-none-any.whl

eosframes/stack.py

@@ -0,0 +1,204 @@
+"""Stack Ersilia DataFrames horizontally or vertically.
+
+These are the in-memory counterparts of :func:`eosframes.stack_files`
+(horizontal, multi-model) and :func:`eosframes.append_files` (vertical,
+single model). Use them when you already have DataFrames in hand —
+typically from :func:`eosframes.read_csv` / :func:`eosframes.read_h5`,
+which attach the ``model_id`` and ``version`` attributes that these
+functions require.
+"""
+
+from typing import List
+
+import pandas as pd
+
+from .exceptions import EosframesError
+from .logger import get_logger
+from .naming import is_model_id_valid
+
+_STACK_MODES = ("eosmix", "explicit")
+
+
+def hstack(df_list: List[pd.DataFrame], mode: str) -> pd.DataFrame:
+    """Stack Ersilia DataFrames horizontally (one model per frame).
+
+    All frames must share the same ``input`` column in the same order.
+    The resulting DataFrame has the shared ``key`` / ``input`` columns
+    once, followed by feature columns from each input in input order.
+
+    Two naming strategies are available, matched to the two stack
+    filename modes (see :func:`eosframes.naming.is_valid_stack_mix_name`
+    and :func:`eosframes.naming.is_valid_stack_explicit_name`):
+
+    * ``mode="eosmix"`` — feature column names are suffixed with
+      ``_<model_id>_<version>`` so provenance lives in the columns.
+    * ``mode="explicit"`` — feature column names are kept as-is, so
+      provenance must live in the destination filename (which will list
+      every model's ``model_id`` and ``version``).
+
+    Parameters
+    ----------
+    df_list : list of pandas.DataFrame
+        DataFrames to stack. Must be non-empty, and each frame must
+        have ``model_id`` and ``version`` attributes (both are set
+        automatically by :func:`eosframes.read_csv` /
+        :func:`eosframes.read_h5` when the filename encodes them).
+    mode : {"eosmix", "explicit"}
+        Column-naming strategy.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Without ``model_id`` / ``version`` attributes — a horizontal
+        stack is multi-model by definition.
+
+    Raises
+    ------
+    EosframesError
+        If *df_list* is empty, *mode* is unknown, any DataFrame is
+        missing ``model_id`` or ``version``, the same
+        ``(model_id, version)`` pair appears twice, or row inputs
+        don't match across frames.
+    """
+    logger = get_logger()
+    if not df_list:
+        raise EosframesError("hstack received an empty df_list.")
+    if mode not in _STACK_MODES:
+        raise EosframesError(
+            f"Unknown stack mode: {mode!r}. Expected one of {_STACK_MODES}."
+        )
+
+    pairs = []
+    for i, df in enumerate(df_list):
+        model_id = getattr(df, "model_id", None)
+        version = getattr(df, "version", None)
+        if model_id is None:
+            raise EosframesError(
+                f"DataFrame #{i} does not have a 'model_id' attribute."
+            )
+        if not is_model_id_valid(model_id):
+            raise EosframesError(f"Invalid model_id: {model_id!r}")
+        if version is None:
+            raise EosframesError(
+                f"DataFrame #{i} (model_id={model_id}) does not have a 'version' "
+                "attribute. Read the file with a name that encodes the version "
+                "(<model_id>_<version>.csv) so df.version is set."
+            )
+        pairs.append((model_id, version))
+
+    # Same (model_id, version) must not appear twice — columns would collide
+    # in eosmix mode, and the explicit-mode filename would be ambiguous.
+    seen: set = set()
+    for p in pairs:
+        if p in seen:
+            raise EosframesError(
+                f"Duplicate (model_id, version) in stack inputs: {p}. "
+                "Each model/version combination may appear at most once."
+            )
+        seen.add(p)
+
+    reference_inputs = df_list[0]["input"].tolist()
+    for i, df in enumerate(df_list[1:], start=2):
+        if df["input"].tolist() != reference_inputs:
+            raise EosframesError(
+                f"Input mismatch: DataFrame #{i} has different inputs or row order "
+                "than DataFrame #1."
+            )
+
+    key_list = None
+    for df in df_list:
+        if "key" in df.columns:
+            key_list = df["key"].tolist()
+            break
+
+    meta = (
+        {"input": reference_inputs}
+        if key_list is None
+        else {"key": key_list, "input": reference_inputs}
+    )
+    result = pd.DataFrame(meta)
+
+    feature_count = 0
+    for (model_id, version), df in zip(pairs, df_list):
+        feature_cols = [c for c in df.columns if c not in {"key", "input"}]
+        block = df[feature_cols].reset_index(drop=True)
+        if mode == "eosmix":
+            block = block.rename(
+                columns={c: f"{c}_{model_id}_{version}" for c in feature_cols}
+            )
+        # mode == "explicit": leave column names as-is.
+        result = pd.concat([result, block], axis=1)
+        feature_count += len(feature_cols)
+
+    logger.info(
+        "hstack: %d frames × %d rows → %d feature columns (mode=%s)",
+        len(df_list),
+        len(reference_inputs),
+        feature_count,
+        mode,
+    )
+    return result
+
+
+def vstack(df_list: List[pd.DataFrame]) -> pd.DataFrame:
+    """Stack Ersilia DataFrames vertically (same model, multiple batches).
+
+    All frames must share the same columns and the same ``model_id``.
+    The resulting DataFrame inherits the shared ``model_id`` so it can
+    be written directly with :func:`eosframes.write_csv` /
+    :func:`eosframes.write_h5`.
+
+    Parameters
+    ----------
+    df_list : list of pandas.DataFrame
+        DataFrames to stack. Must be non-empty; each frame must have a
+        ``model_id`` attribute.
+
+    Returns
+    -------
+    pandas.DataFrame
+        With ``model_id`` set to the shared model ID. Note that
+        ``version`` is intentionally **not** propagated — vertical
+        concatenation across versions is allowed (it's the same model)
+        but the result no longer corresponds to a single version.
+
+    Raises
+    ------
+    EosframesError
+        If *df_list* is empty, columns differ across frames, any
+        ``model_id`` attribute is missing, or the model IDs do not all
+        match.
+    """
+    logger = get_logger()
+    if not df_list:
+        raise EosframesError("vstack received an empty df_list.")
+    model_ids = [getattr(df, "model_id", None) for df in df_list]
+    for i, model_id in enumerate(model_ids):
+        if model_id is None:
+            raise EosframesError(
+                f"DataFrame #{i} does not have a 'model_id' attribute."
+            )
+
+    unique_ids = set(model_ids)
+    if len(unique_ids) > 1:
+        raise EosframesError(
+            f"Cannot vstack DataFrames with different model IDs: {sorted(unique_ids)}"
+        )
+
+    reference_cols = df_list[0].columns.tolist()
+    for i, df in enumerate(df_list[1:], start=2):
+        if df.columns.tolist() != reference_cols:
+            raise EosframesError(
+                f"Column mismatch: DataFrame #{i} has columns {df.columns.tolist()} "
+                f"but expected {reference_cols}."
+            )
+
+    result = pd.concat(df_list, axis=0).reset_index(drop=True)
+    result.model_id = model_ids[0]
+    logger.info(
+        "vstack: %d frames → %d rows (model_id=%s)",
+        len(df_list),
+        len(result),
+        model_ids[0],
+    )
+    return result

eosframes/utils.py

@@ -0,0 +1,23 @@
+"""General-purpose utilities."""
+
+from typing import Iterator
+
+import pandas as pd
+
+
+def chunker(df: pd.DataFrame, chunksize: int = 10000) -> Iterator[pd.DataFrame]:
+    """Yield successive non-overlapping chunks of *df*.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The DataFrame to split.
+    chunksize : int
+        Number of rows per chunk (default 10 000).
+
+    Yields
+    ------
+    pd.DataFrame
+    """
+    for start in range(0, len(df), chunksize):
+        yield df.iloc[start : start + chunksize]

eosframes/write.py

@@ -0,0 +1,201 @@
+"""Writers for Ersilia output files (CSV, H5, chunked CSVs).
+
+Every write path in this module enforces three invariants:
+
+1. **No silent overwrite.** Writers refuse to clobber an existing file or
+   directory and raise :class:`~eosframes.EosframesError` with guidance
+   to delete the existing target first.
+2. **Model-ID match.** Writers extract the model ID from the destination
+   path with :func:`eosframes.naming.get_model_id_from_path` and compare
+   it against ``df.model_id``; mismatches raise.
+3. **Required attributes.** Every DataFrame passed in must have a
+   ``model_id`` attribute. Set it via ``df.model_id = "..."`` after
+   transformations that drop loose attributes (``concat`` /
+   ``drop_duplicates``).
+"""
+
+import os
+from typing import Union
+
+import h5py
+import numpy as np
+import pandas as pd
+
+from .exceptions import EosframesError
+from .logger import get_logger
+from .naming import get_model_id_from_path
+from .utils import chunker
+
+
+def write_csv(df: pd.DataFrame, csv_path: str) -> None:
+    """Save a DataFrame as a CSV file in Ersilia format.
+
+    The CSV is written with no row index. The model ID encoded in
+    *csv_path* must match ``df.model_id`` (extracted leniently from the
+    path basename — the strict canonical naming pattern is enforced by
+    the higher-level operations in :mod:`eosframes.ops`, not here).
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        DataFrame to save. Must have a ``model_id`` attribute set.
+    csv_path : str
+        Destination path. Must end in ``.csv`` and contain a valid
+        Ersilia model identifier somewhere in its basename.
+
+    Raises
+    ------
+    EosframesError
+        If the file already exists, the extension is wrong, the model
+        ID cannot be resolved from the path, ``df.model_id`` is missing,
+        or the path-encoded and DataFrame model IDs disagree.
+    """
+    logger = get_logger()
+    if os.path.exists(csv_path):
+        raise EosframesError(
+            f"File '{csv_path}' already exists. Remove it before saving."
+        )
+    if not csv_path.endswith(".csv"):
+        raise EosframesError(f"Output path must end in '.csv', got: '{csv_path}'")
+    path_model_id = get_model_id_from_path(csv_path)
+    if path_model_id is None:
+        raise EosframesError(
+            f"Could not extract a model ID from '{csv_path}'. "
+            "The filename must contain an Ersilia model identifier."
+        )
+    df_model_id = getattr(df, "model_id", None)
+    if df_model_id is None:
+        raise EosframesError("DataFrame does not have a 'model_id' attribute.")
+    if path_model_id != df_model_id:
+        raise EosframesError(
+            f"Model ID mismatch: filename encodes '{path_model_id}' "
+            f"but DataFrame has model_id='{df_model_id}'."
+        )
+    logger.info("Writing CSV: %s (%d rows)", csv_path, len(df))
+    df.reset_index(drop=True).to_csv(csv_path, index=False)
+    logger.info("Done: %s", csv_path)
+
+
+def write_h5(df: pd.DataFrame, h5_path: str, dtype: Union[np.dtype, str]) -> None:
+    """Save a DataFrame as an HDF5 file in Ersilia format.
+
+    Writes four datasets:
+
+    * ``key``      — UTF-8 strings, ``(N,)`` (only if ``df`` has a ``key`` column)
+    * ``input``    — UTF-8 strings, ``(N,)``
+    * ``features`` — UTF-8 strings, ``(F,)`` (the feature column names)
+    * ``values``   — numeric, ``(N, F)``, with the dtype provided by *dtype*
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        DataFrame to save. Must have a ``model_id`` attribute and an
+        ``input`` column.
+    h5_path : str
+        Destination path. Must contain a valid Ersilia model identifier
+        somewhere in its basename.
+    dtype : numpy.dtype or str
+        NumPy dtype for the ``values`` dataset (e.g. ``numpy.float32``,
+        ``numpy.int8``). Non-float dtypes will quantize the values.
+
+    Raises
+    ------
+    EosframesError
+        If the file already exists, the model ID cannot be resolved,
+        ``df.model_id`` is missing, or the path-encoded and DataFrame
+        model IDs disagree.
+    """
+    logger = get_logger()
+    if os.path.exists(h5_path):
+        raise EosframesError(
+            f"File '{h5_path}' already exists. Remove it before saving."
+        )
+    path_model_id = get_model_id_from_path(h5_path)
+    if path_model_id is None:
+        raise EosframesError(
+            f"Could not extract a model ID from '{h5_path}'. "
+            "The filename must contain an Ersilia model identifier."
+        )
+    df_model_id = getattr(df, "model_id", None)
+    if df_model_id is None:
+        raise EosframesError("DataFrame does not have a 'model_id' attribute.")
+    if path_model_id != df_model_id:
+        raise EosframesError(
+            f"Model ID mismatch: filename encodes '{path_model_id}' "
+            f"but DataFrame has model_id='{df_model_id}'."
+        )
+    df = df.reset_index(drop=True)
+    feature_cols = [c for c in df.columns if c not in {"key", "input"}]
+    logger.info("Writing H5: %s (%d rows)", h5_path, len(df))
+    with h5py.File(h5_path, "w") as f:
+        dt_str = h5py.string_dtype(encoding="utf-8")
+        if "key" in df.columns:
+            f.create_dataset("key", data=df["key"].astype(str).tolist(), dtype=dt_str)
+        f.create_dataset("input", data=df["input"].astype(str).tolist(), dtype=dt_str)
+        f.create_dataset("features", data=feature_cols, dtype=dt_str)
+        f.create_dataset("values", data=df[feature_cols].values, dtype=dtype)
+    logger.info("Done: %s", h5_path)
+
+
+def write_chunked_csvs(df: pd.DataFrame, dir_path: str, chunksize: int) -> None:
+    """Split a DataFrame into chunk CSV files inside *dir_path*.
+
+    Creates *dir_path* (which must not already exist) and writes
+    ``chunk_<N>.csv`` files into it, where ``<N>`` is a zero-padded
+    integer wide enough to accommodate the largest chunk index. Every
+    chunk has the same column header.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        DataFrame to chunk. Must have a ``model_id`` attribute.
+    dir_path : str
+        Directory to create. Must contain a valid Ersilia model
+        identifier in its basename and must not already exist.
+    chunksize : int
+        Rows per chunk. Hard-capped at 100 000.
+
+    Raises
+    ------
+    EosframesError
+        If the directory already exists, the model ID cannot be
+        resolved, ``df.model_id`` is missing, the path-encoded and
+        DataFrame model IDs disagree, or *chunksize* exceeds the limit.
+    """
+    logger = get_logger()
+    if chunksize > 100_000:
+        raise EosframesError(f"chunksize {chunksize} exceeds the limit of 100 000.")
+    path_model_id = get_model_id_from_path(dir_path)
+    if path_model_id is None:
+        raise EosframesError(
+            f"Could not extract a model ID from '{dir_path}'. "
+            "The directory name must contain an Ersilia model identifier."
+        )
+    df_model_id = getattr(df, "model_id", None)
+    if df_model_id is None:
+        raise EosframesError("DataFrame does not have a 'model_id' attribute.")
+    if path_model_id != df_model_id:
+        raise EosframesError(
+            f"Model ID mismatch: directory encodes '{path_model_id}' "
+            f"but DataFrame has model_id='{df_model_id}'."
+        )
+    dir_path = os.path.abspath(dir_path)
+    if os.path.exists(dir_path):
+        raise EosframesError(
+            f"Directory '{dir_path}' already exists. Remove it before saving."
+        )
+    os.mkdir(dir_path)
+    num_chunks = (len(df) + chunksize - 1) // chunksize
+    zfill = len(str(max(num_chunks - 1, 0)))
+    logger.info(
+        "Writing %d rows to %s in %d chunks of up to %d rows each",
+        len(df),
+        dir_path,
+        num_chunks,
+        chunksize,
+    )
+    for i, chunk in enumerate(chunker(df.reset_index(drop=True), chunksize)):
+        chunk.to_csv(
+            os.path.join(dir_path, f"chunk_{str(i).zfill(zfill)}.csv"), index=False
+        )
+    logger.info("Done: %s (%d chunk files)", dir_path, num_chunks)

eosframes-1.1.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: eosframes
+Version: 1.1.0
+Summary: Ersilia utilities for working with tabular output data
+License: MIT
+License-File: LICENSE
+Keywords: ersilia,cheminformatics,data,machine-learning
+Author: Ersilia Open Source Initiative
+Author-email: hello@ersilia.io
+Requires-Python: >=3.8
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Dist: click (>=8.0)
+Requires-Dist: h5py (>=3.10.0)
+Requires-Dist: numpy (>=1.24.0)
+Requires-Dist: pandas (>=2.0.0)
+Requires-Dist: requests (>=2.31)
+Requires-Dist: rich (>=10.0)
+Project-URL: Homepage, https://github.com/ersilia-os/eosframes
+Project-URL: Repository, https://github.com/ersilia-os/eosframes
+Description-Content-Type: text/markdown
+
+![Work in Progress](https://img.shields.io/badge/status-work%20in%20progress-orange)
+
+# Manipulating Ersilia's dataframes
+
+`eosframes` is a library for manipulating inputs and outputs from the [Ersilia Model Hub](https://github.com/ersilia-os/ersilia). It splits, assembles, converts, scales, and summarises tabular model output files.
+
+## Installation
+
+Python ≥ 3.8 is required.
+
+```bash
+pip install eosframes
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/ersilia-os/eosframes.git
+cd eosframes
+pip install -e .
+```
+
+## Quick start
+
+Every file the library reads or writes encodes a model ID and version in its filename, e.g. `eos4e40_v1.csv` (model `eos4e40`, version `v1`).
+
+```bash
+# Slice a big input CSV into chunks for parallel model runs
+eosframes split compounds.csv -o chunks/ --chunksize 10000
+
+# Stitch the per-batch outputs back into one file
+eosframes append eos4e40_v1_000.csv eos4e40_v1_001.csv -o eos4e40_v1.csv
+
+# Combine outputs from multiple models, side by side
+eosframes stack eos4e40_v1.csv eos7m30_v1.csv -o project_eosmix.csv
+```
+
+Everything the CLI does is also importable:
+
+```python
+from eosframes import read_csv, hstack, fit, transform
+
+df = read_csv("eos4e40_v1.csv")
+params = fit(df)
+scaled = transform(df, params)
+```
+
+Run `eosframes --help` (or `eosframes <command> --help`) for inline help.
+
+## Commands
+
+| Command     | Purpose                                                       |
+|-------------|---------------------------------------------------------------|
+| `split`     | Slice any CSV into chunk files for parallel model runs.       |
+| `convert`   | CSV ↔ H5, or assemble a chunks folder.                        |
+| `append`    | Vertically concatenate batches from the same model.           |
+| `dedupe`    | Drop duplicate rows by `key`.                                 |
+| `stack`     | Horizontally combine outputs from different models.           |
+| `unstack`   | Split a stacked file back into per-model files.               |
+| `summary`   | Per-feature stats from a local file.                          |
+| `info`      | Model metadata fetched from GitHub.                           |
+| `columns`   | Feature definitions fetched from GitHub.                      |
+| `fit`       | Fit a type-aware robust scaler and save its parameters.       |
+| `transform` | Apply a saved scaler to a file.                               |
+
+See [`docs/cli.md`](docs/cli.md) for every flag, example, and refusal condition.
+
+## Documentation
+
+- [`docs/cli.md`](docs/cli.md) — every CLI command, all flags, examples, and error patterns.
+- [`docs/nomenclature.md`](docs/nomenclature.md) — every recognised filename / directory pattern, the strict/lenient contract, and the two stack modes.
+- [`docs/scaling.md`](docs/scaling.md) — the type-aware robust scaler: column kinds, how each is picked, and quantization / imputation.
+
+## About the Ersilia Open Source Initiative
+
+The [Ersilia Open Source Initiative](https://ersilia.io) is a tech-nonprofit fueling sustainable research in the Global South. Ersilia's main asset is the [Ersilia Model Hub](https://github.com/ersilia-os/ersilia), an open-source repository of AI/ML models for drug discovery.
+
+![Ersilia Logo](assets/Ersilia_Brand.png)
+

eosframes-1.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+eosframes/__init__.py,sha256=i6XqWcdR_VGqnwS4lqHKYXPTCHEoVgUcy2IqJ0aP_zg,3478
+eosframes/cli.py,sha256=lnNxecjLBw-XdtaRpPPXX8m3hkzYWWQSEdri2T5vhMs,26538
+eosframes/exceptions.py,sha256=sncH1ZUO_jJFspO-r_iqij0vGeUEHAhqhvJQcSWlX2w,758
+eosframes/hub.py,sha256=jlu02v-s42Vohq539THMNAIRvI6liwp1F7UnLt6lSVM,5065
+eosframes/logger.py,sha256=9Vs7KrLE1NutbLrhIvZfbso8RJ8L8QdBgctUiVNKms4,4432
+eosframes/naming.py,sha256=9qxdmL8eloZyLuRcq-MF3SLpHGp-Y_ch2z6lkvZBFec,18519
+eosframes/ops.py,sha256=XUl2xCXJmWpg9p-sLI3zZ0mKgWn13E-Ve0v9nBEFVe0,25944
+eosframes/read.py,sha256=QIxPiU-a93rTNSGmORAVeURcr7tSHPTM20uWsIIrMs0,7502
+eosframes/scale.py,sha256=jMoR2MNygTmd16Lh55dxRIu8E188jMnmv-6wyLdEoMs,71821
+eosframes/stack.py,sha256=OuHMofTR8OWCVgALqnAe8NTbhPKcM8F8IjVGLUagOu0,7355
+eosframes/utils.py,sha256=XYJ7bzvqiuvhUaqnOq19euM7Ay4TRGteu6sznmXShbg,522
+eosframes/write.py,sha256=AAzlXyUM7X37l-vUfPYSNSbG5Jw6rMPlE7BOsQKhWwI,7995
+eosframes-1.1.0.dist-info/METADATA,sha256=qq0OA3P8tQWY0VWO6jOVj5fOchd4_dB08WoVZmBAWjI,4582
+eosframes-1.1.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+eosframes-1.1.0.dist-info/entry_points.txt,sha256=ePFIPifLmlju1MtwrrUE8PLeUHf3GrK86kNUHe_mb9E,48
+eosframes-1.1.0.dist-info/licenses/LICENSE,sha256=2WVpPv5BJoPm-wsGXHxnR6uvrgPYGxWkbhl0kX3AqKc,1087
+eosframes-1.1.0.dist-info/RECORD,,

eosframes-1.1.0.dist-info/WHEEL

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

eosframes-1.1.0.dist-info/entry_points.txt

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

eosframes-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ersilia Open Source Initiative
+
+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.