mumpy

NumPy you know. Speed you feel. Tools you actually need.

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.

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?

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

Installation

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:

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

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)

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. Bug reports and feature requests are welcome via issues — please use the templates.

License

MIT — see LICENSE. © salim-studio.