rustylab 0.3.0__tar.gz

rustylab-0.3.0/.claude/settings.json

@@ -0,0 +1,8 @@
+{
+  "model": "claude-opus-5",
+  "fallbackModel": ["claude-sonnet-5"],
+  "permissions": {
+    "defaultMode": "plan",
+    "deny": ["Edit", "Write", "NotebookEdit"]
+  }
+}

rustylab-0.3.0/.forgejo/workflows/num_acc_testing.yml

@@ -0,0 +1,46 @@
+name: Numerical Accuracy Testing
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+    types: [closed]
+
+jobs:
+  test:
+    runs-on: codeberg-medium-lazy
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust manually
+        run: |
+          curl https://sh.rustup.rs -sSf | sh -s -- -y
+          source $HOME/.cargo/env
+          rustup default stable
+
+      - name: Add Rust to PATH
+        run: echo "PATH=$HOME/.cargo/bin:$PATH" >> $GITHUB_ENV
+
+      - name: Create Python virtual environment
+        run: python3 -m venv venv
+
+      - name: Activate virtual environment and install Python dependencies
+        run: |
+          source venv/bin/activate
+          python -m pip install --upgrade pip
+          python -m pip install maturin
+          python -m pip install -r ./tests/requirements-testing.txt
+
+      - name: Build and install Rust extension
+        run: |
+          source venv/bin/activate
+          maturin develop --release --strip
+
+      - name: Run tests
+        run: |
+          source venv/bin/activate
+          pytest

rustylab-0.3.0/.github/workflows/build-wheels.yml

@@ -0,0 +1,122 @@
+name: Build wheels
+
+on:
+  push:
+    tags:
+        - "v*"
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build-wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python (for maturin & metadata)
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Build wheels with maturin
+        uses: PyO3/maturin-action@v1
+        with:
+          command: build
+          args: >
+            --release
+            --strip
+          manylinux: "2014"   # only used on Linux
+
+      - name: Verify the wheel ships the Python layer
+        shell: bash
+        run: |
+          python - <<'PY'
+          import pathlib, sys, zipfile
+
+          want = {p.relative_to("python").as_posix()
+                  for p in pathlib.Path("python/rustylab").rglob("*.py")}
+          bad = False
+          for whl in sorted(pathlib.Path("target/wheels").glob("*.whl")):
+              have = {n for n in zipfile.ZipFile(whl).namelist() if n.endswith(".py")}
+              missing = sorted(want - have)
+              print(whl.name, "OK" if not missing else f"MISSING {missing}")
+              bad |= bool(missing)
+          sys.exit(1 if bad else 0)
+          PY
+
+      - name: Smoke-test the wheel
+        shell: bash
+        run: |
+          python -m venv smoke
+          PY=smoke/bin/python
+          [ -x smoke/Scripts/python.exe ] && PY=smoke/Scripts/python.exe
+          "$PY" -m pip install --upgrade pip
+          "$PY" -m pip install target/wheels/*.whl
+          "$PY" - <<'PY'
+          import polars as pl
+          from rustylab import expr, stats
+
+          print("eager:", stats.norm.pdf(0.0))
+          lf = pl.LazyFrame({"x": [0.0, 1.0, 2.0]}).select(p=expr.stats.norm.pdf("x"))
+          a = lf.collect(engine="in-memory")["p"].to_list()
+          b = lf.collect(engine="streaming")["p"].to_list()
+          assert a == b, (a, b)
+          print("plugin:", a)
+          PY
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: target/wheels/*.whl
+
+  build-sdist:
+    name: Build sdist
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python (for maturin & metadata)
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist with maturin
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out target/wheels
+
+      - name: Verify the sdist carries both halves of the package
+        shell: bash
+        run: |
+          python - <<'PY'
+          import pathlib, tarfile
+
+          sdist = next(pathlib.Path("target/wheels").glob("*.tar.gz"))
+          names = tarfile.open(sdist).getnames()
+          for required in ("Cargo.toml", "pyproject.toml", "src/lib.rs",
+                           "python/rustylab/__init__.py",
+                           "python/rustylab/expr/stats/norm.py"):
+              assert any(n.endswith("/" + required) for n in names), required
+          print(sdist.name, "OK -", len(names), "entries")
+          PY
+
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: target/wheels/*.tar.gz

rustylab-0.3.0/.gitignore

@@ -0,0 +1,76 @@
+/target
+
+# Quarto
+**/.quarto/
+**/*.quarto_ipynb
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+.pytest_cache/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+.venv/
+env/
+bin/
+build/
+develop-eggs/
+dist/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+include/
+man/
+venv/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+pip-selfcheck.json
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Rope
+.ropeproject
+
+# Django stuff:
+*.log
+*.pot
+
+.DS_Store
+
+# Sphinx documentation
+docs/_build/
+
+# PyCharm
+.idea/
+
+# VSCode
+#.vscode/
+
+# Pyenv
+.python-version

rustylab-0.3.0/.vscode/ltex.dictionary.en-GB.txt

@@ -0,0 +1,6 @@
+RustyLab
+statsmodels
+maturin
+uv
+Codeberg
+Soper

rustylab-0.3.0/.vscode/ltex.hiddenFalsePositives.en-GB.txt

@@ -0,0 +1,7 @@
+{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qlinear_models\\E$"}
+{"rule":"LICENCE_LICENSE_NOUN_SINGULAR","sentence":"^\\QMIT License\\E$"}
+{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QCopyright © 2026 esuriddick\\E$"}
+{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QTHE 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.\\E$"}
+{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qspecial\\E$"}
+{"rule":"LICENCE_LICENSE_NOUN_SINGULAR","sentence":"^\\QLicence\n{{< include ../LICENSE >}}\\E$"}
+{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qmisc\nspecial\nstats\\E$"}

rustylab-0.3.0/CLAUDE.md

@@ -0,0 +1,22 @@
+# rustylab
+
+A Python library with a Rust backend, built to merge and unify functionality
+from SciPy, NumPy, statsmodels, scikit-learn, and river into a single API.
+
+## Architecture
+
+- Rust project where all functions are explicitly built for Python
+  interoperability (via `pyo3` or similar crates).
+- The project includes custom Rust modules that are part of this codebase,
+  not external crates.
+- Internal Rust functions are called through: `use crate::constants`,
+  `use crate::optimize`, `use crate::special`, `use crate::stats`,
+  `use crate::utils`, etc.
+
+## How to work with me
+
+- Do not edit files. Propose changes as suggestions or copy-pasteable
+  code replacements, and show enough surrounding context that I can
+  place the change myself.
+- When suggesting a function, respect the existing `crate::` module
+  boundaries above rather than introducing new top-level modules.

rustylab-0.3.0/CONTRIBUTING.md

@@ -0,0 +1,122 @@
+# Contributing to RustyLab
+Thank you for your interest in contributing to RustyLab! Contributions of all kinds are welcome — whether you want to report an issue, propose a feature, improve documentation, or submit code.
+
+## Getting Help
+Something is not working as expected? Is there a feature you would like to see implemented but are unsure how to approach it? Please head to the [Issues Page](https://codeberg.org/esuriddick/rustylab/issues) and open an issue.
+
+When creating an issue, please include one of the following tags in the title:
+
+- **FEATURE** — propose a new feature or an improvement to an existing one.
+- **BUG** — report unexpected or incorrect behaviour.
+- **HELP** — ask a question that does not fit the categories above.
+
+Examples:
+
+```bash
+[FEATURE] Generalized Linear Models
+[BUG] Function special.factorial is not returning the correct value
+[HELP] How to install RustyLab in Python?
+```
+
+## Propose your own code
+
+### Prerequisites
+
+* **Python:** 3.12 or higher for development; released wheels support 3.10+.
+* **Rust:** 1.92.0 or higher
+
+### Optional Tools
+
+* **Python package manager:** [uv](https://docs.astral.sh/uv/)
+* **IDE:** [Positron](https://positron.posit.co/)
+
+### Project layout
+
+RustyLab is a hybrid package - a Rust core plus a Python layer, both shipped in the wheel:
+
+* `src/**` - the Rust core. Eager functions are exposed with `pyo3`; expression functions
+  are exposed with `#[polars_expr]`, which turns each one into an exported symbol.
+* `python/rustylab/**` - the Python layer. The `expr/**` modules are thin wrappers that call
+  `register_plugin_function(..., function_name="…")`, where the name **must** match the
+  symbol exported by the Rust side.
+* `tests/**` and `benchmarks/**` - the numerical accuracy suite and the benchmark notebooks.
+* `docs/**` - the Quarto sources rendered into the Wiki.
+
+### Quick setup
+1. **Clone the repository**:
+```bash
+git clone https://codeberg.org/esuriddick/rustylab.git
+cd rustylab
+```
+
+2. **Set up the required virtual environments**
+
+There are three virtual environments, namely:
+
+* **Development** (`./requirements.txt`) — includes `maturin` for building and packaging Rust-based Python extension.
+* **Benchmarking** (`./benchmarks/requirements-benchmarking.txt`) — includes packages required for benchmarking.
+* **Testing** (`./tests/requirements-testing.txt`) — includes packages used for numerical accuracy tests.
+
+If you use `uv`, you can create the Development environment with:
+```bash
+uv venv
+uv pip install -r requirements.txt 
+```
+
+To set up the Benchmarking environment:
+```bash
+cd benchmarks
+uv venv
+uv pip install -r requirements-benchmarking.txt
+```
+
+To set up the Testing environment:
+```bash
+cd ../ # To return to the repository's root folder
+cd tests
+uv venv
+uv pip install -r requirements-testing.txt
+```
+
+### Development Workflow
+Please follow the existing project structure and create new modules only when necessary. RustyLab aims to maintain conceptual alignment with established Python libraries such as SciPy, scikit-learn, and statsmodels.
+
+When adding new functions or classes:
+
+- Provide clear documentation, so others can understand and review your work.
+- Ensure your implementation is testable.
+- Include benchmarks and tests where appropriate.
+
+An expression function is not finished until all five exist:
+
+1. The Rust implementation, exposed with `#[polars_expr]` in the right `crate::` module;
+2. The Python wrapper in `python/rustylab/expr/**`, whose `function_name` matches the exported symbol - `tests/test_plugin_symbols.py` enforces this;
+3. A test that collects the expression under **both** the `in-memory` and `streaming` engines and compares the results;
+4. A docstring on both sides - the eager one in `src/**`, the expression one in the Python wrapper;
+5. The matching section in `docs/**`.
+
+To debug your work before submission, build the RustyLab Python package using the Development environment:
+```bash
+source .venv/bin/activate # Linux / macOS
+.\.venv\Scripts\activate  # Windows
+maturin develop --release --strip
+```
+
+`maturin develop` installs **both** halves of the package, and it *copies* the modules under `python/rustylab/**` into `site-packages`. A Python-only edit is therefore not live: rebuild after touching `python/rustylab/**`, exactly as you would after touching `src/**`.
+
+This allows you to import and test RustyLab directly from your local environment.
+
+### Commit Guidelines
+Commits should follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification. Examples:
+```
+docs: documentation only changes
+feat: a new feature is introduced
+fix: a bug is fixed
+perf: code change that improves performance
+refactor: code change that neither fixes a bug nor adds a feature
+style: changes that do not affect the meaning of the code (whitespace, formatting, missing semi-colons, etc.)
+test: add missing tests or correcting existing tests
+```
+
+### Licence of contributions
+By contributing, you agree that your contributions will be licensed under the [MIT licence](https://opensource.org/license/MIT).