deep-atomic 0.1.0__py3-none-any.whl

deep_atomic/__init__.py

@@ -0,0 +1,7 @@
+"""deep-atomic - A simple deep learning framework built upon numpy only"""
+
+__version__ = "0.1.0"
+__author__ = "elliot_zh@proton.me"
+
+from .tensor import *
+from .op import *

deep_atomic/graph.py

@@ -0,0 +1,246 @@
+import numpy as np
+from .tensor import Tensor
+from abc import ABC, abstractmethod
+
+from .utils import *
+
+
+class Op(ABC):
+    @abstractmethod
+    def backward(self, grad):
+        pass
+
+
+class SingleOp(Op):
+    def __init__(self, input: Tensor):
+        self.input = input
+        self.input.depended_count += 1
+
+
+class TwoOp(Op):
+    def __init__(self, a1, a2):
+        self.a1_np, self.a2_np = (
+            i.to_np() if isinstance(i, Tensor) else i for i in [a1, a2]
+        )
+        self.a1, self.a2 = (i if isinstance(i, Tensor) else None for i in [a1, a2])
+        if isinstance(self.a1, Tensor):
+            self.a1.depended_count += 1
+        if isinstance(self.a2, Tensor):
+            self.a2.depended_count += 1
+
+
+class Add(TwoOp):
+    def __init__(self, a1, a2, sub=False):
+        super().__init__(a1, a2)
+        self.sub = sub
+
+    def backward(self, grad):
+        if self.a1 is not None:
+            self.a1.backward(grad)
+        if self.a2 is None:
+            return
+        if self.sub:
+            grad = -grad
+        self.a2.backward(grad)
+
+
+class Mul(TwoOp):
+    def __init__(self, a1, a2):
+        super().__init__(a1, a2)
+
+    def backward(self, grad):
+        if self.a1 is not None:
+            self.a1.backward(grad * self.a2_np)
+        if self.a2 is not None:
+            self.a2.backward(self.a1_np * grad)
+
+
+class Div(TwoOp):
+    def __init__(self, a1, a2):
+        super().__init__(a1, a2)
+
+    def backward(self, grad):
+        if self.a1 is not None:
+            self.a1.backward(grad / self.a2_np)
+        if self.a2 is not None:
+            self.a2.backward(-1 * self.a1_np / (self.a2_np**2) * grad)
+
+
+class MatMul(TwoOp):
+    def __init__(self, a1, a2):
+        super().__init__(a1, a2)
+
+    def backward(self, grad):
+        if self.a1 is not None:
+            self.a1.backward(grad @ self.a2_np.swapaxes(-1, -2))
+        if self.a2 is not None:
+            self.a2.backward(self.a1_np.swapaxes(-1, -2) @ grad)
+
+
+class Exp(SingleOp):
+    def __init__(
+        self, input: Tensor
+    ):  # node of exp is introduced only when the input is a Tensor
+        super().__init__(input)
+
+    def backward(self, grad):
+        self.input.backward(np.exp(self.input.to_np()) * grad)
+
+
+class Log(SingleOp):
+    def __init__(
+        self, input: Tensor
+    ):  # node of log is introduced only when the input is a Tensor
+        super().__init__(input)
+
+    def backward(self, grad):
+        self.input.backward(1 / self.input.to_np() * grad)
+
+
+class Pow(TwoOp):
+    def __init__(self, a1, a2):
+        super().__init__(a1, a2)
+
+    def backward(self, grad):
+        if self.a1 is not None:
+            self.a1.backward(self.a2_np * (self.a1_np) ** (self.a2_np - 1) * grad)
+        if self.a2 is not None:
+            self.a2.backward(np.log(self.a1_np) * (self.a1_np) ** (self.a2_np) * grad)
+
+
+class Sum(SingleOp):
+    def __init__(self, input: Tensor, axis, keepdims):
+        super().__init__(input)
+        self.axis = axis
+        self.keepdims = keepdims
+
+    def backward(self, grad):
+        if self.axis is None or self.keepdims:
+            self.input.backward(grad)
+        else:
+            self.input.backward(np.expand_dims(grad, self.axis))
+
+
+class Abs(SingleOp):
+    def __init__(self, input: Tensor):
+        super().__init__(input)
+
+    def backward(self, grad):
+        self.input.backward(np.where(grad < 0, -grad, grad))
+
+
+class MinMax(SingleOp):
+    def __init__(
+        self, input: Tensor, axis, keepdims, indices=None, full_red_value=None
+    ):
+        super().__init__(input)
+        self.indices = indices  # result of argmin / argmax. when axis is not None
+        self.axis, self.keepdims = axis, keepdims
+        self.full_red_value = full_red_value  # for faster compute when axis is None
+        if axis is None:
+            assert full_red_value is not None
+        else:
+            assert indices is not None
+
+    def backward(self, grad):
+        if self.axis is None:
+            if not self.keepdims:
+                grad = np.tile(grad, self.input.shape)
+            mask = self.input.to_np() == self.full_red_value
+            grad /= np.count_nonzero(
+                mask
+            )  # distribute gradient evenly across max values. following pytorch implementation
+        else:
+            if not self.keepdims:
+                tile_reps = [1] * self.input.ndim
+                tile_reps[self.axis] = self.input.shape[self.axis]
+                grad = np.expand_dims(grad, axis=self.axis)
+                grad = np.tile(grad, tile_reps)
+            baseline_expansion_axis = list(range(self.input.ndim))
+            baseline_expansion_axis.pop(self.axis)
+            baseline_indices = np.expand_dims(
+                np.arange(self.input.shape[self.axis]), axis=baseline_expansion_axis
+            )
+            mask = self.indices == baseline_indices
+        self.input.backward(np.where(mask, grad, 0.0))
+
+
+class Reshape(SingleOp):
+    def __init__(self, input: Tensor, from_):
+        super().__init__(input)
+        self.from_ = from_
+
+    def backward(self, grad):
+        self.input.backward(grad.reshape(self.from_))
+
+
+class Squeeze(SingleOp):
+    def __init__(self, input: Tensor, axis):
+        super().__init__(input)
+        self.axis = axis
+
+    def backward(self, grad):
+        self.input.backward(np.expand_dims(grad, self.axis))
+
+
+class ExpandDims(SingleOp):
+    def __init__(self, input: Tensor, axis):
+        super().__init__(input)
+        self.axis = axis
+
+    def backward(self, grad):
+        self.input.backward(grad.squeeze(self.axis))
+
+
+class Repeat(SingleOp):
+    def __init__(self, input: Tensor, repeats, axis=None):
+        super().__init__(input)
+        self.repeats = repeats
+        self.axis = axis
+
+    def backward(self, grad):
+        if isinstance(self.repeats, int):
+            if self.axis is None:
+                grad = grad.reshape(-1, self.repeats).sum(axis=-1)
+            else:
+                shape = list(grad.shape)
+                shape[self.axis] //= self.repeats
+                shape.insert(self.axis + 1, self.repeats)
+                grad = grad.reshape(shape).sum(axis=self.axis + 1)
+            self.input.backward(grad)
+        else:
+            if self.axis is None:
+                grad_ = np.zeros(len(self.repeats), dtype=grad.dtype)
+                start = 0
+                for i, r in enumerate(self.repeats):
+                    if r > 0:
+                        grad_[i] = grad[start : start + r].sum()
+                    start += r
+            else:
+                moved = np.moveaxis(grad, self.axis, 0)
+                grad_ = np.zeros(self.input.shape, dtype=grad.dtype)
+                start = 0
+                for i, r in enumerate(self.repeats):
+                    if r > 0:
+                        idx = [slice(None)] * self.input.ndim
+                        idx[self.axis] = i
+                        grad_[tuple(idx)] = moved[start : start + r].sum(axis=0)
+                    start += r
+            self.input.backward(grad_)
+
+
+class Tile(SingleOp):
+    def __init__(self, input: Tensor, reps):
+        super().__init__(input)
+        self.reps = reps
+
+    def backward(self, grad):
+        start = (grad.ndim - len(self.reps)) if grad.ndim > len(self.reps) else 0
+        for i, r in enumerate(self.reps, start=start):
+            shape = list(grad.shape)
+            shape[i] //= r
+            shape.insert(i + 1, r)
+            grad = grad.reshape(shape, order="F").sum(axis=i + 1)
+        if grad.ndim < len(self.reps):
+            grad = grad.reshape(self.input.shape)
+        self.input.backward(grad)

deep_atomic/op.py

@@ -0,0 +1,117 @@
+import numpy as np
+from .tensor import *
+from .graph import *
+
+
+# implement add, sub, mul, div etc. here
+def add(a1, a2):
+    return a1.__array_ufunc__(np.add, "__call__", a1, a2)
+
+
+def sub(a1, a2):
+    return a1.__array_ufunc__(np.subtract, "__call__", a1, a2)
+
+
+def mul(a1, a2):
+    return a1.__array_ufunc__(np.multiply, "__call__", a1, a2)
+
+
+def div(a1, a2):
+    return a1.__array_ufunc__(np.divide, "__call__", a1, a2)
+
+
+def matmul(a1, a2):
+    return a1.__array_ufunc__(np.matmul, "__call__", a1, a2)
+
+
+def pow(a1, a2):
+    return a1.__array_ufunc__(np.pow, "__call__", a1, a2)
+
+
+def exp(input):
+    # TODO: handle other methods for ufunc (or use torch like api?)
+    return input.__array_ufunc__(np.exp, "__call__", input)
+
+
+def log(input):
+    # TODO: handle other methods for ufunc (or use torch like api?)
+    return input.__array_ufunc__(np.log, "__call__", input)
+
+
+# we do not implement exp2, log2, log10 etc. for that this framework is mainly for neural network training and for simplicity
+
+
+def sum(input: Tensor, axis=None, keepdims=False):
+    return input.__array_ufunc__(np.add, "reduce", input, axis=axis, keepdims=keepdims)
+
+
+def max(input: Tensor, axis=None, keepdims=False):
+    res = Tensor(
+        np.max(input.to_np(), axis=axis, keepdims=keepdims), requires_grad=False
+    )
+    if input.requires_grad:
+        res.requires_grad = True
+        if axis == None:
+            res.dep = MinMax(input, None, keepdims, full_red_value=res.to_np())
+        else:
+            indices = np.argmax(input.to_np(), axis=axis, keepdims=True)
+            res.dep = MinMax(input, axis, keepdims, indices=indices)
+    return res
+
+
+def min(input: Tensor, axis=None, keepdims=False):
+    res = Tensor(
+        np.min(input.to_np(), axis=axis, keepdims=keepdims), requires_grad=False
+    )
+    if input.requires_grad:
+        res.requires_grad = True
+        if axis == None:
+            res.dep = MinMax(input, None, keepdims, full_red_value=res.to_np())
+        else:
+            indices = np.argmin(input.to_np(), axis=axis, keepdims=True)
+            res.dep = MinMax(input, axis, keepdims, indices=indices)
+    return res
+
+
+def argmax(input: Tensor, axis=-1, keepdims=False):
+    # no gradient concerned when performing argmax
+    return Tensor(
+        np.argmax(input.to_np(), axis=axis, keepdims=keepdims), requires_grad=False
+    )
+
+
+def argmin(input: Tensor, axis=-1, keepdims=False):
+    # no gradient concerned when performing armin
+    return Tensor(
+        np.argmin(input.to_np(), axis=axis, keepdims=keepdims), requires_grad=False
+    )
+
+
+def softmax(input: Tensor, axis=-1):
+    input = exp(input - max(input, axis=axis, keepdims=True))
+    return input / sum(input, axis=axis, keepdims=True)
+
+
+def log_softmax(input: Tensor, axis=-1):
+    input = input - max(input, axis=axis, keepdims=True)
+    return input - log(sum(exp(input), axis=axis, keepdims=True))
+
+
+def reshape(input: Tensor, target_shape):
+    return input.reshape(*target_shape)
+
+
+def squeeze(input: Tensor, axis):
+    return input.squeeze(axis)
+
+
+def expand_dims(input: Tensor, axis):
+    return input.expand_dims(axis)
+
+
+def repeats(input: Tensor, repeats, axis=None):
+    return input.repeat(repeats, axis)
+
+
+def tile(input: Tensor, reps):
+    return input.tile(*reps)

deep_atomic/tensor.py

@@ -0,0 +1,168 @@
+import numpy as np
+
+from .utils import *
+
+
+class Tensor(np.ndarray):
+    def __new__(
+        subtype,
+        arg0,  # arg0: ndarray | shape
+        requires_grad=True,  # for backward
+        dep=None,  # for backward
+        dtype=np.float64,
+        buffer=None,
+        offset=0,
+        strides=None,
+        order=None,
+    ):
+        if isinstance(arg0, np.ndarray):
+            obj = arg0.view(subtype)  # convert from ndarray
+        elif isinstance(arg0, np.generic):
+            obj = np.array(arg0).view(subtype)
+        else:
+            obj = super().__new__(subtype, arg0, dtype, buffer, offset, strides, order)
+
+        obj.requires_grad, obj.dep = requires_grad, dep
+        obj.depended_count = 0  # for topo sorting in backward
+        return obj
+
+    @property
+    def requires_grad(self):
+        return self._requires_grad
+
+    @requires_grad.setter
+    def requires_grad(self, value: bool):
+        self._requires_grad = value
+        if value:
+            # IMPORTANT: will reset gradient to zero
+            self.grad = np.zeros(self.shape)
+        else:
+            self.grad = None
+
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
+        # FIXME: ? when creating a view, we cannot rely on python's default reference mechanism. must share identical depended_count across views. should depended_count be a list?
+        self.requires_grad = getattr(obj, "requires_grad", True)
+        self.dep = getattr(obj, "dep", None)
+        self.depended_count = getattr(obj, "depended_cound", 0)
+        self.grad = getattr(obj, "grad", None)
+
+    def to_np(self):
+        return self.view(np.ndarray)
+
+    def backward(self, grad=None):
+        if not self.requires_grad:
+            return
+        if grad is None:  # source point of compute graph
+            # TODO: support Vector-Jacobian Product like pytorch
+            assert self.size == 1  # must be scalar
+            self.grad += 1
+        # otherwise receive gradient from graph
+        elif grad.size == 1:
+            self.grad += np.tile(grad, self.shape)
+        elif is_broadcastable(grad.shape, self.shape):
+            self.grad += grad
+        elif grad.shape != self.shape:
+            grad_ = grad
+            dim_to_reduce = detect_broadcast_dim(self.shape, grad.shape)
+            for dim, keepdims in dim_to_reduce:
+                grad_ = grad_.sum(axis=dim, keepdims=keepdims)
+            self.grad += grad_
+        else:
+            raise ValueError(
+                f"Invalid gradient shape. Expected {self.shape}, but got {grad.shape}"
+            )
+        self.depended_count -= 1
+        if self.dep is not None and self.depended_count <= 0:
+            self.dep.backward(self.grad)  # trigger graph
+
+    # override operations
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        # type conversion
+        inputs_np = []
+        requires_grad = self.requires_grad
+        for input_ in inputs:
+            if isinstance(input_, Tensor):
+                inputs_np.append(input_.to_np())
+                requires_grad = requires_grad or input_.requires_grad
+            else:
+                inputs_np.append(input_)
+
+        result_np = super().__array_ufunc__(ufunc, method, *inputs_np, **kwargs)
+
+        if not requires_grad:
+            return Tensor(result_np, requires_grad=False)
+
+        # if requires_grad, construct graph
+        # TODO: implement gradient computation for other methods / ufuncs
+        if ufunc is np.add:
+            if method == "__call__":
+                res = Tensor(result_np, dep=Add(*inputs))
+            elif method == "reduce":
+                axis = getattr(kwargs, "axis", None)
+                keepdims = getattr(kwargs, "keepdims", False)
+                res = Tensor(result_np, dep=Sum(*inputs, axis, keepdims))
+            else:
+                return NotImplemented
+        elif ufunc is np.subtract:
+            res = Tensor(result_np, dep=Add(*inputs, sub=True))
+        elif ufunc is np.multiply:
+            res = Tensor(result_np, dep=Mul(*inputs))
+        elif ufunc is np.divide:
+            res = Tensor(result_np, dep=Div(*inputs))
+        elif ufunc is np.matmul:
+            res = Tensor(result_np, dep=MatMul(*inputs))
+        elif ufunc is np.exp:
+            res = Tensor(result_np, dep=Exp(*inputs))
+        elif ufunc is np.exp2:
+            res = Tensor(result_np, dep=Exp(Mul(*inputs, np.log(2))))
+        elif ufunc is np.log:
+            res = Tensor(result_np, dep=Log(*inputs))
+        elif ufunc is np.log2:
+            res = Tensor(result_np, dep=Div(Log(*inputs), np.log(2)))
+        elif ufunc is np.log10:
+            res = Tensor(result_np, dep=Div(Log(*inputs), np.log(10)))
+        elif ufunc is np.pow:
+            res = Tensor(result_np, dep=Pow(*inputs))
+        elif ufunc is np.square:
+            res = Tensor(result_np, dep=Pow(*inputs, 2))
+        elif ufunc is np.abs:
+            res = Tensor(result_np, dep=Abs(*inputs))
+        else:
+            return NotImplemented
+
+        return res
+
+    def reshape(self, *target_shape):
+        res = Tensor(super().reshape(*target_shape), requires_grad=self.requires_grad)
+        if self.requires_grad:
+            res.dep = Reshape(self, self.shape)
+        return res
+
+    def squeeze(self, axis):
+        res = Tensor(super().squeeze(axis), requires_grad=self.requires_grad)
+        if self.requires_grad:
+            res.dep = Squeeze(self, axis)
+        return res
+
+    def expand_dims(self, axis):
+        res = Tensor(np.expand_dims(super(), axis), requires_grad=self.requires_grad)
+        if self.requires_grad:
+            res.dep = ExpandDims(self, axis)
+        return res
+
+    def repeat(self, repeats, axis=None):
+        res = Tensor(super().repeat(repeats, axis), requires_grad=self.requires_grad)
+        if self.requires_grad:
+            res.dep = Repeat(self, repeats, axis)
+        return res
+
+    def tile(self, *reps):
+        res = Tensor(np.tile(super(), reps), requires_grad=self.requires_grad)
+        if self.requires_grad:
+            res.dep = Tile(self, reps)
+        return res
+
+
+from .graph import *  # avoid looped dependencies

deep_atomic/utils.py

@@ -0,0 +1,17 @@
+def detect_broadcast_dim(from_, to_):
+    detected = []
+    for i in range(-1, -len(to_) - 1, -1):
+        if i < -len(from_):
+            detected.append((i + len(to_), False))
+        elif from_[i] == 1 and to_[i] != 1:
+            detected.append((i + len(to_), True))  # True tp keepdims
+        elif from_[i] != to_[i]:
+            raise ValueError(f"{from_} cannot be broadcasted to target shape {to_}")
+    return detected
+
+
+def is_broadcastable(from_, to_):
+    res = True
+    for i in range(-1, -len(to_) - 1, -1):
+        res = res and (from_[i] == to_[i] or from_[i] == 1 and to_[i] != 1)
+    return res

deep_atomic-0.1.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: deep_atomic
+Version: 0.1.0
+Summary: A simple deep learning framework built upon numpy only
+Author-email: Elliot Zhang <elliot_zh@proton.me>
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.24.4
+Requires-Dist: pytest>=8.3.5
+Provides-Extra: dev
+Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# deep-atomic
+
+A simple deep learning framework built upon numpy only. Mainly for practice and learning.
+
+## Usage
+
+### Import
+
+```python
+import deep_atomic as da
+import numpy as np   # required for tensor initialization and some operations
+```
+
+### Creating a Tensor
+
+```python
+# Create a tensor from a NumPy array (requires_grad=True by default)
+a = da.Tensor(
+    np.array([1, 2, 3], dtype=np.float64),
+    requires_grad=True
+)
+```
+
+### Supported Operations
+
+Most essential deep‑learning operations are implemented. For those that also exist in NumPy, we follow NumPy's API conventions.
+
+```python
+a, b = da.Tensor(np.random.rand(3, 4)), da.Tensor(np.random.rand(3, 4))
+
+# Arithmetic & math
+c = a + b                     # addition
+c = a - b                     # subtraction
+c = a * b                     # element‑wise multiplication
+c = a / b                     # element‑wise division
+c = a ** b                    # element‑wise power
+c = a @ b                     # matrix multiplication
+c = da.exp(a)
+c = da.log(a)
+
+# Reductions
+c = da.sum(a)                               # shape: (1,)
+c = da.sum(a, axis=1)                       # shape: (3,)
+c = da.sum(a, axis=1, keepdims=True)        # shape: (3, 1)
+# min, max, argmin, argmax follow the same signature
+
+# Softmax
+c = da.softmax(a, axis=-1)
+c = da.log_softmax(a, axis=-1)
+
+# Shape manipulations
+c = a.reshape(2, 6)
+c = a.reshape(1, 12).squeeze(0)               # shape: (12,)
+c = da.expand_dims(a, -1)                   # shape: (3, 4, 1)
+c = a.expand_dims(-1)                         # method‑style alternative
+c = a.repeat(2, axis=1)                       # shape: (3, 8)
+c = da.tile(a, (2, 2))                      # shape: (6, 8)
+c = a.tile(2, 2)                              # method‑style alternative
+```
+
+## Todo
+
+- [ ] more basic operations and their autograd
+    - [ ] convolution and 2d convolution
+    - [ ] topk
+    - [ ] boolean and masked operation
+    - [ ] einsum
+    - [ ] scatter
+- [ ] basic neural network classes
+- [ ] optimizers and loss functions
+- [ ] full training test
+- [ ] benchmark with pytorch on CPU
+- [ ] attention layers and full LLM training
+- [ ] finer type annotations, comments and documentation
+
+## Installation
+
+```bash
+pip install deep_atomic
+
+# or with uv
+uv add deep_atomic
+```
+
+## Development
+
+Install in editable mode with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Run tests:
+
+```bash
+pytest
+```

deep_atomic-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+deep_atomic/__init__.py,sha256=qYv3Pu95A5_TZfrkC0J3O7YHs__vw4AUed20GQMoaKw,174
+deep_atomic/graph.py,sha256=o-ZClWo0QY4Pl8AkhZ5VHHRo8Lx9gYIYKIFUoe-nkFw,7573
+deep_atomic/op.py,sha256=rXQvrwkoCj9rLGBzysBfyF0hozusD1xwsoY3QzrSFFU,3262
+deep_atomic/tensor.py,sha256=JftulVvUghQZSFjdnknLO4xUSoLQdfgeo5tzgtYn3r0,6145
+deep_atomic/utils.py,sha256=9IHdlybDbzPcb2UnaXvAeGYXjyGZisQV-rxBVhUyaT4,615
+deep_atomic-0.1.0.dist-info/METADATA,sha256=29hTZMGvoNmqTgKSvbkAINPWBFH53V9pL3QLVz7grRc,3106
+deep_atomic-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+deep_atomic-0.1.0.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+deep_atomic-0.1.0.dist-info/RECORD,,

deep_atomic-0.1.0.dist-info/WHEEL

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

deep_atomic-0.1.0.dist-info/licenses/LICENSE

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