maten 0.1.0__tar.gz

maten-0.1.0/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-06-27
+
+### Added
+
+- Initial release with four subpackages:
+  - `maten.core` — NumPy-like tensor operations
+  - `maten.frame` — Pandas-like Series and DataFrame
+  - `maten.plot` — Matplotlib-like plotting (SVG output)
+  - `maten.neural` — TensorFlow-like autograd and training utilities
+- Unit tests, examples, and documentation

maten-0.1.0/LICENSE

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

maten-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include LICENSE
+include CHANGELOG.md
+recursive-include docs *.md
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]

maten-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: maten
+Version: 0.1.0
+Summary: Pure Python scientific computing — replaces NumPy, Pandas, Matplotlib & TensorFlow
+Home-page: https://github.com/maten/maten
+Author: maten contributors
+License: MIT License
+        
+        Copyright (c) 2026 Maten Contributors
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/yourname/maten
+Project-URL: Issues, https://github.com/yourname/maten/issues
+Keywords: numpy,pandas,matplotlib,tensorflow,machine-learning,dataframe,tensor,neural-network,pure-python,zero-dependency
+Classifier: Development Status :: 3 - Alpha
+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.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: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+Dynamic: requires-python
+
+# Maten
+
+A lightweight, dependency-free Python toolkit that provides NumPy-, Pandas-, Matplotlib-, and TensorFlow-like APIs for learning and prototyping.
+
+## Features
+
+- **maten.core** — N-dimensional tensors, element-wise math, and linear algebra
+- **maten.frame** — Series, DataFrame, groupby, and CSV/JSON I/O
+- **maten.plot** — SVG charts (line, bar, scatter, hist, pie, heatmap)
+- **maten.neural** — Scalar autograd, layers, optimizers, and a simple trainer
+
+## Installation
+
+From the project root:
+
+```bash
+pip install .
+```
+
+Editable install for development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick start
+
+```python
+import maten
+from maten.core import Tensor, zeros
+from maten.frame import DataFrame
+from maten.plot import subplots, line
+from maten.neural import Value
+
+print(maten.__version__)
+print(zeros(3))
+print(DataFrame({"x": [1, 2, 3]}))
+
+_, ax = subplots()
+line(ax, [0, 1, 2], [0, 1, 4])
+ax.save("demo.svg")
+
+x = Value(2.0)
+y = x * x
+y.backward()
+print(x.grad)  # 4.0
+```
+
+## Examples
+
+```bash
+python examples/core_demo.py
+python examples/frame_demo.py
+python examples/plot_demo.py
+python examples/neural_demo.py
+```
+
+## Tests
+
+```bash
+pytest
+```
+
+## Documentation
+
+- [Core](docs/core.md)
+- [Frame](docs/frame.md)
+- [Plot](docs/plot.md)
+- [Neural](docs/neural.md)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

maten-0.1.0/README.md

@@ -0,0 +1,73 @@
+# Maten
+
+A lightweight, dependency-free Python toolkit that provides NumPy-, Pandas-, Matplotlib-, and TensorFlow-like APIs for learning and prototyping.
+
+## Features
+
+- **maten.core** — N-dimensional tensors, element-wise math, and linear algebra
+- **maten.frame** — Series, DataFrame, groupby, and CSV/JSON I/O
+- **maten.plot** — SVG charts (line, bar, scatter, hist, pie, heatmap)
+- **maten.neural** — Scalar autograd, layers, optimizers, and a simple trainer
+
+## Installation
+
+From the project root:
+
+```bash
+pip install .
+```
+
+Editable install for development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick start
+
+```python
+import maten
+from maten.core import Tensor, zeros
+from maten.frame import DataFrame
+from maten.plot import subplots, line
+from maten.neural import Value
+
+print(maten.__version__)
+print(zeros(3))
+print(DataFrame({"x": [1, 2, 3]}))
+
+_, ax = subplots()
+line(ax, [0, 1, 2], [0, 1, 4])
+ax.save("demo.svg")
+
+x = Value(2.0)
+y = x * x
+y.backward()
+print(x.grad)  # 4.0
+```
+
+## Examples
+
+```bash
+python examples/core_demo.py
+python examples/frame_demo.py
+python examples/plot_demo.py
+python examples/neural_demo.py
+```
+
+## Tests
+
+```bash
+pytest
+```
+
+## Documentation
+
+- [Core](docs/core.md)
+- [Frame](docs/frame.md)
+- [Plot](docs/plot.md)
+- [Neural](docs/neural.md)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

maten-0.1.0/docs/core.md

@@ -0,0 +1,28 @@
+# maten.core
+
+NumPy-like tensor library with zero external dependencies.
+
+## Quick start
+
+```python
+from maten.core import Tensor, zeros, ones, arange, sin, matmul
+
+x = Tensor([[1, 2], [3, 4]])
+y = zeros((2, 2))
+print(x + y)
+print(matmul(x, x.T()))
+```
+
+## API overview
+
+| Module | Purpose |
+|--------|---------|
+| `tensor.py` | `Tensor` class — shape, indexing, arithmetic, reshape, transpose |
+| `creation.py` | `zeros`, `ones`, `arange`, `linspace`, `eye` |
+| `math_ops.py` | `sin`, `cos`, `exp`, `log`, `sqrt`, `relu` |
+| `linalg.py` | `norm`, `trace`, `det`, `matmul` |
+
+## Notes
+
+- Tensors store data in a flat list with an explicit shape tuple.
+- Broadcasting is limited to scalar-like tensors with `size == 1`.

maten-0.1.0/docs/frame.md

@@ -0,0 +1,22 @@
+# maten.frame
+
+Pandas-like tabular data structures.
+
+## Quick start
+
+```python
+from maten.frame import DataFrame, Series
+
+df = DataFrame({"name": ["a", "b"], "score": [10, 20]})
+print(df.describe())
+print(df.groupby("name").mean("score"))
+```
+
+## API overview
+
+| Module | Purpose |
+|--------|---------|
+| `series.py` | Labeled 1-D `Series` |
+| `dataframe.py` | Column-oriented `DataFrame` |
+| `groupby.py` | Split-apply-combine aggregations |
+| `io.py` | `read_csv`, `read_json`, `concat` |

maten-0.1.0/docs/neural.md

@@ -0,0 +1,35 @@
+# maten.neural
+
+Minimal autograd and training utilities inspired by micrograd and TensorFlow APIs.
+
+## Quick start
+
+```python
+from maten.neural import Linear, ReLU, Sequential, SGD, Value
+from maten.neural.losses import mse
+
+model = Sequential([Linear(2, 4), ReLU(), Linear(4, 1)])
+opt = SGD(model.parameters(), lr=0.01)
+
+x = [Value(1.0), Value(-1.0)]
+y = [Value(0.5)]
+
+opt.zero_grad()
+pred = model(x)
+loss = mse(pred, y)
+loss.backward()
+opt.step()
+```
+
+## API overview
+
+| Module | Purpose |
+|--------|---------|
+| `autograd.py` | Differentiable `Value` scalar |
+| `tensor.py` | Batched `Value` containers |
+| `layers.py` | `Linear`, `ReLU`, `Dropout`, `BatchNorm` |
+| `losses.py` | `mse`, `bce`, `cross_entropy` |
+| `optimizers.py` | `SGD`, `Adam`, `RMSProp` |
+| `sequential.py` | `Module`, `Sequential` |
+| `dataloader.py` | `DataLoader`, `Trainer` |
+| `metrics.py` | `accuracy`, `mse`, `r2_score` |

maten-0.1.0/docs/plot.md

@@ -0,0 +1,23 @@
+# maten.plot
+
+Matplotlib-inspired plotting that renders SVG.
+
+## Quick start
+
+```python
+from maten.plot import subplots, line, bar
+
+_, ax = subplots()
+line(ax, [0, 1, 2], [0, 1, 4])
+bar(ax, ["A", "B"], [3, 7])
+ax.save("chart.svg")
+```
+
+## API overview
+
+| Module | Purpose |
+|--------|---------|
+| `figure.py` | `Figure`, `Axes`, `subplots` |
+| `charts.py` | `line`, `scatter`, `bar`, `hist`, `pie`, `heatmap` |
+| `colors.py` | Named colors and categorical palettes |
+| `utils.py` | SVG helpers and linear scaling |

maten-0.1.0/maten/__init__.py

@@ -0,0 +1,57 @@
+"""
+maten — Pure Python scientific computing library
+=================================================
+Single import replaces NumPy + Pandas + Matplotlib + TensorFlow.
+
+    import maten as mt
+
+    mt.array(...)          # arrays
+    mt.DataFrame(...)      # dataframes
+    mt.subplots()          # plots
+    mt.Sequential(...)     # neural networks
+"""
+
+__version__ = "0.1.0"
+__author__  = "maten contributors"
+
+# ── core (NumPy replacement) ──────────────────────────────────
+from maten.core.tensor   import Tensor, array, matmul
+from maten.core.creation import (zeros, ones, full, eye, arange, linspace,
+                                  rand, randn, randint, concatenate, stack)
+from maten.core.math_ops import (sqrt, exp, log, log2, log10,
+                                  sin, cos, tan, tanh,
+                                  abs_, ceil, floor,
+                                  sigmoid, relu, leaky_relu,
+                                  clip, softmax, where, unique, sort)
+from maten.core.linalg   import linalg
+
+# ── frame (Pandas replacement) ────────────────────────────────
+from maten.frame.series    import Series
+from maten.frame.dataframe import DataFrame
+from maten.frame.groupby   import GroupBy
+from maten.frame.io        import read_csv, read_json, concat as concat_frames
+
+# ── plot (Matplotlib replacement) ─────────────────────────────
+from maten.plot.figure import (Figure, Axes,
+                                figure, subplots, show, savefig,
+                                plot, scatter, bar, barh, hist,
+                                fill_between, axhline, axvline,
+                                xlabel, ylabel, title, legend, xlim, ylim)
+from maten.plot.charts import pie, heatmap
+
+# ── neural (TensorFlow replacement) ───────────────────────────
+from maten.neural.autograd   import Value
+from maten.neural.sequential import Module, Sequential
+from maten.neural.layers     import (Parameter, Linear,
+                                     ReLU, Sigmoid, Tanh, Softmax,
+                                     LeakyReLU, Dropout, BatchNorm1d, Flatten)
+from maten.neural.losses     import (MSELoss, MAELoss, BCELoss,
+                                     CrossEntropyLoss, HuberLoss)
+from maten.neural.optimizers import SGD, Adam, AdamW, RMSProp, Adagrad
+from maten.neural.metrics    import (accuracy, mean_squared_error,
+                                     mean_absolute_error, r2_score, rmse,
+                                     precision, recall, f1_score, confusion_matrix)
+from maten.neural.dataloader import DataLoader, Trainer
+
+# ── neural tensor (separate namespace to avoid clash with core) 
+from maten.neural import tensor as nn_tensor

maten-0.1.0/maten/core/creation.py

@@ -0,0 +1,68 @@
+"""
+maten.core.creation — array creation functions
+"""
+
+import random
+from functools import reduce
+import operator
+from maten.core.tensor import Tensor
+
+
+def zeros(shape, dtype=float):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([dtype(0)] * size, shape, dtype)
+
+def ones(shape, dtype=float):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([dtype(1)] * size, shape, dtype)
+
+def full(shape, fill_value, dtype=float):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([dtype(fill_value)] * size, shape, dtype)
+
+def eye(n, dtype=float):
+    t = zeros((n, n), dtype=dtype)
+    for i in range(n):
+        t._data[i * n + i] = dtype(1)
+    return t
+
+def arange(start, stop=None, step=1, dtype=float):
+    if stop is None: start, stop = 0, start
+    data, v = [], start
+    while (step > 0 and v < stop) or (step < 0 and v > stop):
+        data.append(dtype(v)); v += step
+    return Tensor._make(data, (len(data),), dtype)
+
+def linspace(start, stop, num=50, dtype=float):
+    if num == 1:
+        return Tensor._make([dtype(start)], (1,), dtype)
+    step = (stop - start) / (num - 1)
+    data = [dtype(start + i * step) for i in range(num)]
+    return Tensor._make(data, (num,), dtype)
+
+def rand(*shape):
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([random.random() for _ in range(size)], shape, float)
+
+def randn(*shape):
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([random.gauss(0, 1) for _ in range(size)], shape, float)
+
+def randint(low, high, shape):
+    if isinstance(shape, int): shape = (shape,)
+    size = reduce(operator.mul, shape, 1)
+    return Tensor._make([float(random.randint(low, high - 1)) for _ in range(size)], shape, float)
+
+def concatenate(tensors, axis=0):
+    if axis == 0:
+        data     = []
+        for t in tensors: data.extend(t._data)
+        new_shape = (sum(t._shape[0] for t in tensors),) + tensors[0]._shape[1:]
+        return Tensor._make(data, new_shape, tensors[0].dtype)
+    raise NotImplementedError("concatenate on axis != 0 coming soon")
+
+def stack(tensors, axis=0):
+    return concatenate([t.expand_dims(axis) for t in tensors], axis=axis)

maten-0.1.0/maten/core/linalg.py

@@ -0,0 +1,78 @@
+"""
+maten.core.linalg — linear algebra operations
+"""
+
+import math
+import operator
+from functools import reduce
+from maten.core.tensor import Tensor, matmul
+
+
+class linalg:
+
+    @staticmethod
+    def norm(t, ord=2):
+        if ord == 2:           return Tensor._make([math.sqrt(sum(x**2 for x in t._data))], (1,), float)
+        elif ord == 1:         return Tensor._make([sum(abs(x) for x in t._data)], (1,), float)
+        elif ord == float('inf'): return Tensor._make([max(abs(x) for x in t._data)], (1,), float)
+        raise ValueError(f"Unsupported norm order: {ord}")
+
+    @staticmethod
+    def dot(a, b):
+        return a.dot(b)
+
+    @staticmethod
+    def matmul(a, b):
+        return matmul(a, b)
+
+    @staticmethod
+    def transpose(t):
+        return t.T
+
+    @staticmethod
+    def trace(t):
+        assert t.ndim == 2 and t._shape[0] == t._shape[1]
+        n = t._shape[0]
+        return Tensor._make([sum(t._data[i * n + i] for i in range(n))], (1,), float)
+
+    @staticmethod
+    def det(t):
+        assert t.ndim == 2 and t._shape[0] == t._shape[1]
+        n   = t._shape[0]
+        from maten.core.tensor import _make_nested
+        mat = [row[:] for row in _make_nested(t._data, t._shape)]
+        det = 1.0
+        for col in range(n):
+            pivot = next((r for r in range(col, n) if abs(mat[r][col]) > 1e-12), None)
+            if pivot is None: return Tensor._make([0.0], (1,), float)
+            if pivot != col:
+                mat[col], mat[pivot] = mat[pivot], mat[col]; det *= -1
+            det *= mat[col][col]
+            for row in range(col + 1, n):
+                f = mat[row][col] / mat[col][col]
+                for k in range(col, n):
+                    mat[row][k] -= f * mat[col][k]
+        return Tensor._make([det], (1,), float)
+
+    @staticmethod
+    def inv(t):
+        assert t.ndim == 2 and t._shape[0] == t._shape[1]
+        n = t._shape[0]
+        from maten.core.tensor import _make_nested
+        mat = [row[:] for row in _make_nested(t._data, t._shape)]
+        inv = [[float(i == j) for j in range(n)] for i in range(n)]
+        for col in range(n):
+            pivot = next((r for r in range(col, n) if abs(mat[r][col]) > 1e-12), None)
+            if pivot is None: raise ValueError("Matrix is singular")
+            mat[col], mat[pivot] = mat[pivot], mat[col]
+            inv[col], inv[pivot] = inv[pivot], inv[col]
+            scale = mat[col][col]
+            mat[col] = [v / scale for v in mat[col]]
+            inv[col] = [v / scale for v in inv[col]]
+            for row in range(n):
+                if row != col:
+                    f = mat[row][col]
+                    mat[row] = [mat[row][k] - f * mat[col][k] for k in range(n)]
+                    inv[row] = [inv[row][k] - f * inv[col][k] for k in range(n)]
+        flat = [v for row in inv for v in row]
+        return Tensor._make(flat, (n, n), float)

maten-0.1.0/maten/core/math_ops.py

@@ -0,0 +1,56 @@
+"""
+maten.core.math_ops — mathematical functions
+"""
+
+import math
+from maten.core.tensor import Tensor
+
+
+def _apply(t, func):
+    if isinstance(t, (int, float)): return func(t)
+    return t.apply(func)
+
+def sqrt(t):    return _apply(t, math.sqrt)
+def exp(t):     return _apply(t, math.exp)
+def log(t):     return _apply(t, math.log)
+def log2(t):    return _apply(t, math.log2)
+def log10(t):   return _apply(t, math.log10)
+def sin(t):     return _apply(t, math.sin)
+def cos(t):     return _apply(t, math.cos)
+def tan(t):     return _apply(t, math.tan)
+def tanh(t):    return _apply(t, math.tanh)
+def abs_(t):    return _apply(t, abs)
+def ceil(t):    return _apply(t, math.ceil)
+def floor(t):   return _apply(t, math.floor)
+
+def sigmoid(t):
+    return _apply(t, lambda x: 1 / (1 + math.exp(-x)))
+
+def relu(t):
+    return _apply(t, lambda x: max(0.0, x))
+
+def leaky_relu(t, alpha=0.01):
+    return _apply(t, lambda x: x if x > 0 else alpha * x)
+
+def clip(t, min_val, max_val):
+    return _apply(t, lambda x: max(min_val, min(max_val, x)))
+
+def softmax(t):
+    m = max(t._data)
+    exps  = [math.exp(x - m) for x in t._data]
+    total = sum(exps)
+    return Tensor._make([e / total for e in exps], t._shape, float)
+
+def where(condition, x, y):
+    data = [a if c else b for c, a, b in zip(condition._data, x._data, y._data)]
+    return Tensor._make(data, condition._shape, x.dtype)
+
+def unique(t):
+    return sorted(set(t._data))
+
+def sort(t):
+    return Tensor._make(sorted(t._data), t._shape, t.dtype)
+
+def matmul(a, b):
+    from maten.core.tensor import matmul as _matmul
+    return _matmul(a, b)