mumpy-toolkit 0.2.0__py3-none-any.whl

mumpy/stats.py

@@ -0,0 +1,122 @@
+"""mumpy.stats: descriptive statistics & exploratory analysis for analysts."""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = [
+    "describe", "corr", "cov", "zscore", "iqr_outliers", "z_outliers",
+    "histogram", "percentile", "mode", "skew", "kurtosis",
+    "correlation_matrix", "crosstab", "value_counts",
+]
+
+
+def describe(a, percentiles=(25, 50, 75)):
+    a = np.asanyarray(a, dtype=float).ravel()
+    a = a[~np.isnan(a)]
+    if a.size == 0:
+        return {"count": 0}
+    return {
+        "count": int(a.size),
+        "mean": float(a.mean()),
+        "std": float(a.std()),
+        "min": float(a.min()),
+        **{f"{int(p)}%": float(np.percentile(a, p)) for p in percentiles},
+        "max": float(a.max()),
+    }
+
+
+def corr(x, y):
+    x = np.asanyarray(x, dtype=float).ravel()
+    y = np.asanyarray(y, dtype=float).ravel()
+    mask = ~(np.isnan(x) | np.isnan(y))
+    x, y = x[mask], y[mask]
+    if x.size < 2:
+        return float("nan")
+    return float(np.corrcoef(x, y)[0, 1])
+
+
+def cov(x, y, ddof=0):
+    x = np.asanyarray(x, dtype=float).ravel()
+    y = np.asanyarray(y, dtype=float).ravel()
+    mask = ~(np.isnan(x) | np.isnan(y))
+    return float(np.cov(x[mask], y[mask], ddof=ddof)[0, 1])
+
+
+def correlation_matrix(X):
+    X = np.asanyarray(X, dtype=float)
+    col_mean = np.nanmean(X, axis=0)
+    idx = np.where(np.isnan(X))
+    X = X.copy()
+    X[idx] = np.take(col_mean, idx[1])
+    return np.corrcoef(X, rowvar=False)
+
+
+def zscore(a, axis=None, ddof=0):
+    a = np.asanyarray(a, dtype=float)
+    m = np.nanmean(a, axis=axis, keepdims=True)
+    s = np.nanstd(a, axis=axis, ddof=ddof, keepdims=True)
+    s = np.where(s == 0, 1.0, s)
+    return (a - m) / s
+
+
+def iqr_outliers(a, factor=1.5):
+    a = np.asanyarray(a, dtype=float).ravel()
+    q1, q3 = np.nanpercentile(a, [25, 75])
+    iqr = q3 - q1
+    lo, hi = q1 - factor * iqr, q3 + factor * iqr
+    return (a < lo) | (a > hi), (float(lo), float(hi))
+
+
+def z_outliers(a, thresh=3.0):
+    z = np.abs(zscore(a))
+    return (z > thresh).ravel() if z.ndim == 1 else (z > thresh), thresh
+
+
+def histogram(a, bins=10, range=None):
+    a = np.asanyarray(a, dtype=float).ravel()
+    counts, edges = np.histogram(a[~np.isnan(a)], bins=bins, range=range)
+    return counts, edges
+
+
+def percentile(a, q):
+    return np.nanpercentile(np.asanyarray(a, dtype=float), q)
+
+
+def mode(a):
+    vals, counts = np.unique(np.asanyarray(a).ravel(), return_counts=True)
+    return vals[int(np.argmax(counts))]
+
+
+def skew(a):
+    a = np.asanyarray(a, dtype=float).ravel()
+    a = a[~np.isnan(a)]
+    m, s = a.mean(), a.std()
+    if s == 0 or a.size < 3:
+        return 0.0
+    return float((((a - m) / s) ** 3).mean())
+
+
+def kurtosis(a, fisher=True):
+    a = np.asanyarray(a, dtype=float).ravel()
+    a = a[~np.isnan(a)]
+    m, s = a.mean(), a.std()
+    if s == 0 or a.size < 4:
+        return 0.0
+    k = float((((a - m) / s) ** 4).mean())
+    return k - 3.0 if fisher else k
+
+
+def value_counts(a):
+    vals, counts = np.unique(np.asanyarray(a).ravel(), return_counts=True)
+    order = np.argsort(-counts)
+    return list(zip(vals[order].tolist(), counts[order].tolist()))
+
+
+def crosstab(a, b):
+    a = np.asanyarray(a).ravel()
+    b = np.asanyarray(b).ravel()
+    ua, ia = np.unique(a, return_inverse=True)
+    ub, ib = np.unique(b, return_inverse=True)
+    table = np.zeros((len(ua), len(ub)), dtype=int)
+    np.add.at(table, (ia, ib), 1)
+    return table, ua.tolist(), ub.tolist()

mumpy/utils.py

@@ -0,0 +1,105 @@
+"""mumpy utils: seeds, timing, chunking, memory helpers, missing-value utils."""
+from __future__ import annotations
+
+import time
+import numpy as np
+from contextlib import contextmanager
+
+__all__ = [
+    "seed", "timer", "timeit", "chunks", "asnumpy", "is_mumpy",
+    "memory_usage", "count_nan", "drop_nan", "fill_nan",
+    "normalize", "standardize", "one_hot",
+]
+
+
+def seed(s=None):
+    """Set global seeds for reproducibility (numpy + mumpy.random + python random)."""
+    import random as _pr
+    np.random.seed(s if s is None else int(s) % (2**32 - 1))
+    try:
+        from . import random as _cr
+        _cr.seed(s)
+    except Exception:
+        pass
+    _pr.seed(s)
+
+
+@contextmanager
+def timer(name="elapsed"):
+    t0 = time.perf_counter()
+    yield
+    print(f"{name}: {(time.perf_counter() - t0) * 1000:.2f}ms")
+
+
+def timeit(func, *args, repeat=5, warmup=1, **kw):
+    for _ in range(warmup):
+        func(*args, **kw)
+    best = min(
+        (lambda: (t0 := time.perf_counter(), func(*args, **kw),
+                  time.perf_counter() - t0)[2])()
+        for _ in range(repeat)
+    )
+    return best
+
+
+def chunks(n, size):
+    for i in range(0, n, size):
+        yield (i, min(i + size, n))
+
+
+def asnumpy(a):
+    return np.asanyarray(a).view(np.ndarray)
+
+
+def is_mumpy(a):
+    from ._core import ndarray
+    return isinstance(a, ndarray)
+
+
+# backward compat with the old `cumpy` name
+is_cumpy = is_mumpy
+
+
+def memory_usage(a):
+    a = np.asanyarray(a)
+    return int(a.nbytes)
+
+
+def count_nan(a):
+    return int(np.isnan(np.asanyarray(a, dtype=float)).sum())
+
+
+def drop_nan(a):
+    a = np.asanyarray(a)
+    mask = ~np.isnan(a.astype(float)) if np.issubdtype(a.dtype, np.number) else np.zeros(len(a), bool)
+    return a[mask] if a.ndim == 1 else a
+
+
+def fill_nan(a, value=0.0):
+    a = np.asanyarray(a).astype(float, copy=True)
+    a[np.isnan(a)] = value
+    return a
+
+
+def normalize(a, axis=None):
+    a = np.asanyarray(a, dtype=float)
+    n = np.linalg.norm(a, axis=axis, keepdims=True)
+    n[n == 0] = 1.0
+    return a / n
+
+
+def standardize(a, axis=0):
+    a = np.asanyarray(a, dtype=float)
+    m = a.mean(axis=axis, keepdims=True)
+    s = a.std(axis=axis, keepdims=True)
+    s[s == 0] = 1.0
+    return (a - m) / s
+
+
+def one_hot(labels, num_classes=None):
+    labels = np.asanyarray(labels).astype(int).ravel()
+    if num_classes is None:
+        num_classes = int(labels.max()) + 1 if labels.size else 0
+    out = np.zeros((labels.size, num_classes), dtype=float)
+    out[np.arange(labels.size), labels] = 1.0
+    return out

mumpy/viz.py

@@ -0,0 +1,81 @@
+"""mumpy.viz: one-line plots for quick EDA (requires matplotlib, optional)."""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["hist", "scatter", "line", "heatmap", "corr_heatmap", "boxplot"]
+
+
+def _plt():
+    try:
+        import matplotlib.pyplot as plt
+        return plt
+    except ImportError as e:
+        raise ImportError("pip install matplotlib") from e
+
+
+def hist(a, bins=30, title=None, show=False):
+    plt = _plt()
+    plt.figure()
+    plt.hist(np.asanyarray(a, dtype=float).ravel(), bins=bins)
+    if title:
+        plt.title(title)
+    if show:
+        plt.show()
+    return plt.gca()
+
+
+def scatter(x, y, title=None, show=False):
+    plt = _plt()
+    plt.figure()
+    plt.scatter(np.asanyarray(x).ravel(), np.asanyarray(y).ravel(), alpha=0.6)
+    if title:
+        plt.title(title)
+    if show:
+        plt.show()
+    return plt.gca()
+
+
+def line(*series, title=None, show=False):
+    plt = _plt()
+    plt.figure()
+    for s in series:
+        plt.plot(np.asanyarray(s).ravel())
+    if title:
+        plt.title(title)
+    if show:
+        plt.show()
+    return plt.gca()
+
+
+def heatmap(m, title=None, show=False):
+    plt = _plt()
+    plt.figure()
+    plt.imshow(np.asanyarray(m, dtype=float), aspect="auto")
+    plt.colorbar()
+    if title:
+        plt.title(title)
+    if show:
+        plt.show()
+    return plt.gca()
+
+
+def corr_heatmap(X, labels=None, show=False):
+    X = np.asanyarray(X, dtype=float)
+    C = np.corrcoef(X, rowvar=False)
+    ax = heatmap(C, title="Correlation", show=False)
+    if labels is not None:
+        ax.set_xticks(range(len(labels)), labels, rotation=45)
+        ax.set_yticks(range(len(labels)), labels)
+    if show:
+        _plt().show()
+    return ax
+
+
+def boxplot(*cols, labels=None, show=False):
+    plt = _plt()
+    plt.figure()
+    plt.boxplot([np.asanyarray(c, dtype=float).ravel() for c in cols], labels=labels)
+    if show:
+        plt.show()
+    return plt.gca()

mumpy_toolkit-0.2.0.dist-info/METADATA

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: mumpy-toolkit
+Version: 0.2.0
+Summary: NumPy-compatible array library with multithreaded ufuncs, fused ops, plus built-in IO, SQL databases, DataFrame, stats, preprocessing, metrics, ML and tiny DL
+Author-email: salim-studio <salim-studio@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/salim-studio/mumpy
+Project-URL: Repository, https://github.com/salim-studio/mumpy
+Project-URL: Issues, https://github.com/salim-studio/mumpy/issues
+Project-URL: Documentation, https://github.com/salim-studio/mumpy#readme
+Project-URL: Changelog, https://github.com/salim-studio/mumpy/blob/main/CHANGELOG.md
+Keywords: numpy,arrays,dataframe,sql,machine-learning,deep-learning,statistics,preprocessing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Database
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: fast
+Requires-Dist: scipy>=1.10; extra == "fast"
+Provides-Extra: io
+Requires-Dist: pandas>=1.5; extra == "io"
+Requires-Dist: pyarrow>=10; extra == "io"
+Provides-Extra: db
+Requires-Dist: sqlalchemy>=2.0; extra == "db"
+Requires-Dist: duckdb>=0.8; extra == "db"
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.5; extra == "viz"
+Provides-Extra: all
+Requires-Dist: scipy>=1.10; extra == "all"
+Requires-Dist: pandas>=1.5; extra == "all"
+Requires-Dist: pyarrow>=10; extra == "all"
+Requires-Dist: sqlalchemy>=2.0; extra == "all"
+Requires-Dist: duckdb>=0.8; extra == "all"
+Requires-Dist: matplotlib>=3.5; extra == "all"
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/banner.svg" alt="mumpy banner" width="100%"/>
+</p>
+
+<p align="center">
+  <img src="assets/logo.svg" alt="mumpy logo" width="96"/>
+</p>
+
+<h1 align="center">mumpy</h1>
+
+<p align="center"><strong>NumPy you know. Speed you feel. Tools you actually need.</strong></p>
+
+<p align="center">
+  <a href="https://github.com/salim-studio/mumpy/actions"><img src="https://github.com/salim-studio/mumpy/actions/workflows/ci.yml/badge.svg" alt="CI"/></a>
+  <img src="https://img.shields.io/badge/version-0.2.0-4F46E5" alt="version"/>
+  <img src="https://img.shields.io/badge/python-3.9%2B-06B6D4" alt="python"/>
+  <img src="https://img.shields.io/badge/numpy-compatible-013243" alt="numpy compatible"/>
+  <img src="https://img.shields.io/badge/license-MIT-FDE047" alt="license"/>
+</p>
+
+**mumpy** is a drop-in, NumPy-compatible library that goes further: multithreaded compute,
+fused operations, plus a built-in toolkit for data loading, SQL databases, dataframes,
+statistics, preprocessing, classic ML and tiny deep learning — with zero hard dependencies
+beyond NumPy.
+
+```python
+import mumpy as mp
+
+# 1) Faster NumPy (parallel ufuncs + fused ops)
+a = mp.arange(10_000_000)
+b = mp.sqrt(a)            # multithreaded over all cores
+c = mp.fma(a, b, 1.0)     # a*b+c in a single pass, half the peak memory
+
+# 2) Databases (sqlite built-in; postgres/mysql via SQLAlchemy, OLAP via DuckDB)
+db = mp.db.connect("data.db")
+db.create_table("users", {"id": "INTEGER PRIMARY KEY", "name": "TEXT", "age": "INTEGER"})
+db.insert_many("users", [{"name": "ada", "age": 36}])
+ages = db.read_numpy("SELECT age FROM users")
+
+# 3) Lightweight DataFrame for analysts (no pandas required)
+df = mp.frame.DataFrame({"age": [20, 30, 40], "salary": [100, 200, 300]})
+df.describe()
+df.groupby("age").mean()
+df.query("age > 25")
+
+# 4) Classic ML with a scikit-learn-like API (pure NumPy)
+model = mp.ml.LogisticRegression().fit(X_train, y_train)
+pred = model.predict(X_test)
+
+# 5) Tiny deep learning (pure NumPy)
+net = mp.nn.Sequential([mp.nn.Dense(4, 16), mp.nn.ReLU(), mp.nn.Dense(16, 1)])
+net.fit(X, y, epochs=200, lr=0.01)
+```
+
+## Why faster than NumPy?
+
+| Technique | Detail |
+|---|---|
+| Parallel ufuncs | Compute-bound element-wise ops (`sqrt/exp/sin/cos/…`) split across a thread pool |
+| Fused ops | `fma/fms/fnma/lerp` instead of `a*b+c` (half the peak memory, one pass) |
+| Parallel FFT | `scipy.fft` with `workers=-1` when SciPy is installed |
+| `einsum(optimize=True)` | Faster contraction paths |
+| Contiguous linalg | `batch_matmul/cho_solve/ridge_solve` ensure cache-friendly layouts |
+
+> Honest note: bandwidth-bound reductions (`sum/mean`) delegate to NumPy directly —
+> a single thread already saturates RAM bandwidth, and threading only adds overhead there.
+
+## Modules
+
+| Module | For | Highlights |
+|---|---|---|
+| `mp.io` | Everyone | `load_csv/save_csv/load_npy/load_npz/load_json/memmap/load_parquet/load_excel/read_auto` |
+| `mp.db` | Backend devs & analysts | `connect/read_numpy/read_pandas/write_numpy/from_csv/query/to_parquet` |
+| `mp.frame` | Data analysts | `DataFrame/filter/sort/groupby/merge/describe/corr/read_csv/read_sql/to_pandas` |
+| `mp.stats` | Exploratory analysis | `describe/corr/zscore/iqr_outliers/histogram/skew/kurtosis/crosstab` |
+| `mp.preprocessing` | Data science | `StandardScaler/MinMaxScaler/RobustScaler/OneHotEncoder/LabelEncoder/SimpleImputer/train_test_split/Pipeline` |
+| `mp.metrics` | Model evaluation | `mse/rmse/mae/r2/accuracy/precision/recall/f1/confusion_matrix/roc_auc/log_loss` |
+| `mp.ml` | Machine learning | `LinearRegression/Ridge/LogisticRegression/KNN/NaiveBayes/DecisionTree/RandomForest/KMeans/PCA` |
+| `mp.nn` | Deep learning | `Sequential/Dense/ReLU/Sigmoid/Tanh/Softmax/Dropout/Adam/SGD/MSE/BCE/CrossEntropy` |
+| `mp.viz` | Quick plots | `hist/scatter/line/heatmap/corr_heatmap` (matplotlib, optional) |
+| `mp.utils` | Everyone | `seed/timer/timeit/one_hot/standardize/fill_nan/memory_usage` |
+
+## Installation
+
+```bash
+pip install mumpy-toolkit            # core (numpy only)
+pip install "mumpy-toolkit[fast]"    # + scipy for parallel FFT
+pip install "mumpy-toolkit[all]"     # scipy, pandas, pyarrow, sqlalchemy, duckdb, matplotlib
+```
+
+From source:
+
+```bash
+git clone https://github.com/salim-studio/mumpy.git
+cd mumpy
+pip install -e ".[all]"
+```
+
+## Compatibility
+
+- `mumpy.ndarray` subclasses `np.ndarray` — any NumPy-consuming code accepts it unchanged.
+- `mp.asnumpy(x)` returns a plain zero-copy `np.ndarray` view.
+- `mp.set_workers(1)` reproduces pure-NumPy behavior for fair comparison.
+- `DataFrame.to_pandas()/from_pandas()` bridge to pandas; `Database` works with stdlib
+  sqlite and optionally SQLAlchemy (PostgreSQL/MySQL) and DuckDB.
+- Migrating from the old name? `import cumpy` still works via a compatibility shim.
+
+## Benchmarks & tests
+
+```bash
+python benchmarks/bench.py
+python -m pytest tests/ -q
+python examples_mumpy.py   # end-to-end: synthetic data -> DB -> DataFrame -> ML
+```
+
+## End-to-end example (synthetic data → DB → ML)
+
+```python
+import numpy as np
+import mumpy as mp
+
+rng = np.random.default_rng(0)
+X = rng.normal(size=(200, 3))
+y = (X[:, 0] + X[:, 1] > 0).astype(int)
+
+with mp.db.connect(":memory:") as db:
+    db.write_numpy("data", np.column_stack([X, y]), columns=["f0", "f1", "f2", "label"])
+    df = mp.frame.DataFrame.read_sql("SELECT * FROM data", db)
+
+print(df.describe())
+Xtr, Xte, ytr, yte = mp.ml.train_test_split(
+    df.to_numpy(["f0", "f1", "f2"]), df["label"].to_numpy(), test_size=0.2)
+acc = mp.metrics.accuracy(
+    yte, mp.ml.LogisticRegression(lr=0.5, epochs=500).fit(Xtr, ytr).predict(Xte))
+print("accuracy:", acc)
+```
+
+## Roadmap
+
+- [ ] PyPI release + versioned changelog
+- [ ] Optional Rust/Numba backend for ufuncs
+- [ ] `mp.sql` query builder + lazy frames
+- [ ] More estimators (Gradient Boosting, Isolation Forest)
+- [ ] ONNX export for `mp.nn`
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Bug reports and feature requests are welcome via
+[issues](https://github.com/salim-studio/mumpy/issues) — please use the templates.
+
+## License
+
+MIT — see [LICENSE](LICENSE). © salim-studio.

mumpy_toolkit-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+mumpy/__init__.py,sha256=EpM-tHY9N23cki0ElqJjgdJHay5GVY1-N_JxHR6LcHA,5756
+mumpy/_core.py,sha256=KLeRSRUS0PHUQKHyZ6PszWzuybg_KQuqqIzS9ANgQD0,7492
+mumpy/_math.py,sha256=F23GD_wtJjeMpYBplXTazYK9F42t5MAnEUqSGga4Qcs,8846
+mumpy/_parallel.py,sha256=GNe7UjKQjvlV3bAivhhD0RAi7DKbqJMgUZCO-KnjnFw,5592
+mumpy/db.py,sha256=LsntQ1iMk6iBjRdjOHfoSgGrN18Ytb4X5edfwcjaxy0,10674
+mumpy/fft.py,sha256=PV8p2ZEgkrCGkuFRV964kNJYgZWMp-t6Z9T5YHhqGVo,4483
+mumpy/frame.py,sha256=fd7vj6cHUGEkYNI0SooGBCkYyfDRfFoBu8clSEi5G0Y,15869
+mumpy/io.py,sha256=oFE_exgx8sYhQVnhQzEZILitAgRkWoVsLELGOm97eno,5900
+mumpy/linalg.py,sha256=T_KtF8jC-LHlx8GyM6E5n1EWHJlJmQWWJ0-gopEs8LM,1854
+mumpy/metrics.py,sha256=t3DYEvJFPqp-lN0oMVC1ocMTtHCbIiYo0372AayDCH8,7096
+mumpy/ml.py,sha256=FVuLCCvHu7qgxaqeL2KgRJqBGnr-cn5DTQub7D1cOvM,15462
+mumpy/nn.py,sha256=Ntlrd9ju5-LZlPiKDGqX0E3pnooMMs_pL2IBpjm_YB0,8186
+mumpy/preprocessing.py,sha256=Ga-v3kM8nSniOxwRvf8LuhsNp6EmaD7cMj77UX33-e4,8117
+mumpy/random.py,sha256=Q8oFOSf-washlm-Ne9niQHLR8WJc-lMXNjEUrLwRqTI,2480
+mumpy/stats.py,sha256=7Tv3eyBxiaCui8s8BQi0FNbkdntn-moX_R6xaTnqlhA,3575
+mumpy/utils.py,sha256=yWMHjIjS-PFqIztPKCYfojThnar6DqfrRhszMoJp5Ks,2645
+mumpy/viz.py,sha256=17PrKiMut6Lm_aZrR_9fRZUXHDK-3nJuODMox-6g3L4,2017
+mumpy_toolkit-0.2.0.dist-info/licenses/LICENSE,sha256=hDYVKKPqNhSZ9rd347j-lmHJTI0g35WOPTYMp8SMh9Q,1069
+mumpy_toolkit-0.2.0.dist-info/METADATA,sha256=eof0OoEzWpYFLEILACpJswlP1OaJv7ImcR3zvFNJ3V4,8470
+mumpy_toolkit-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mumpy_toolkit-0.2.0.dist-info/top_level.txt,sha256=mniPO61dR6cmqnvOLmWVGwe4QsTTDxPRJE6_-lV3LZk,6
+mumpy_toolkit-0.2.0.dist-info/RECORD,,

mumpy_toolkit-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mumpy_toolkit-0.2.0.dist-info/licenses/LICENSE

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

mumpy_toolkit-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mumpy