lme-python 0.1.7__tar.gz → 0.1.8__tar.gz

{lme_python-0.1.7 → lme_python-0.1.8}/.github/workflows/ci.yml

@@ -23,6 +23,28 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
+  rust-lint:
+    name: Rust fmt & clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install OpenBLAS
+        run: sudo apt-get update && sudo apt-get install -y libopenblas-dev
+      - name: Cache cargo registry & build
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ubuntu-lint-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ubuntu-lint-
+      - name: rustfmt --check
+        run: python3 scripts/ci/lme_ci.py fmt-check
+      - name: clippy
+        run: python3 scripts/ci/lme_ci.py clippy
+
   test:
     name: Test (${{ matrix.os }})
     runs-on: ${{ matrix.os }}
@@ -37,10 +59,6 @@ jobs:
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
 
-      - name: Install OpenBLAS (macOS)
-        if: matrix.os == 'macos-latest'
-        run: brew install openblas
-
       - name: Install OpenBLAS (Ubuntu)
         if: matrix.os == 'ubuntu-latest'
         run: sudo apt-get update && sudo apt-get install -y libopenblas-dev
@@ -55,6 +73,10 @@ jobs:
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-cargo-
 
+      - name: Set OpenBLAS target (macOS)
+        if: matrix.os == 'macos-latest'
+        run: echo "OPENBLAS_TARGET=ARMV8" >> "$GITHUB_ENV"
+
       - name: Build
         run: cargo build --verbose --locked
 

{lme_python-0.1.7 → lme_python-0.1.8}/.github/workflows/python-release.yml

@@ -82,8 +82,9 @@ jobs:
       - uses: actions/setup-python@v6
         with:
           python-version: '3.10'
-      - name: Install OpenBLAS
-        run: brew install openblas
+      - name: Set OpenBLAS target (Apple Silicon wheel)
+        if: matrix.target == 'aarch64'
+        run: echo "OPENBLAS_TARGET=ARMV8" >> "$GITHUB_ENV"
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:

{lme_python-0.1.7 → lme_python-0.1.8}/.github/workflows/repo-metadata.yml

@@ -24,10 +24,20 @@ jobs:
         run: |
           if [ -z "$REPO_ADMIN_TOKEN" ]; then
             echo "REPO_ADMIN_TOKEN is not set."
-            echo "Create a fine-grained PAT or GitHub App token with repository Administration: write."
+            echo "Create a fine-grained PAT with repository Administration: Read and write."
+            echo "Add it under Settings → Secrets and variables → Actions → REPO_ADMIN_TOKEN."
             exit 1
           fi
 
+      - name: Dry-run metadata payload
+        run: python scripts/sync_github_repo_metadata.py --dry-run
+
+      - name: Verify admin token is valid
+        env:
+          REPO_ADMIN_TOKEN: ${{ secrets.REPO_ADMIN_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+        run: python scripts/sync_github_repo_metadata.py --verify-token
+
       - name: Sync repository metadata
         env:
           REPO_ADMIN_TOKEN: ${{ secrets.REPO_ADMIN_TOKEN }}

lme_python-0.1.8/AGENTS.md

@@ -0,0 +1,173 @@
+# Agent and contributor pre-flights
+
+This repo uses **four tiers** of checks (one more than a typical Task + bash-hook setup). Pick the tier that matches how much you changed.
+
+## Architecture (vs duplicated shell scripts)
+
+```mermaid
+flowchart TD
+  subgraph entry [Entry points]
+    task[Taskfile.yml]
+    lh[Lefthook]
+    gha[GitHub Actions]
+    legacy[scripts/local_ci.*]
+  end
+
+  subgraph core [Single implementation]
+    lme["scripts/ci/lme_ci.py"]
+  end
+
+  subgraph tools [Pinned tooling via mise.toml]
+    mise[mise install]
+    uv[uv — Python venv + Ruff]
+    lk[lefthook — git hooks]
+  end
+
+  task --> lme
+  lh --> lme
+  gha --> lme
+  legacy --> lme
+  mise --> uv
+  mise --> lk
+```
+
+**Why this is better than parallel `.ps1` / `.sh` trees:**
+
+| Piece | Role |
+|---|---|
+| [`scripts/ci/lme_ci.py`](lme_ci.py) | One cross-platform implementation (stdlib Python 3.10+) |
+| [`lefthook.yml`](../lefthook.yml) | Declarative hooks, **parallel** pre-commit, `stage_fixed` auto-staging |
+| [`mise.toml`](../mise.toml) | Pins Rust, Python 3.11, uv, lefthook, task — reproducible dev env |
+| [`uv`](https://docs.astral.sh/uv/) | Fast venv creation (`uv venv --python 3.11`), no repo-root `.venv` backup dance |
+| **Ruff** | `python/tests` + `python/examples` on `task lint`; staged auto-fix on commit |
+| **pre-push hook** | Automatic `preflight` (lint + `cargo check --all-targets` + `cargo audit` + repo metadata dry-run) |
+
+[`Taskfile.yml`](../Taskfile.yml) is a thin alias layer; it does not duplicate logic.
+
+## 0. One-time setup
+
+```powershell
+mise install          # rust, python 3.11, uv, lefthook, task
+task setup            # mise install + lefthook install
+```
+
+Or install tools manually, then:
+
+```powershell
+task hooks:install
+```
+
+## 1. On `git commit` (Lefthook — parallel, staged-only)
+
+[`lefthook.yml`](../lefthook.yml) runs only when matching files are staged:
+
+| Staged | Command | Notes |
+|---|---|---|
+| `**/*.rs` | `fmt` then `clippy` | `stage_fixed: true` re-stages rustfmt fixes |
+| `python/**/*.py` | `ruff-staged --fix` | Ruff check + format; auto-stages fixes |
+| `Cargo.toml`, `Cargo.lock`, `python/Cargo.toml`, `python/Cargo.lock` | `cargo check --all-targets` | Catches link/BLAS issues on your platform when manifests change |
+| `Cargo.toml`, `scripts/sync_github_repo_metadata.py` | `repo-metadata` dry-run (+ token verify if `REPO_ADMIN_TOKEN` set) | Validates About-box payload before GHA metadata sync |
+
+Runs **in parallel** where safe (Ruff vs Rust fmt). Clippy waits on fmt (`priority`); manifest `check` runs after clippy (`priority` 3).
+
+**Not** on commit: full `cargo test`, maturin/pytest, `pip-audit`.
+
+Bypass once: `git commit --no-verify`.
+
+## 2. On `git push` (Lefthook pre-push)
+
+Runs **`preflight`** in parallel with itself as one command:
+
+1. `lint` — Rust fmt/clippy + Ruff
+2. `cargo check --workspace --all-targets --locked` — compile graph including tests/examples
+3. `cargo audit` — root crate + `python/` (same as GHA audit job, without `pip-audit`)
+4. `repo-metadata` — dry-run from `Cargo.toml`; **`--verify-token`** when `REPO_ADMIN_TOKEN` is in the environment
+
+Install `cargo-audit` once: `cargo install cargo-audit` (pinned in GHA as 0.22.1).
+
+To catch **expired metadata tokens** before push (optional):
+
+```powershell
+$env:REPO_ADMIN_TOKEN = "<fine-grained PAT with Administration: Read and write>"
+task repo-metadata
+```
+
+If GHA reports `401 Bad credentials` on **Sync Repository Metadata**, rotate the secret: **Settings → Secrets and variables → Actions → `REPO_ADMIN_TOKEN`**.
+
+Bypass: `git push --no-verify`.
+
+**macOS Apple Silicon BLAS** (`openblas-static` vs MKL) is only exercised on `macos-latest` in GHA — Windows/Linux preflights cannot catch that matrix cell. After changing `Cargo.toml` BLAS target tables or release workflows, run `task ci` or wait for the macOS CI job.
+
+## 3. Before finishing work (manual)
+
+### Quick path
+
+```powershell
+task lint
+task preflight   # same as pre-push hook (without pip-audit)
+task audit       # full security audit incl. pip-audit
+```
+
+Runs Rust (`fmt --check` + clippy) and Python Ruff on `python/tests` and `python/examples`.
+
+If you changed **Python bindings**:
+
+```powershell
+task python
+```
+
+### Rust-only
+
+```powershell
+task rust
+```
+
+### Python-only
+
+```powershell
+task lint:python
+task python
+```
+
+Direct runner (no Task):
+
+```powershell
+python scripts/ci/lme_ci.py lint
+python scripts/ci/lme_ci.py python --reuse-venv
+```
+
+## 4. Before PR / large refactors
+
+```powershell
+task          # full core CI mirror
+task ci:fast  # reuse python/.venv, skip wheel-reinstall pytest
+```
+
+Equivalent:
+
+```powershell
+python scripts/ci/lme_ci.py ci
+python scripts/ci/lme_ci.py ci --reuse-venv --skip-wheel-reinstall
+```
+
+**CI-only:** multi-OS matrix, Python 3.10/3.12/3.13, production-load gates, `cargo audit` / `pip-audit`.
+
+## `lme_ci.py` commands
+
+| Command | Purpose |
+|---|---|
+| `ci` | Full core CI |
+| `lint` | Rust + Python static checks |
+| `preflight` | Pre-push: lint + check + cargo audit + repo metadata |
+| `audit` | cargo audit + pip-audit (GHA mirror) |
+| `repo-metadata` | Dry-run GitHub About sync; verify token if `REPO_ADMIN_TOKEN` set |
+| `rust-lint` | `fmt --check` + clippy |
+| `ruff-lint` | Ruff on `python/tests` + `python/examples` |
+| `rust-all` | Rust slice without Python bindings tests |
+| `python` | Maturin + pytest (+ wheel pass) |
+| `ruff-staged --fix` | Staged Python lint/format |
+| `hooks-install` | `lefthook install` |
+
+Run `python scripts/ci/lme_ci.py --help` for the full list.
+
+See also [`CONTRIBUTING.md`](../CONTRIBUTING.md).

{lme_python-0.1.7 → lme_python-0.1.8}/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.8] - 2026-07-01
+
+### Added
+
+- Python bindings pushed to ~95% Rust parity: `lm_matrix`, `contrast_matrix`, structured results (`PyConfintResult`, `PyFixedEffectsAnova`, `PyContrastTest`, `PyLikelihoodRatioAnova`, `PySimulateResult`), extra [`PyLmeFit`](python/src/lib.rs) getters (`b`, `u`, `beta_se`, `fixed_term_assign`, `categorical_levels`, `v_beta_unscaled`), and [`lme_python.pyi`](python/lme_python.pyi). Prior: `nlmer`, `glmer_weighted`, `contrast_matrix_from_names`, `test_contrast_vs`, metadata getters. Tests in [`python/tests/test_api_parity.py`](python/tests/test_api_parity.py).
+- Weighted GLMMs: [`glmer_weighted`](src/lib.rs) with prior observation weights in PIRLS / Laplace deviance (delegates to [`lmer_weighted`](src/lib.rs) for Gaussian). Python: `lme_python.glmer_weighted(..., weights=...)`. Tests: [`tests/test_glmm_weighted.rs`](tests/test_glmm_weighted.rs).
+- Nonlinear mixed models (`nlmer`-style): [`nlmer`](src/nlmm/mod.rs) with three-part formulas (`response ~ SSlogis(cov, Asym, xmid, scal) ~ Asym|group`), penalized Gauss–Newton inner loop, and golden-section profiling of a single random-effect standard deviation. Parity test [`tests/test_nlmm_orange.rs`](tests/test_nlmm_orange.rs) against `lme4::nlmer(Orange)` (ML, random effect on `Asym` only).
+- User-defined fixed-effects contrast tests: [`LmeFit::test_contrast`](src/contrast.rs), [`test_contrast_vs`](src/contrast.rs), and [`contrast_matrix_from_names`](src/contrast.rs) ([`tests/test_contrast.rs`](tests/test_contrast.rs)). Python: `fit.test_contrast(l_matrix)`.
+- Kenward–Roger multi-DoF ANOVA via `pbkrtest::KRmodcomp` / `.KR_adjust` ([`src/kr_modcomp.rs`](src/kr_modcomp.rs)) and structural `vcovAdj16` ([`src/kr_vcov_adj.rs`](src/kr_vcov_adj.rs)), wired from [`src/anova.rs`](src/anova.rs). Parity test [`tests/test_kr_modcomp_pastes.rs`](tests/test_kr_modcomp_pastes.rs); golden case `pastes_cask_multi_dof_reml` now checks KR ANOVA.
+
+### Changed
+
+- Kenward–Roger multi-DoF rows no longer use marginal-df pooling only; they use full `KRmodcomp` when `vcovAdj` differs from `vcov`, with pooling when adjustment is negligible (e.g. pastes batch RE).
+- CI and local dev tooling: single cross-platform [`scripts/ci/lme_ci.py`](scripts/ci/lme_ci.py) runner (Task, Lefthook, GitHub Actions, legacy `local_ci` scripts); [`Taskfile.yml`](Taskfile.yml), [`lefthook.yml`](lefthook.yml), [`mise.toml`](mise.toml) pins; Ruff on `python/tests` and `python/examples`. See [`AGENTS.md`](AGENTS.md).
+
 ## [0.1.7] - 2026-05-18
 
 ### Added

{lme_python-0.1.7 → lme_python-0.1.8}/CONTRIBUTING.md

@@ -11,9 +11,33 @@ This repository contains:
 
 ## Local setup
 
+### Recommended toolchain
+
+Install [mise](https://mise.jdx.dev) and run once per clone:
+
+```bash
+mise install
+task setup    # installs pinned tools + lefthook git hooks
+```
+
+[`mise.toml`](mise.toml) pins Rust (stable), Python 3.11, [uv](https://docs.astral.sh/uv/), [lefthook](https://lefthook.dev/), and [go-task](https://taskfile.dev).
+
+See [AGENTS.md](AGENTS.md) for the four-tier pre-flight model (Lefthook commit/push hooks → `task lint` / `task preflight` → `task ci`).
+
+Install **`cargo-audit`** for the pre-push hook: `cargo install cargo-audit` (GHA pins 0.22.1).
+
+### CI runner
+
+All checks share one implementation: [`scripts/ci/lme_ci.py`](scripts/ci/lme_ci.py). Task, Lefthook, GitHub Actions, and [`scripts/local_ci.sh`](scripts/local_ci.sh) call into it — no duplicated PowerShell/bash logic.
+
+```bash
+python3 scripts/ci/lme_ci.py ci
+python3 scripts/ci/lme_ci.py rust-lint
+```
+
 ### Rust
 
-Install a stable Rust toolchain via [rustup](https://rustup.rs).
+Install a stable Rust toolchain via [rustup](https://rustup.rs) (or `mise install`).
 
 Useful commands:
 
@@ -27,14 +51,35 @@ cargo clippy --locked -- -D warnings
 cargo doc --no-deps --locked
 ```
 
-To run the same **core** checks as [GitHub Actions CI](.github/workflows/ci.yml) locally (`--locked` build/test, Python 3.11 `maturin develop` + `pytest tests/`, `fmt`, `clippy`, `check --all-targets`, doctests, `doc`):
+Or via Task:
+
+```powershell
+task lint        # fmt --check + clippy + Ruff (python/tests + examples)
+task preflight   # pre-push hook: lint + check + cargo audit + repo-metadata dry-run
+task audit       # cargo audit + pip-audit (GHA security audit mirror)
+task rust        # full Rust slice (no Python)
+task             # full core CI mirror
+task ci:fast     # reuse python/.venv, skip wheel-reinstall pytest
+```
+
+To run the same **core** checks as [GitHub Actions CI](.github/workflows/ci.yml) locally:
 
 ```bash
-./scripts/local_ci.sh
+task ci
+# or
+python3 scripts/ci/lme_ci.py ci
 ```
 
 ```powershell
-.\scripts\local_ci.ps1
+task ci
+# or
+python scripts/ci/lme_ci.py ci
+```
+
+Git hooks (parallel pre-commit + pre-push **preflight**) via Lefthook:
+
+```powershell
+task hooks:install
 ```
 
 ### Python bindings
@@ -66,7 +111,7 @@ pip-compile pyproject.toml --extra dev -o requirements-ci.txt --allow-unsafe --s
 
 Use `pytest tests/` so only [`python/tests/`](python/tests/) runs (same as [`.github/workflows/ci.yml`](.github/workflows/ci.yml)); `pytest` alone also collects optional demos under `python/examples/`.
 
-The same flow runs in CI on every push/PR: a fresh `python/.venv` is created with Python **3.11**, then `pip install -r requirements-ci.txt`, `maturin develop`, and `pytest tests/`. CI also runs that binding flow on **Ubuntu only** for Python **3.10**, **3.12**, and **3.13** (see job `python-bindings-versions` in [`.github/workflows/ci.yml`](.github/workflows/ci.yml)). If you use **CPython 3.14** in your own venv, set `PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1` before `maturin develop` (see [python/PYTHON_GUIDE.md](python/PYTHON_GUIDE.md)). The [`scripts/local_ci.sh`](scripts/local_ci.sh) / [`scripts/local_ci.ps1`](scripts/local_ci.ps1) helpers temporarily back up existing `python/.venv` and repo-root `.venv`, run the Python 3.11 flow, then restore them.
+The [`scripts/local_ci.sh`](scripts/local_ci.sh) / [`scripts/local_ci.ps1`](scripts/local_ci.ps1) helpers use **uv** to create `python/.venv` with Python **3.11** explicitly, then `pip install -r requirements-ci.txt`, `maturin develop`, and `pytest tests/`. CI also runs that binding flow on **Ubuntu only** for Python **3.10**, **3.12**, and **3.13** (see job `python-bindings-versions` in [`.github/workflows/ci.yml`](.github/workflows/ci.yml)). If you use **CPython 3.14** in your own venv, set `PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1` before `maturin develop` (see [python/PYTHON_GUIDE.md](python/PYTHON_GUIDE.md)).
 
 ## Working on numerical changes
 
@@ -111,6 +156,15 @@ The GitHub About box is synced from `Cargo.toml` using:
 
 If you change `package.description`, `homepage`, `keywords`, or `categories`, the metadata workflow will update the GitHub repository metadata on the next run.
 
+Preflight locally:
+
+```powershell
+task repo-metadata          # dry-run; verifies token if REPO_ADMIN_TOKEN is set
+python scripts/sync_github_repo_metadata.py --dry-run
+```
+
+The workflow needs a valid **`REPO_ADMIN_TOKEN`** repository secret (fine-grained PAT with **Administration: Read and write** on this repo). If CI fails with `401 Bad credentials`, create a new PAT and update **Settings → Secrets and variables → Actions → REPO_ADMIN_TOKEN**.
+
 ## Pull request expectations
 
 Keep changes focused. For non-trivial changes, include:

{lme_python-0.1.7 → lme_python-0.1.8}/Cargo.lock

@@ -1528,7 +1528,7 @@ checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lme-rs"
-version = "0.1.7"
+version = "0.1.8"
 dependencies = [
  "anyhow",
  "argmin",
@@ -2948,9 +2948,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.37"
+version = "0.23.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
+checksum = "6b92b125634d9b795e7beca796cc790df15a7fb38323bf3196fda83292d06b1f"
 dependencies = [
  "log",
  "once_cell",
@@ -2972,9 +2972,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.10"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
  "ring",
  "rustls-pki-types",

{lme_python-0.1.7 → lme_python-0.1.8}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lme-rs"
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 authors = ["Martin Huck <x4g4p3x@users.noreply.github.com>"]
 description = "Rust port of R's lme4: linear mixed-effects models with 1:1 numerical compatibility"
@@ -89,8 +89,15 @@ path = "comparisons/lmer_weighted.rs"
 name = "glmm_gaussian"
 path = "comparisons/glmm_gaussian.rs"
 
+# x86_64 (Linux, Windows, macOS x86_64 wheels via cross-compile): static Intel MKL.
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 ndarray-linalg = { version = "0.17", features = ["intel-mkl-static"] }
 
-[target.'cfg(not(target_arch = "x86_64"))'.dependencies]
+# macOS Apple Silicon: static OpenBLAS (MKL does not link on aarch64-apple-darwin;
+# Homebrew OpenBLAS pulls libgcc dylibs maturin cannot repair).
+[target.'cfg(all(target_arch = "aarch64", target_os = "macos"))'.dependencies]
+ndarray-linalg = { version = "0.17", features = ["openblas-static"] }
+
+# Other non-x86_64 (e.g. Linux aarch64 manylinux wheels): static OpenBLAS.
+[target.'cfg(all(not(target_arch = "x86_64"), not(target_os = "macos")))'.dependencies]
 ndarray-linalg = { version = "0.17", features = ["openblas-static"] }

{lme_python-0.1.7 → lme_python-0.1.8}/GUIDE.md

@@ -21,7 +21,7 @@ This guide covers the practical Rust workflow for fitting linear and generalized
 
 ```toml
 [dependencies]
-lme-rs = "0.1.7"
+lme-rs = "0.1.8"
 polars = { version = "0.46", features = ["csv"] }
 anyhow = "1"
 ```
@@ -134,6 +134,39 @@ let weights = Array1::from_vec(vec![1.0; df.height()]);
 let fit = lmer_weighted("y ~ x + (1 | group)", &df, true, Some(weights))?;
 ```
 
+### `nlmer()` for nonlinear mixed models
+
+`nlmer` fits Gaussian nonlinear mixed models with a three-part formula (response, nonlinear mean, random part):
+
+```text
+circumference ~ SSlogis(age, Asym, xmid, scal) ~ Asym|Tree
+```
+
+```rust
+use lme_rs::nlmer;
+use std::collections::HashMap;
+
+let mut start = HashMap::new();
+start.insert("Asym".to_string(), 200.0);
+start.insert("xmid".to_string(), 725.0);
+start.insert("scal".to_string(), 350.0);
+
+// ML (matches R `nlmer` default); pass `true` for REML profiling
+let fit = nlmer(
+    "circumference ~ SSlogis(age, Asym, xmid, scal) ~ Asym|Tree",
+    &df,
+    start,
+    false,
+)?;
+```
+
+Current limitations:
+
+- Only `SSlogis` is implemented as the mean function.
+- Only one random effect, on a single nonlinear parameter (the canonical Orange-tree example).
+- `predict()` is not wired for NLMM fits yet; use `fitted` / `residuals` on the training data.
+- Log-likelihood and residual variance can differ slightly from `lme4` because this release uses a Laplace / penalized Gauss–Newton path (`nAGQ = 0` style), not full adaptive quadrature.
+
 ### `glmer()` for generalized linear mixed models
 
 ```rust
@@ -169,6 +202,24 @@ Built-in family support through the public enum:
 
 At the public API level, `glmer()` currently dispatches through these built-in families and their default links.
 
+### `glmer_weighted()` for prior observation weights
+
+```rust
+use lme_rs::{family::Family, glmer_weighted};
+use ndarray::Array1;
+
+let w = Array1::from_vec(vec![1.0; df.height()]);
+let fit = glmer_weighted(
+    "y ~ period2 + period3 + period4 + (1 | herd)",
+    &df,
+    Family::Binomial,
+    1,
+    Some(w),
+)?;
+```
+
+Weights must be strictly positive and match the number of rows. For `Family::Gaussian`, fitting delegates to `lmer_weighted` with ML.
+
 ### Understanding model output
 
 The `Display` implementation intentionally mirrors the shape of R output.
@@ -297,8 +348,9 @@ Current scope:
 - Type **II** and Type **III** tables (`anova_typed` / `AnovaType`)
 - 1-DoF marginal tests for continuous predictors; joint multi-DoF Wald F-tests for categorical predictors when dummy columns are grouped in the fit
 - Multi-DoF Satterthwaite denominator df follows **`lmerTest::contestMD()`** (orthogonal contrast directions + `get_Fstat_ddf()` pooling); call `with_satterthwaite()` before `anova()` so the vcov Jacobian is available
-- Kenward–Roger multi-DoF rows pool marginal dfs with the same `get_Fstat_ddf()` rule (full `pbkrtest::KRmodcomp` per term is not implemented)
+- Kenward–Roger multi-DoF rows use `pbkrtest::KRmodcomp` / `.KR_adjust` via [`kr_modcomp`](src/kr_modcomp.rs) and `vcovAdj16` via [`kr_vcov_adj`](src/kr_vcov_adj.rs); when `vcovAdj` ≈ `vcov`, DenDF matches marginal KR pooling (pastes `cask` reference)
 - Golden regression for categorical multi-DoF ANOVA: manifest case `pastes_cask_multi_dof_reml` in [`tests/data/golden_parity_manifest.json`](tests/data/golden_parity_manifest.json) (pastes / `cask`)
+- **User-defined contrasts:** any **q × p** matrix `L` via [`LmeFit::test_contrast`](src/contrast.rs) / [`test_contrast_vs`](src/contrast.rs) (`lmerTest::contestMD` / `KRmodcomp`); helpers [`contrast_matrix`](src/contrast.rs) and [`contrast_matrix_from_names`](src/contrast.rs). Python: `fit.test_contrast(l_matrix, ddf_method=...)`.
 
 ## Model Comparison
 
@@ -328,7 +380,7 @@ For GLMMs, `lme-rs` computes the optimization target from a Laplace-approximated
 
 ### ANOVA scope
 
-Fixed-effects ANOVA supports Type **II** and Type **III** (`AnovaType`). Type II uses `lmerTest`-style contrasts (marginal for non-contained terms, Doolittle reordering for contained terms). Continuous terms use 1-DoF tests where applicable; categorical predictors use joint multi-DoF Wald rows. Arbitrary user-defined contrast matrices are not implemented.
+Fixed-effects ANOVA supports Type **II** and Type **III** (`AnovaType`). Type II uses `lmerTest`-style contrasts (marginal for non-contained terms, Doolittle reordering for contained terms). Continuous terms use 1-DoF tests where applicable; categorical predictors use joint multi-DoF Wald rows. Arbitrary **q × p** contrast matrices are supported via [`test_contrast`](src/contrast.rs).
 
 ### Kenward-Roger status
 
@@ -381,7 +433,9 @@ For concrete parity outputs, use the scripts and datasets in `comparisons/` and
 | `lm(y, x)` | fixed-effects-only linear regression |
 | `lmer(formula, data, reml)` | linear mixed model |
 | `lmer_weighted(formula, data, reml, weights)` | weighted linear mixed model |
+| `nlmer(formula, data, start, reml)` | nonlinear mixed model (`SSlogis`, one RE parameter) |
 | `glmer(formula, data, family)` | generalized linear mixed model |
+| `glmer_weighted(formula, data, family, n_agq, weights)` | GLMM with prior observation weights |
 | `anova(fit_a, fit_b)` | likelihood ratio test between nested models |
 
 ### `LmeFit` methods

{lme_python-0.1.7 → lme_python-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lme_python
-Version: 0.1.7
+Version: 0.1.8
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{lme_python-0.1.7 → lme_python-0.1.8}/README.md

@@ -11,7 +11,8 @@
 
 - `lm()` for fixed-effects-only linear models
 - `lmer()` and `lmer_weighted()` for linear mixed models
-- `glmer()` for binomial, poisson, gaussian, and gamma mixed models
+- `nlmer()` for nonlinear mixed models (`SSlogis` mean; random effect on one nonlinear parameter, e.g. Orange-tree growth)
+- `glmer()` and `glmer_weighted()` for binomial, poisson, gaussian, and gamma mixed models
 - Wilkinson formulas with nested and crossed random effects
 - Population-level and conditional prediction APIs
 - Wald confidence intervals, parametric simulation, robust standard errors, Satterthwaite degrees of freedom, and Kenward-Roger denominator degrees of freedom
@@ -64,9 +65,9 @@ For a subjective, area-by-area view of what is implemented versus still open (in
 
 - Numerical parity is the goal for the covered LMM and GLMM workflows, but the guarantee is scoped to the models and examples exercised by the repository tests and comparison fixtures.
 - `glmer()` uses a Laplace approximation. Absolute AIC, BIC, and log-likelihood values can differ from R because `lme-rs` optimizes a deviance expression that omits data-dependent constants. Coefficients and variance parameters are the quantities to compare.
-- Fixed-effects ANOVA supports **Type II** and **Type III** (`anova_typed` / `AnovaType`). Continuous fixed effects use 1-DoF tests where applicable; categorical predictors encoded as multiple dummies use **joint multi-DoF Wald F-tests**, with multi-DoF Satterthwaite denominator df following **`lmerTest::contestMD()`** (see [GUIDE.md](GUIDE.md) and [comparisons/COMPARISONS.md](comparisons/COMPARISONS.md) §4). Arbitrary user-defined contrast matrices are not covered.
+- Fixed-effects ANOVA supports **Type II** and **Type III** (`anova_typed` / `AnovaType`). Continuous fixed effects use 1-DoF tests where applicable; categorical predictors encoded as multiple dummies use **joint multi-DoF Wald F-tests**, with multi-DoF Satterthwaite denominator df following **`lmerTest::contestMD()`** (see [GUIDE.md](GUIDE.md) and [comparisons/COMPARISONS.md](comparisons/COMPARISONS.md) §4). Arbitrary user-defined **q × p** contrast matrices are supported via `test_contrast()` (Rust) / `fit.test_contrast()` (Python).
 - `with_kenward_roger()` produces denominator degrees of freedom that match R's `pbkrtest` to within the precision of numerical differentiation on the covered LMM models.
-- The Rust crate exposes a broader surface than the Python bindings. The Python package is useful, but it is not yet a full mirror of the Rust API.
+- The Python bindings mirror the Rust API (`lm`, `lm_matrix`, `lmer`, `glmer`, `nlmer`, contrasts, ANOVA, prediction, simulation) with structured result types and [`lme_python.pyi`](python/lme_python.pyi) stubs.
 - Built-in GLMM families currently use their default links through the public `glmer()` API.
 
 ## Documentation map
@@ -97,6 +98,6 @@ Each example is mirrored across Rust, R, Python, and Julia where that comparison
 
 ## Development notes
 
-Repository metadata on GitHub is synced from `Cargo.toml` by the workflow in [.github/workflows/repo-metadata.yml](.github/workflows/repo-metadata.yml). If you change the package description, homepage, keywords, or categories, the GitHub About box will be updated on the next metadata sync run.
+Repository metadata on GitHub is synced from `Cargo.toml` by [.github/workflows/repo-metadata.yml](.github/workflows/repo-metadata.yml). Preflight with `task repo-metadata`; the workflow needs a valid **`REPO_ADMIN_TOKEN`** secret (see [CONTRIBUTING.md](CONTRIBUTING.md)).
 
-To run the same checks as CI locally (format, clippy, build, tests, docs), use [`scripts/local_ci.sh`](scripts/local_ci.sh) or [`scripts/local_ci.ps1`](scripts/local_ci.ps1) (see [CHANGELOG.md](CHANGELOG.md) 0.1.6).
+Local checks mirror CI in layers: **`task preflight`** before push (lint, compile graph, `cargo audit`, metadata dry-run), **`task ci`** before a PR ([AGENTS.md](AGENTS.md) for hook details). Install `cargo-audit` once: `cargo install cargo-audit`.