seqpro 0.19.0__tar.gz → 0.20.0__tar.gz

{seqpro-0.19.0 → seqpro-0.20.0}/.github/workflows/publish.yaml

@@ -9,7 +9,9 @@
 # conditions below. Re-apply the workflow_call inputs (`dry_run`), delete
 # the `on.workflow_run` block, remove all `if: ${{ github.event_name ... }}`
 # guards, and wrap the `uv publish` step with the dry_run gate before
-# committing.
+# committing. Also re-add the hand-written `crates-io` job at the bottom
+# (maturin does not generate it) — it publishes the pyo3-free seqpro-core
+# crate to crates.io on a version bump.
 name: Publish
 
 on:
@@ -268,3 +270,47 @@ jobs:
             echo
             ls -1 wheels-*/* | sed 's/^/- /'
           } >> "$GITHUB_STEP_SUMMARY"
+
+  # Publish the pyo3-free seqpro-core crate to crates.io. Bump-detected and
+  # idempotent: it reads the version from crates/seqpro-core/Cargo.toml and
+  # publishes only when that version is not already on crates.io, so an
+  # unchanged version is a no-op (success), and bumping the crate's version is
+  # what triggers a release. Independent of the Python wheel/PyPI publish above.
+  crates-io:
+    name: Publish seqpro-core to crates.io
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ inputs.tag }}
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+      - name: Detect seqpro-core version and whether it is already published
+        id: ver
+        run: |
+          version=$(grep -m1 '^version' crates/seqpro-core/Cargo.toml \
+            | sed -E 's/version *= *"([^"]+)".*/\1/')
+          if [ -z "$version" ]; then
+            echo "::error::could not read seqpro-core version from crates/seqpro-core/Cargo.toml"
+            exit 1
+          fi
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          # crates.io requires a descriptive User-Agent or it returns 403.
+          code=$(curl -s -o /dev/null -w '%{http_code}' \
+            -H 'User-Agent: seqpro-release-pipeline (https://github.com/ML4GLand/SeqPro)' \
+            "https://crates.io/api/v1/crates/seqpro-core/$version")
+          if [ "$code" = "200" ]; then
+            echo "published=true" >> "$GITHUB_OUTPUT"
+            echo "seqpro-core $version is already on crates.io — no bump detected, skipping." >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "published=false" >> "$GITHUB_OUTPUT"
+            echo "seqpro-core $version not found on crates.io (HTTP $code) — will publish." >> "$GITHUB_STEP_SUMMARY"
+          fi
+      - name: Dry-run publish
+        if: inputs.dry_run == true && steps.ver.outputs.published == 'false'
+        run: cargo publish -p seqpro-core --dry-run
+      - name: Publish to crates.io
+        if: inputs.dry_run == false && steps.ver.outputs.published == 'false'
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_IO }}
+        run: cargo publish -p seqpro-core

{seqpro-0.19.0 → seqpro-0.20.0}/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.20.0 (2026-06-25)
+
+### Feat
+
+- **rag**: to_numpy(validate=False) skips the uniformity scan
+- **rag**: contiguous-slice fast path for record R=2 getitem
+- **rag**: contiguous-slice fast path for record R=1 getitem
+- **rag**: contiguous-slice fast path for opaque-string getitem
+- **rag**: contiguous-slice fast path for R=2 getitem
+- **rag**: contiguous-slice fast path for R=1 getitem
+
+### Fix
+
+- **rag**: preserve middle fixed dim in record R=2 slice shape-tail
+
+### Perf
+
+- **rust**: release the GIL during PyO3 kernel compute
+- **rag**: lean from_offsets — elide ascontiguousarray, gate size-check behind validate
+
+## 0.19.1 (2026-06-23)
+
 ## 0.19.0 (2026-06-23)
 
 ### Feat

{seqpro-0.19.0 → seqpro-0.20.0}/CLAUDE.md

@@ -60,7 +60,7 @@ Most functions require callers to specify `length_axis` (which axis is sequence
 
 ### Rust extension (`src/`)
 
-Only `kshuffle.rs` is compiled. It's exposed as `seqpro._k_shuffle` (called by `_modifiers.k_shuffle`). The Rust layer expects a contiguous `uint8` ndarray with the last dimension as sequence length.
+Several modules are compiled and registered in the `seqpro` PyO3 module (`lib.rs`): `kshuffle.rs` (k-mer shuffle, `_k_shuffle`, called by `_modifiers.k_shuffle`), `translate.rs` (codon translation, the `_translate_*` functions), and `ragged.rs` (re-exports `seqpro-core::ragged` for the `_ragged_*` functions). `kmer_encode.rs` provides a rolling k-mer integer encoder used internally. Kernels expect contiguous arrays (e.g. k-shuffle takes a `uint8` ndarray with the last dimension as sequence length) and release the GIL via `py.detach()` during compute.
 
 ### Ragged arrays (`rag/`)
 
@@ -74,6 +74,11 @@ Only `kshuffle.rs` is compiled. It's exposed as `seqpro._k_shuffle` (called by `
 - Conventional commits are enforced — use `feat:`, `fix:`, `ci:`, `bump:`, `refactor:`, `docs:`, etc. prefixes.
 - **Validation is opt-in and front-loaded.** Add fast-fail/input validation via a `validate=` flag (or equivalent single opt-in), not per-feature `error` modes. There must be one obvious way to ask "is this input clean?" — don't duplicate the check across parameters.
 - **No naive NumPy in hot paths.** Never use raw Python loops or naive NumPy (e.g. per-segment `np.concatenate`, Python `for` over sequences) where a Numba kernel is faster and leaner — unless the NumPy version is *verifiably* comparable in time and memory. When Numba is a poor fit (graph algorithms like k-shuffle), use the Rust/PyO3 extension (`src/`).
+- **PyO3 perf tips for `src/` boundary code** (per the [PyO3 performance guide](https://github.com/PyO3/pyo3/blob/main/guide/src/performance.md)). When writing or editing a `#[pyfunction]`:
+  - **Detach the interpreter during compute.** Any kernel doing real work (>~1ms, especially rayon-parallel ones) must run inside `py.detach(|| ...)`. Pattern: take slices/views (`as_slice`/`as_array`) and do all Python-touching work *while attached*, run the compute in `detach` capturing only `Ungil` slices/views (never a `PyReadonlyArray`/`Bound`/`Py`), then `into_pyarray(py)` *after* re-attaching. Add a `py: Python` param if the function lacks one.
+  - Use the existing `py` token / `Bound::py()` — never `Python::attach` when a token is already in scope.
+  - Prefer `cast::<T>()` over `extract::<T>()` for *native* Python types (`PyList`/`PyTuple`/etc.). Does not apply to numpy `PyReadonlyArray` extraction.
+  - Pass Rust tuples (not `Bound<PyTuple>`) when calling back into Python, to hit the faster `vectorcall` path.
 
 ## Skills
 

{seqpro-0.19.0 → seqpro-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqpro
-Version: 0.19.0
+Version: 0.20.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

seqpro-0.20.0/crates/seqpro-core/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "seqpro-core"
+version = "0.1.0"
+edition = "2021"
+description = "pyo3-free Rust kernels for seqpro's ragged (offsets+data) sequence arrays."
+license = "MIT"
+repository = "https://github.com/ML4GLand/SeqPro"
+readme = false
+keywords = ["bioinformatics", "genomics", "ragged", "sequences"]
+categories = ["science", "data-structures"]
+
+[lib]
+name = "seqpro_core"
+
+[dependencies]
+ndarray = { version = "0.17", features = ["rayon"] }
+rayon = "1.11.0"
+
+[dev-dependencies]
+proptest = "1.4"