livefold 0.1.0__py3-none-any.whl

livefold/__init__.py

@@ -0,0 +1,15 @@
+from livefold.livefold import (
+    LiveFold,
+    TimeIndexedLiveFold,
+    InvalidRangeException,
+    InvalidFoldException,
+    MonotonicityError,
+)
+
+__all__ = [
+    "LiveFold",
+    "TimeIndexedLiveFold",
+    "InvalidRangeException",
+    "InvalidFoldException",
+    "MonotonicityError",
+]

livefold/livefold.py

@@ -0,0 +1,402 @@
+import bisect
+import copy as _copy
+import time
+
+from math import isqrt
+from typing import Any, Generic, Iterable, Callable, TypeVar
+
+T = TypeVar("T")
+
+
+class InvalidRangeException(Exception): ...
+
+
+class InvalidFoldException(Exception): ...
+
+
+class MonotonicityError(Exception): ...
+
+
+class LiveFold(list):
+    def __init__(self, data: Iterable[Any], folds: dict[str, Callable]):
+        super().__init__(data)
+        if not folds:
+            raise InvalidFoldException(
+                "Cannot initialize LiveFold with no `folds` provided"
+            )
+        self.folds = folds
+        self._blocks = self.compute_blocks()
+
+    @property
+    def block_size(self):
+        return isqrt(len(self))
+
+    @property
+    def block_count(self):
+        if not len(self):
+            return 0
+        return len(self) // self.block_size
+
+    @property
+    def blocks(self):
+        return self._blocks
+
+    @blocks.setter
+    def blocks(self, blocks_):
+        self._blocks = blocks_
+        if hasattr(self, "_folded_values"):
+            del self._folded_values
+
+    @property
+    def folded_values(self):
+        if not hasattr(self, "_folded_values"):
+            self.folded_values = {
+                name: list(map(fn, self.blocks)) for name, fn in self.folds.items()
+            }
+        return self._folded_values
+
+    @folded_values.setter
+    def folded_values(self, values):
+        self._folded_values = values
+
+    def _fold_each(self, items) -> dict[str, Any]:
+        return {name: fn(items) for name, fn in self.folds.items()}
+
+    def _block_folds(self, block_index: int) -> dict[str, Any]:
+        return {name: self.folded_values[name][block_index] for name in self.folds}
+
+    def _refold_from(self, block_index: int) -> None:
+        for name, fn in self.folds.items():
+            self.folded_values[name][block_index:] = list(
+                map(fn, self.blocks[block_index:])
+            )
+
+    def _refold_at(self, block_index: int) -> None:
+        for name, fn in self.folds.items():
+            self.folded_values[name][block_index] = fn(self.blocks[block_index])
+
+    def _merge_into_last_block_folds(self, prefix) -> None:
+        for name, fn in self.folds.items():
+            self.folded_values[name][-1] = fn([self.folded_values[name][-1], *prefix])
+
+    def _extend_block_folds(self, new_blocks) -> None:
+        for name, fn in self.folds.items():
+            self.folded_values[name].extend(map(fn, new_blocks))
+
+    def compute_blocks(self, start_index: int = 0):
+        block_size = self.block_size
+        if not block_size:
+            return []
+        return [
+            self[i : i + block_size] for i in range(start_index, len(self), block_size)
+        ]
+
+    def append(self, __object):
+        self.extend([__object])
+
+    def insert(self, __index, __object):
+        block_size = self.block_size
+        super().insert(__index, __object)
+        new_block_size = self.block_size
+        if new_block_size != block_size:
+            self.blocks = self.compute_blocks()
+        else:
+            block_index = __index // block_size
+            self.blocks[block_index:] = self.compute_blocks(block_index * block_size)
+            self._refold_from(block_index)
+
+    def sort(self, *, key=None, reverse=False):
+        super().sort(key=key, reverse=reverse)
+        self.blocks = self.compute_blocks()
+
+    def extend(self, __iterable):
+        __iterable = list(__iterable)
+        block_size = self.block_size
+        super().extend(__iterable)
+        new_block_size = self.block_size
+        if new_block_size != block_size:
+            self.blocks = self.compute_blocks()
+        else:
+            if (index := block_size - len(self.blocks[-1])) > 0:
+                self._merge_into_last_block_folds(__iterable[:index])
+                self.blocks[-1] += __iterable[:index]
+                __iterable = __iterable[index:]
+            self.__extend_blocks(__iterable)
+
+    def __extend_blocks(self, iterable):
+        block_size = self.block_size
+        new_blocks = [
+            iterable[i : i + block_size] for i in range(0, len(iterable), block_size)
+        ]
+        self.blocks.extend(new_blocks)
+        self._extend_block_folds(new_blocks)
+
+    def pop(self, __index=-1):
+        block_size = self.block_size
+        value = super().pop(__index)
+        new_block_size = self.block_size
+        if new_block_size != block_size:
+            self.blocks = self.compute_blocks()
+        else:
+            block_index = __index // block_size
+            self.blocks[block_index].pop(__index % block_size if __index >= 0 else -1)
+            if len(self.blocks[block_index]) == 0:
+                del self.blocks[block_index]
+                for name in self.folds:
+                    del self.folded_values[name][block_index]
+            else:
+                self.blocks[block_index:] = self.compute_blocks(
+                    block_index * block_size
+                )
+                self._refold_from(block_index)
+        return value
+
+    def remove(self, __value):
+        self.pop(self.index(__value))
+
+    def reverse(self):
+        super().reverse()
+        self.blocks = self.compute_blocks()
+
+    def __add__(self, other):
+        return LiveFold(super().__add__(other), self.folds)
+
+    def __iadd__(self, other):
+        self.extend(other)
+        return self
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        if isinstance(key, slice):
+            # TODO: for slice assignment we recompute all blocks - this can be optimized but
+            # requires more thought for all edge cases
+            self.blocks = self.compute_blocks()
+        else:
+            if key < 0:
+                key += len(self)
+            block_size = self.block_size
+            block_index = key // block_size
+            self.blocks[block_index][key % block_size] = value
+            self._refold_at(block_index)
+
+    def __delitem__(self, key):
+        if isinstance(key, slice):
+            super().__delitem__(key)
+            self.blocks = self.compute_blocks()
+        else:
+            self.pop(key)
+
+    def copy(self):
+        return LiveFold(list(self), self.folds)
+
+    def __copy__(self):
+        return self.copy()
+
+    def __deepcopy__(self, memo):
+        return LiveFold(
+            _copy.deepcopy(list(self), memo),
+            self.folds,
+        )
+
+    def __reduce__(self):
+        return (
+            self.__class__,
+            (list(self), self.folds),
+        )
+
+    def query(self, left: int, right: int):
+        if right - left < 0 or right >= len(self) or left < 0:
+            raise InvalidRangeException(
+                f"Invalid range of {left} - {right}. Please supply a valid range!"
+            )
+        block_size = self.block_size
+        left_block = left // block_size
+        right_block = right // block_size
+        left_block_start_index = left_block * block_size
+        left_block_end_index = left_block_start_index + len(self.blocks[left_block]) - 1
+        right_block_start_index = right_block * block_size
+        right_block_end_index = (
+            right_block_start_index + len(self.blocks[right_block]) - 1
+        )
+        if left_block == right_block:
+            if left == left_block_start_index and right == right_block_end_index:
+                return self._block_folds(left_block)
+            return self._fold_each(self[left : right + 1])
+        if left != left_block_start_index:
+            initial_value = self._fold_each(self[left : left_block_end_index + 1])
+        else:
+            initial_value = self._block_folds(left_block)
+        if right != right_block_end_index:
+            final_value = self._fold_each(self[right_block_start_index : right + 1])
+        else:
+            final_value = self._block_folds(right_block)
+        return {
+            name: fn(
+                [initial_value[name]]
+                + self.folded_values[name][left_block + 1 : right_block]
+                + [final_value[name]]
+            )
+            for name, fn in self.folds.items()
+        }
+
+    def clear(self):
+        super().clear()
+        self.blocks = []
+        self.folded_values = {name: [] for name in self.folds}
+
+
+class TimeIndexedLiveFold(LiveFold, Generic[T]):
+    """LiveFold with monotonically non-decreasing timestamps per element.
+
+    Generic over `T`, the timestamp type. Any orderable type works
+    (`float`, `int`, `datetime`, etc.) — the implementation only uses `<`
+    and `bisect`, which require mutual comparability of stored timestamps.
+
+    The `timestamp=None` defaults in `__init__`, `append`, and `extend`
+    fall back to `time.time()` (a `float`). This default only makes sense
+    for `T = float`; for any other type, pass timestamps explicitly.
+    """
+
+    def __init__(
+        self,
+        data: Iterable[Any],
+        folds: dict[str, Callable],
+        timestamps: list[T] | None = None,
+    ):
+        super().__init__(data, folds)
+        if timestamps is not None:
+            if len(timestamps) != len(self):
+                raise ValueError(
+                    f"Timestamps and data length must match, got {len(timestamps)} and {len(self)}"
+                )
+            self._timestamps: list[T] = []
+            self._check_monotonic(timestamps)
+            self._timestamps = list(timestamps)
+        else:
+            self._timestamps: list[T] = [time.time() for _ in range(len(self))]
+
+    @property
+    def timestamps(self) -> list[T]:
+        return self._timestamps
+
+    def append(self, __object, timestamp: T | None = None):
+        self.extend([__object], [timestamp] if timestamp is not None else None)
+
+    def extend(self, __iterable, timestamps: list[T] | None = None):
+        __iterable = list(__iterable)
+        if timestamps is None:
+            timestamps = [time.time() for _ in __iterable]
+        else:
+            if len(timestamps) != len(__iterable):
+                raise ValueError(
+                    f"Timestamps and iterable lengths must match, got {len(timestamps)} and {len(__iterable)}"
+                )
+            self._check_monotonic(timestamps)
+        super().extend(__iterable)
+        self._timestamps.extend(timestamps)
+
+    def _check_monotonic(self, new_timestamps: list[T]) -> None:
+        prev = self._timestamps[-1] if self._timestamps else None
+        for ts in new_timestamps:
+            if prev is not None and ts < prev:
+                raise MonotonicityError(
+                    f"non-monotonic timestamp: {ts} precedes {prev}"
+                )
+            prev = ts
+
+    def insert(self, __index, __object):
+        raise MonotonicityError(
+            "insert is not supported on TimeIndexedLiveFold; use append to preserve time ordering"
+        )
+
+    def sort(self, *, key=None, reverse=False):
+        raise MonotonicityError(
+            "sort is not supported on TimeIndexedLiveFold; sorting would break time ordering"
+        )
+
+    def reverse(self):
+        raise MonotonicityError(
+            "reverse is not supported on TimeIndexedLiveFold; reversing would break time ordering"
+        )
+
+    def __setitem__(self, key, value):
+        if isinstance(key, slice):
+            raise MonotonicityError(
+                "slice assignment is not supported on TimeIndexedLiveFold; "
+                "it would not preserve alignment with stored timestamps"
+            )
+        super().__setitem__(key, value)
+
+    def __delitem__(self, key):
+        if isinstance(key, slice):
+            raise MonotonicityError(
+                "slice deletion is not supported on TimeIndexedLiveFold; use pop or remove"
+            )
+        # super().__delitem__ routes int keys through self.pop, which we override
+        # to handle timestamps; no separate timestamp removal needed here.
+        super().__delitem__(key)
+
+    def __add__(self, other):
+        if not isinstance(other, TimeIndexedLiveFold):
+            raise MonotonicityError(
+                "+ only supports TimeIndexedLiveFold + TimeIndexedLiveFold; "
+                "use extend(values, timestamps=...) for other inputs"
+            )
+        self._check_monotonic(other.timestamps)
+        return TimeIndexedLiveFold(
+            list(self) + list(other),
+            self.folds,
+            timestamps=self.timestamps + other.timestamps,
+        )
+
+    def __iadd__(self, other):
+        if not isinstance(other, TimeIndexedLiveFold):
+            raise MonotonicityError(
+                "+= only supports TimeIndexedLiveFold + TimeIndexedLiveFold; "
+                "use extend(values, timestamps=...) for other inputs"
+            )
+        self.extend(list(other), timestamps=list(other.timestamps))
+        return self
+
+    def copy(self):
+        return TimeIndexedLiveFold(
+            list(self), self.folds, timestamps=list(self._timestamps)
+        )
+
+    def __copy__(self):
+        return self.copy()
+
+    def __deepcopy__(self, memo):
+        return TimeIndexedLiveFold(
+            _copy.deepcopy(list(self), memo),
+            self.folds,
+            timestamps=_copy.deepcopy(self._timestamps, memo),
+        )
+
+    def __reduce__(self):
+        return (
+            self.__class__,
+            (list(self), self.folds, list(self._timestamps)),
+        )
+
+    def pop(self, __index=-1):
+        value = super().pop(__index)
+        self.timestamps.pop(__index)
+        return value
+
+    def clear(self):
+        super().clear()
+        self.timestamps.clear()
+
+    def __repr__(self) -> str:
+        return f"TimeIndexedLiveFold({list(self)!r}, timestamps={self._timestamps!r})"
+
+    def query_time_range(self, start: T, end: T):
+        left = bisect.bisect_left(self.timestamps, start)
+        right = bisect.bisect_right(self.timestamps, end) - 1
+        try:
+            return super().query(left, right)
+        except InvalidRangeException as e:
+            raise InvalidRangeException(
+                f"No elements in time range: [{start}, {end}]"
+            ) from e

livefold-0.1.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: livefold
+Version: 0.1.0
+Summary: A primitive for online sequential aggregation in Python
+Project-URL: Source code, https://github.com/danielenricocahall/livefold
+Author: Daniel Cahall
+License-File: LICENSE
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# livefold
+
+*live + fold — incremental folds over a mutable sequence.*
+
+[![Build Status](https://github.com/danielenricocahall/livefold/actions/workflows/ci.yaml/badge.svg)](https://github.com/danielenricocahall/livefold/actions/workflows/ci.yaml)
+[![Supported Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://github.com/danielenricocahall/livefold/blob/main/pyproject.toml)
+[![license](https://img.shields.io/github/license/danielenricocahall/livefold.svg)](https://github.com/danielenricocahall/livefold/blob/main/LICENSE)
+
+> A primitive for online sequential aggregation in Python.
+> Maintain a mutable numeric sequence; query exact aggregates over any range
+> in **O(√n)**; plug in any associative reducer (any monoid).
+
+## When to reach for it
+
+| Need | Use |
+|---|---|
+| Immutable series, range aggregates | Prefix sums |
+| Frequent point updates, log-time queries | Segment tree / Fenwick tree |
+| Fixed-width rolling windows | `pandas.rolling()` / `polars.rolling()` |
+| **Mutable series, arbitrary range queries, multi-fold** | **livefold** |
+
+Common shapes: request latencies, sensor readings, trade prices, telemetry events.
+
+## Quickstart
+
+```bash
+pip install livefold
+```
+
+```python
+from livefold import LiveFold
+
+lf = LiveFold([1, 2, 3, 4, 5, 6], folds={"sum": sum, "max": max, "min": min})
+
+lf.append(7)
+lf.query(0, 5)
+# → {"sum": 21, "max": 6, "min": 1}
+
+# Mutate freely; aggregates stay current
+lf[2] = -1
+lf.query(2, 5)
+# → {"sum": 9, "max": 6, "min": -1}
+```
+
+## Performance
+
+![Query latency vs collection size](https://raw.githubusercontent.com/danielenricocahall/livefold/main/benchmarks/plots/query_latency.png)
+
+At n = 10⁷, `livefold`'s median range query is **69 µs vs naive Python's 29 ms** (~400× faster), and median append cost is **~2 µs across all n** while every other backend with a competitive query path (numpy, pandas) degrades linearly on *every* append. livefold's amortized append is O(√n) — boundary-crossing rebuilds are rare (~one per √n appends) but real — so the median characterizes typical streaming latency, not the rare rebuild spike.
+
+Full methodology, append benchmarks, comparison against four backends, and the reproduction script: [`benchmarks/`](https://github.com/danielenricocahall/livefold/tree/main/benchmarks).
+
+## Examples
+
+Two runnable Streamlit demos in [`examples/`](https://github.com/danielenricocahall/livefold/tree/main/examples):
+
+- **[`system_metrics/`](https://github.com/danielenricocahall/livefold/tree/main/examples/system_metrics)** — live `psutil`-driven CPU/memory dashboard with arbitrary-range aggregate queries. Runs entirely offline.
+- **[`crypto_ticks/`](https://github.com/danielenricocahall/livefold/tree/main/examples/crypto_ticks)** — synthetic BTC/USD tick stream with high/low/avg-price queries. Includes a drop-in recipe for real Binance ticks.
+
+
+## API
+
+```python
+LiveFold(data: Iterable, folds: dict[str, Callable])
+```
+
+| Member | Returns | Notes |
+|---|---|---|
+| `lf.append(x)` | `None` | Amortized O(√n); worst-case O(n) on perfect-square crossings |
+| `lf.query(left, right)` | `dict[str, Any]` | O(√n); inclusive bounds |
+| `lf.blocks` | `list[list]` | Underlying √n-sized blocks |
+| `lf.folded_values` | `dict[str, list]` | Per-fold, per-block aggregates |
+| `lf.insert / pop / extend / remove / sort / ...` | — | Standard `list` methods; blocks and folds updated in place |
+
+`LiveFold` subclasses `list`, so it's a drop-in for any code that expected a plain list — until you start calling `query`.
+
+## Time-indexed queries: `TimeIndexedLiveFold`
+
+For monotonic streams where you want to query by *time* instead of *index*, `TimeIndexedLiveFold` carries a parallel timestamp per element and exposes `query_time_range` — still O(√n).
+
+```python
+from livefold import TimeIndexedLiveFold
+
+lf = TimeIndexedLiveFold(
+    [1, 2, 3],
+    folds={"sum": sum, "max": max},
+    timestamps=[1.0, 2.0, 3.0],
+)
+lf.append(4, timestamp=4.0)
+lf.append(5, timestamp=5.0)
+
+lf.query_time_range(2.0, 4.0)
+# → {"sum": 9, "max": 4}
+```
+
+If you omit `timestamps` / `timestamp`, `time.time()` is used by default. The class is generic over the timestamp type — anything orderable works (`float`, `int`, `datetime`, ...). Pass explicit timestamps for any non-`float` type:
+
+```python
+from datetime import datetime
+from livefold import TimeIndexedLiveFold
+
+lf = TimeIndexedLiveFold[datetime](
+    [1, 2, 3],
+    folds={"sum": sum},
+    timestamps=[datetime(2025, 1, 1), datetime(2025, 6, 1), datetime(2026, 1, 1)],
+)
+lf.query_time_range(datetime(2025, 5, 1), datetime(2026, 6, 1))
+# → {"sum": 5}
+```
+
+`TimeIndexedLiveFold` is **append-only by design**. Operations that would break time ordering raise `MonotonicityError`:
+
+- `insert`, `sort`, `reverse` — would break the ordering invariant
+- slice `__setitem__`, slice `__delitem__` — would desync data and timestamps
+- `append` / `extend` with a timestamp earlier than the last stored one
+- `+` / `+=` with anything other than another `TimeIndexedLiveFold` (use `extend(values, timestamps=...)` instead)
+
+Integer indexing (`lf[i] = x`, `del lf[i]`), `pop`, `remove`, and `clear` work normally and keep the parallel timestamp list in sync. `+` and `+=` between two `TimeIndexedLiveFold` instances concatenate timestamps and re-check monotonicity.
+
+## How it works
+
+![Query animation](https://raw.githubusercontent.com/danielenricocahall/livefold/main/assets/query_animation.gif)
+
+`LiveFold` splits its underlying list into ⌊√n⌋ blocks of size √n, precomputes the configured folds for each block, and updates them incrementally on mutation. A `query(left, right)` walks at most two partial blocks plus the precomputed folds for whole-block spans in between — touching roughly 2√n elements per fold regardless of n. Mo's algorithm with mutability and a dict-shaped output.
+
+![Append re-block animation](https://raw.githubusercontent.com/danielenricocahall/livefold/main/assets/resize_animation.gif)
+
+`append` is **amortized O(√n)**. Most appends just push onto the last block at O(1), but each time `n` crosses a perfect square, `block_size = isqrt(n)` increments and the whole structure re-blocks — an O(n) cost. The gap between consecutive perfect squares is `2k + 1` (linear in `k = √n`, not geometric), so over `n` appends total rebuild work sums to Σ_{k=1}^{√n} O(k²) = O(n^(3/2)) — i.e. O(√n) per append amortized. Boundary crossings happen only ~once per √n appends, though, so the *median* append latency stays in the low µs range across all `n` (this is what the benchmarks show); the asymptotic only shows up in mean or total cost.
+
+`TimeIndexedLiveFold` layers a parallel monotonically non-decreasing timestamp list on top. `query_time_range(start, end)` calls `bisect_left`/`bisect_right` to map timestamps to indices in O(log n), then routes through the same √n-decomposed query path — so overall query cost stays O(√n).
+
+For the full derivation, complexity analysis, and other implementation details, see the [corresponding blog post](https://dannycahall.substack.com/p/square-root-decomposition-made-mutable).
+
+> *Note: the blog post predates the rebrand from `pysquagg` and uses the old singular `aggregator_function=` API. The math and structural choices are unchanged; only the package name and the `folds={"name": fn, ...}` dict shape have evolved.*
+
+## Fold contract
+
+A fold is a single-argument callable `fn(items) -> result` that:
+
+1. Accepts an **iterable** of elements (or, when called internally to combine block results, an iterable of prior fold results) and returns a single value.
+2. Is **associative**: `fn([fn([a, b]), fn([c, d])]) == fn([a, b, c, d])`. This lets `query` combine precomputed block-level folds with the partial folds at each end.
+3. Returns a value of the same shape it accepts as elements — i.e., feeding the result back through `fn` together with other results must work. `len` is a common-but-broken choice: it returns an `int` regardless of input shape, so `len([len(block_a), len(block_b)])` gives `2`, not the total element count.
+
+Examples that satisfy the contract: `sum`, `max`, `min`, `math.prod`, `math.gcd` (via `functools.reduce`), bitwise `or`/`and`/`xor`, `"".join`, and any mergeable sketch (t-digest, HyperLogLog, Count-Min, Welford) wrapped in a fold-shaped callable. Commutativity is *not* required — string concatenation, matrix multiplication, and other ordered monoids work too.
+
+## Constraints
+
+- **Not thread-safe.** Single-process, single-thread workloads only.
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/danielenricocahall/livefold/blob/main/CONTRIBUTING.md).

livefold-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+livefold/__init__.py,sha256=0klOsiEgesyfhNVjdDVwlRdvoPzjZCSqWkaY6uNNzo4,289
+livefold/livefold.py,sha256=EwHv2vdJE7rFZr1x5LyO1egb-VpelDiu_M0EMhdgtVA,13941
+livefold/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livefold-0.1.0.dist-info/METADATA,sha256=IqTB3VjUaMCk8UpHMEOyR-zm85lxluLdjNDkLzyt_wE,9020
+livefold-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+livefold-0.1.0.dist-info/licenses/LICENSE,sha256=dsRN6HXDmbpw1K4fTVXgOrzgsWZOjJ03O09ZkjQUR_A,1062
+livefold-0.1.0.dist-info/RECORD,,

livefold-0.1.0.dist-info/WHEEL

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

livefold-0.1.0.dist-info/licenses/LICENSE

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