rgapi 0.2.0__tar.gz → 0.2.1__tar.gz

{rgapi-0.2.0 → rgapi-0.2.1}/.github/workflows/ci.yml

@@ -12,11 +12,12 @@ jobs:
     steps:
       - uses: actions/checkout@v7
       - uses: dtolnay/rust-toolchain@stable
-      - run: cargo test
       - uses: actions/setup-python@v7
         with:
           python-version: '3.12'
+      - run: cargo test
       - run: pip install -e '.[dev]'
+      - run: cargo develop
       - run: pytest -q
 
   build:
@@ -61,7 +62,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - id: crates-auth
         uses: rust-lang/crates-io-auth-action@v1
-      - run: cargo publish
+      - run: cargo publish -p rgapi
         env:
           CARGO_REGISTRY_TOKEN: ${{ steps.crates-auth.outputs.token }}
       - uses: actions/download-artifact@v8

{rgapi-0.2.0 → rgapi-0.2.1}/Cargo.lock

@@ -171,9 +171,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "libc"
-version = "0.2.189"
+version = "0.2.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
 
 [[package]]
 name = "log"
@@ -225,9 +225,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
+checksum = "700d18fa267b73b9b521fd7e13580e2f446916f176cacee1ab63fcc8191f1655"
 dependencies = [
  "libc",
  "once_cell",
@@ -239,18 +239,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
+checksum = "7b3fc0c4d08f6bb10e71fe39dfb9e2f59c6eb6854e22ec8092f50c69a4499adb"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
+checksum = "dfc0b8e19df29aad7086cf977bb0c2a2f143e30567eb113e9cf72b62ca698330"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -258,9 +258,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
+checksum = "6100e8a4b5eba53afaa5ed078364851a0b2499c553a44c31026b929049b49dc6"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -270,9 +270,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
+checksum = "6143877a16e82b5a727b7127ff4cd86858a24a28d745d72f43e6f227c7b1bdb3"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -308,7 +308,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rgapi"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "crc32fast",
  "globset",
@@ -316,11 +316,21 @@ dependencies = [
  "grep-regex",
  "grep-searcher",
  "ignore",
- "pyo3",
  "serde",
  "serde_json",
 ]
 
+[[package]]
+name = "rgapi-py"
+version = "0.2.1"
+dependencies = [
+ "grep-matcher",
+ "grep-regex",
+ "pyo3",
+ "pyo3-build-config",
+ "rgapi",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.23"

{rgapi-0.2.0 → rgapi-0.2.1}/Cargo.toml

@@ -1,37 +1,44 @@
+[workspace]
+members = ["py"]
+
+[workspace.package]
+version = "0.2.1"
+edition = "2024"
+
+[workspace.dependencies]
+grep-matcher = ">=0.1.8"
+grep-regex = ">=0.1.14"
+
 [package]
 name = "rgapi"
-version = "0.2.0"
-edition = "2024"
+version.workspace = true
+edition.workspace = true
 rust-version = "1.91"
 license = "Apache-2.0"
 description = "Python API for ripgrep-style file walking and searching"
 repository = "https://github.com/AnswerDotAI/rgapi"
 homepage = "https://github.com/AnswerDotAI/rgapi"
 documentation = "https://github.com/AnswerDotAI/rgapi"
-readme = "README.md"
 
 [lib]
 name = "rgapi"
-crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 crc32fast = "1"
 globset = ">=0.4.18"
-grep-matcher = ">=0.1.8"
-grep-regex = ">=0.1.14"
+grep-matcher.workspace = true
+grep-regex.workspace = true
 grep-searcher = ">=0.1.16"
 ignore = ">=0.4.26"
-pyo3 = { version = ">=0.28", optional = true }
 serde = { version = "=1", features = ["derive"] }
 serde_json = "=1"
 
-[features]
-python = ["dep:pyo3"]
-extension-module = ["python", "pyo3/extension-module"]
-
 [lints.clippy]
 too_many_arguments = "allow"
 
+[profile.test]
+inherits = "release"
+
 [profile.release]
 lto = false
 codegen-units = 16
@@ -39,6 +46,9 @@ codegen-units = 16
 [profile.release.package.rgapi]
 incremental = true
 
+[profile.release.package.rgapi-py]
+incremental = true
+
 [profile.dist]
 inherits = "release"
 lto = true
@@ -48,3 +58,6 @@ strip = true
 
 [profile.dist.package.rgapi]
 incremental = false
+
+[profile.dist.package.rgapi-py]
+incremental = false

{rgapi-0.2.0 → rgapi-0.2.1}/DEV.md

@@ -8,7 +8,7 @@
 src/walk.rs       ignore/globset/grep-regex-backed path walking and filtering
 src/search.rs     grep-regex/grep-searcher-backed searching
 src/block.rs      blank-line-delimited block grouping, matching, and block context
-src/python.rs     PyO3 classes and private core functions
+py/src/lib.rs     PyO3 classes and private core functions
 python/rgapi/     public Python wrappers over `rgapi._core`, plus the `rgapi-nbrg` CLI
 tests/            pytest coverage for the Python API
 ```
@@ -18,11 +18,11 @@ The public Python API lives in `python/rgapi/__init__.py`. The extension module
 ## Commands
 
 ```bash
-maturin develop
+cargo develop
 pytest -q
 ```
 
-Python tests (`tests/`) run against the built extension. `cargo test` covers the Rust-only API, and takes no feature flags: `extension-module` stops pyo3 linking libpython, which a test binary needs. For a fast local loop use `maturin develop && pytest -q`. Run `cargo fmt --check` and `cargo check --all-features` for Rust-only edits. Run `chkstyle` after Python edits once tests pass.
+`cargo develop` and bare `cargo test` use the same Cargo profile and share the core and binding libraries. Unit tests also build a separate `cfg(test)` executable. The published `rgapi` crate has no Python dependency; the unpublished `rgapi-py` crate in `py/` builds the extension. Run `cargo fmt` after Rust edits and `chkstyle` before committing Python edits.
 
 ## Release
 
@@ -30,8 +30,8 @@ The canonical version lives in `Cargo.toml`. `pyproject.toml` gets the Python pa
 
 Release flow is: release first, then bump - `ship-release` does both.
 
-1. Run `maturin develop && pytest -q`.
-2. Confirm the release version in `Cargo.toml` (`[package].version`).
+1. Run `cargo develop && pytest -q`.
+2. Confirm the release version in `Cargo.toml` (`[workspace.package].version`).
 3. Run `ship-release`. It tags `v<version>`, pushes branch and tag (CI builds and publishes), then bumps `Cargo.toml`, refreshes the editable install, and pushes the bump without a tag.
 
 The GitHub workflow builds wheels for Python 3.10-3.13 on Linux and macOS and publishes the Rust crate, GitHub release artifacts, and PyPI package when a `v*` tag is pushed.

{rgapi-0.2.0 → rgapi-0.2.1}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore>=2.2.29
+Requires-Dist: fastws-cli>=0.0.20 ; extra == 'dev'
 Requires-Dist: fastship>=0.0.12 ; extra == 'dev'
 Requires-Dist: maturin>=1.0,<2.0 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
 Provides-Extra: dev
 License-File: LICENSE
 Summary: Python API for ripgrep-style file walking and searching
-Home-Page: https://github.com/AnswerDotAI/rgapi
 Author-email: Jeremy Howard <j@fast.ai>
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

rgapi-0.2.1/py/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rgapi-py"
+version.workspace = true
+edition.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+test = false
+
+[dependencies]
+rgapi = { path = ".." }
+grep-matcher.workspace = true
+grep-regex.workspace = true
+pyo3 = { version = ">=0.29", features = ["extension-module"] }
+
+[build-dependencies]
+pyo3-build-config = "0.29"

rgapi-0.2.1/py/build.rs

@@ -0,0 +1 @@
+fn main() { pyo3_build_config::add_extension_module_link_args(); }

rgapi-0.2.0/src/python.rs → rgapi-0.2.1/py/src/lib.rs

@@ -9,15 +9,38 @@ use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict};
 
-use crate::search::spans_for;
-use crate::walk::{find_iter_with, resolve_roots};
-use crate::{
-    FindIter, FindOptions, NbCell, NbIter, NbOptions, RgIter, RgOptions, SearchBlock, SearchLine, StreamIter, WalkOptions, block_iter as block_iter_core,
-    compile_regex, find, find_iter as find_iter_core, nb_iter as nb_iter_core, nb_search_file, rg_iter as rg_iter_core, search_path as search_path_core,
-    search_text as search_text_core,
+use rgapi::{
+    FindIter, FindOptions, NbCell, NbIter, NbOptions, RgIter, RgOptions, SearchBlock, SearchLine, StreamIter, WalkOptions as WalkOptionsCore,
+    block_iter as block_iter_core, compile_regex, find, find_iter as find_iter_core, find_iter_with, nb_iter as nb_iter_core, nb_search_file, resolve_roots,
+    rg_iter as rg_iter_core, search_path as search_path_core, search_text as search_text_core, spans_for,
 };
 use std::path::Path;
 
+struct WalkOptions(WalkOptionsCore);
+
+impl<'a, 'py> FromPyObject<'a, 'py> for WalkOptions {
+    type Error = PyErr;
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> PyResult<Self> {
+        Ok(Self(WalkOptionsCore {
+            roots: obj.get_item("roots")?.extract()?,
+            includes: obj.get_item("includes")?.extract()?,
+            excludes: obj.get_item("excludes")?.extract()?,
+            exts: obj.get_item("exts")?.extract()?,
+            path_re: obj.get_item("path_re")?.extract()?,
+            skip_path_re: obj.get_item("skip_path_re")?.extract()?,
+            skip_dirs: obj.get_item("skip_dirs")?.extract()?,
+            skip_dir_re: obj.get_item("skip_dir_re")?.extract()?,
+            hidden: obj.get_item("hidden")?.extract()?,
+            ignore: obj.get_item("ignore")?.extract()?,
+            max_depth: obj.get_item("max_depth")?.extract()?,
+            min_depth: obj.get_item("min_depth")?.extract()?,
+            max_filesize: obj.get_item("max_filesize")?.extract()?,
+            follow_links: obj.get_item("follow_links")?.extract()?,
+            same_file_system: obj.get_item("same_file_system")?.extract()?,
+        }))
+    }
+}
+
 #[pyclass(name = "SearchLine", eq, skip_from_py_object)]
 #[derive(Clone)]
 struct SearchLinePy {
@@ -193,12 +216,20 @@ fn compile_regex_py(pattern: String, case_sensitive: Option<bool>, smart_case: b
 fn compile_py(pattern: String, case_sensitive: Option<bool>, smart_case: bool) -> PyResult<RegexPy> { compile_regex_py(pattern, case_sensitive, smart_case) }
 #[pyfunction(name = "walk_base")]
 fn walk_base_py(walk: WalkOptions, canonical: bool, walk_root_links: bool) -> PyResult<PathBuf> {
-    resolve_roots(&walk, canonical, walk_root_links).map(|(_, base)| base).map_err(|e| PyValueError::new_err(e.to_string()))
+    resolve_roots(&walk.0, canonical, walk_root_links).map(|(_, base)| base).map_err(|e| PyValueError::new_err(e.to_string()))
 }
 
 #[pyfunction(name = "find")]
-fn find_py(py: Python<'_>, walk: WalkOptions, pattern: Option<String>, files: bool, dirs: bool, timeout_ms: Option<u64>, walk_root_links: bool) -> PyResult<(Vec<PathBuf>, bool)> {
-    let opts = FindOptions { walk, pattern, files, dirs, ..FindOptions::default() };
+fn find_py(
+    py: Python<'_>,
+    walk: WalkOptions,
+    pattern: Option<String>,
+    files: bool,
+    dirs: bool,
+    timeout_ms: Option<u64>,
+    walk_root_links: bool,
+) -> PyResult<(Vec<PathBuf>, bool)> {
+    let opts = FindOptions { walk: walk.0, pattern, files, dirs, ..FindOptions::default() };
     let iter = find_iter_with(&opts, walk_root_links).map_err(|e| PyValueError::new_err(e.to_string()))?;
     collect_stream_py(py, iter, |p| p, timeout_ms)
 }
@@ -235,7 +266,7 @@ fn rg_py(
     lnhash: bool,
     timeout_ms: Option<u64>,
 ) -> PyResult<(Vec<SearchLinePy>, bool)> {
-    let opts = RgOptions { walk, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
+    let opts = RgOptions { walk: walk.0, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
     let iter = rg_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     collect_stream_py(py, iter, move |l| search_line_py(l, lnhash), timeout_ms)
 }
@@ -251,7 +282,7 @@ fn block_search_py(
     after_context: usize,
     timeout_ms: Option<u64>,
 ) -> PyResult<(Vec<BlockRow>, bool)> {
-    let opts = RgOptions { walk, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
+    let opts = RgOptions { walk: walk.0, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
     let iter = block_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     collect_stream_py(py, iter, block_row, timeout_ms)
 }
@@ -265,7 +296,7 @@ fn rg_iter_py(
     after_context: usize,
     lnhash: bool,
 ) -> PyResult<RgIterPy> {
-    let opts = RgOptions { walk, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
+    let opts = RgOptions { walk: walk.0, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
     rg_iter_core(&opts).map(|inner| RgIterPy { inner, display_lnhash: lnhash }).map_err(|e| PyValueError::new_err(e.to_string()))
 }
 
@@ -281,7 +312,7 @@ impl FindIterPy {
 
 #[pyfunction(name = "find_iter")]
 fn find_iter_py(walk: WalkOptions, pattern: Option<String>, files: bool, dirs: bool) -> PyResult<FindIterPy> {
-    let opts = FindOptions { walk, pattern, files, dirs, ..FindOptions::default() };
+    let opts = FindOptions { walk: walk.0, pattern, files, dirs, ..FindOptions::default() };
     find_iter_core(&opts).map(|inner| FindIterPy { inner }).map_err(|e| PyValueError::new_err(e.to_string()))
 }
 
@@ -293,7 +324,7 @@ impl AsyncHandlePy { fn cancel(&self) { self.cancel.store(true, Ordering::Relaxe
 
 #[pyfunction(name = "find_async")]
 fn find_async_py(cb: Py<PyAny>, walk: WalkOptions, pattern: Option<String>, files: bool, dirs: bool, timeout_ms: Option<u64>) -> PyResult<AsyncHandlePy> {
-    let opts = FindOptions { walk, pattern, files, dirs, ..FindOptions::default() };
+    let opts = FindOptions { walk: walk.0, pattern, files, dirs, ..FindOptions::default() };
     let iter = find_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     let deadline = timeout_ms.map(|ms| Instant::now() + Duration::from_millis(ms));
     Ok(stream_async(cb, iter, deadline, |py, paths, timed_out| Ok((paths, timed_out).into_pyobject(py)?.into_any().unbind())))
@@ -301,7 +332,7 @@ fn find_async_py(cb: Py<PyAny>, walk: WalkOptions, pattern: Option<String>, file
 
 #[pyfunction(name = "find_iter_async")]
 fn find_iter_async_py(cb: Py<PyAny>, batch_max: usize, walk: WalkOptions, pattern: Option<String>, files: bool, dirs: bool) -> PyResult<AsyncHandlePy> {
-    let opts = FindOptions { walk, pattern, files, dirs, ..FindOptions::default() };
+    let opts = FindOptions { walk: walk.0, pattern, files, dirs, ..FindOptions::default() };
     let iter = find_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     Ok(stream_iter_async(cb, iter, batch_max, |py, paths| Ok(paths.into_pyobject(py)?.into_any().unbind())))
 }
@@ -411,7 +442,7 @@ fn rg_async_py(
     lnhash: bool,
     timeout_ms: Option<u64>,
 ) -> PyResult<AsyncHandlePy> {
-    let opts = RgOptions { walk, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
+    let opts = RgOptions { walk: walk.0, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
     let iter = rg_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     let deadline = timeout_ms.map(|ms| Instant::now() + Duration::from_millis(ms));
     Ok(stream_async(cb, iter, deadline, move |py, rows, timed_out| {
@@ -431,7 +462,7 @@ fn block_search_async_py(
     after_context: usize,
     timeout_ms: Option<u64>,
 ) -> PyResult<AsyncHandlePy> {
-    let opts = RgOptions { walk, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
+    let opts = RgOptions { walk: walk.0, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
     let iter = block_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     let deadline = timeout_ms.map(|ms| Instant::now() + Duration::from_millis(ms));
     Ok(stream_async(cb, iter, deadline, |py, rows, timed_out| {
@@ -452,7 +483,7 @@ fn rg_iter_async_py(
     after_context: usize,
     lnhash: bool,
 ) -> PyResult<AsyncHandlePy> {
-    let opts = RgOptions { walk, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
+    let opts = RgOptions { walk: walk.0, pattern, case_sensitive, smart_case, before_context, after_context, ..RgOptions::default() };
     let iter = rg_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     Ok(stream_iter_async(cb, iter, batch_max, move |py, rows| {
         let rows: Vec<SearchLinePy> = rows.into_iter().map(|l| search_line_py(l, lnhash)).collect();
@@ -462,7 +493,7 @@ fn rg_iter_async_py(
 
 #[pyfunction(name = "panic_probe")]
 fn panic_probe_py(py: Python<'_>, root: PathBuf, walk: bool) -> PyResult<()> {
-    let walk_opts = WalkOptions { roots: vec![root], ..WalkOptions::default() };
+    let walk_opts = WalkOptionsCore { roots: vec![root], ..WalkOptionsCore::default() };
     if walk {
         let opts = FindOptions { walk: walk_opts, panic_probe: true, ..FindOptions::default() };
         find(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
@@ -518,14 +549,14 @@ fn nb_search_py(
     multiline: bool,
     timeout_ms: Option<u64>,
 ) -> PyResult<(Vec<NbRow>, bool)> {
-    let opts = NbOptions { walk, pattern, case_sensitive, smart_case, cell_context, multiline };
+    let opts = NbOptions { walk: walk.0, pattern, case_sensitive, smart_case, cell_context, multiline };
     let iter = nb_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     collect_stream_py(py, iter, nb_row, timeout_ms)
 }
 
 #[pyfunction(name = "nb_iter")]
 fn nb_iter_py(walk: WalkOptions, pattern: String, case_sensitive: Option<bool>, smart_case: bool, cell_context: usize, multiline: bool) -> PyResult<NbIterPy> {
-    let opts = NbOptions { walk, pattern, case_sensitive, smart_case, cell_context, multiline };
+    let opts = NbOptions { walk: walk.0, pattern, case_sensitive, smart_case, cell_context, multiline };
     nb_iter_core(&opts).map(|inner| NbIterPy { inner }).map_err(|e| PyValueError::new_err(e.to_string()))
 }
 
@@ -540,7 +571,7 @@ fn nb_search_async_py(
     multiline: bool,
     timeout_ms: Option<u64>,
 ) -> PyResult<AsyncHandlePy> {
-    let opts = NbOptions { walk, pattern, case_sensitive, smart_case, cell_context, multiline };
+    let opts = NbOptions { walk: walk.0, pattern, case_sensitive, smart_case, cell_context, multiline };
     let iter = nb_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     let deadline = timeout_ms.map(|ms| Instant::now() + Duration::from_millis(ms));
     Ok(stream_async(cb, iter, deadline, |py, rows, timed_out| {
@@ -560,7 +591,7 @@ fn nb_iter_async_py(
     cell_context: usize,
     multiline: bool,
 ) -> PyResult<AsyncHandlePy> {
-    let opts = NbOptions { walk, pattern, case_sensitive, smart_case, cell_context, multiline };
+    let opts = NbOptions { walk: walk.0, pattern, case_sensitive, smart_case, cell_context, multiline };
     let iter = nb_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     Ok(stream_iter_async(cb, iter, batch_max, |py, rows| {
         let rows: Vec<NbRow> = rows.into_iter().map(nb_row).collect();

{rgapi-0.2.0 → rgapi-0.2.1}/pyproject.toml

@@ -17,7 +17,7 @@ classifiers = [
 dependencies = ["fastcore>=2.2.29"]
 
 [project.optional-dependencies]
-dev = ["fastship>=0.0.12", "maturin>=1.0,<2.0", "pytest"]
+dev = ["fastws-cli>=0.0.20", "fastship>=0.0.12", "maturin>=1.0,<2.0", "pytest"]
 
 [project.urls]
 Homepage = "https://github.com/AnswerDotAI/rgapi"
@@ -34,12 +34,12 @@ rgapi = "rgapi"
 rgapi-nbrg = "rgapi._cli:nbrg_cli"
 
 [tool.maturin]
-features = ["extension-module"]
+manifest-path = "py/Cargo.toml"
 python-source = "python"
 module-name = "rgapi._core"
 
 [tool.uv]
-cache-keys = [{ file = "pyproject.toml" }, { file = "src/**/*.rs" }, { file = "Cargo.toml" }, { file = ".git/fastws-cargo-key" }]
+cache-keys = [{ file = "pyproject.toml" }, { file = "Cargo.toml" }, { file = "py/Cargo.toml" }]
 
 [tool.fastship]
 branch = "main"

{rgapi-0.2.0 → rgapi-0.2.1}/src/block.rs

@@ -109,13 +109,8 @@ pub fn block_iter(opts: &RgOptions) -> Result<BlockIter, RgApiError> {
     let filters = Arc::new(PathFilters::new(&opts.walk)?);
     let matcher = compile_regex(&opts.pattern, opts.case_sensitive, opts.smart_case, false)?;
     let (before_context, after_context, max_depth) = (opts.before_context, opts.after_context, opts.walk.max_depth);
-    Ok(spawn_walk(
-        roots,
-        base,
-        &opts.walk,
-        filters,
-        Vec::new(),
-        move |dent, base, filters, tx, cancel| match block_entry(dent, base, filters, &matcher, before_context, after_context, max_depth) {
+    Ok(spawn_walk(roots, base, &opts.walk, filters, Vec::new(), move |dent, base, filters, tx, cancel| {
+        match block_entry(dent, base, filters, &matcher, before_context, after_context, max_depth) {
             Ok(blocks) => {
                 for block in blocks { if cancel.load(Ordering::Relaxed) || tx.send(Ok(block)).is_err() { return WalkState::Quit; } }
                 WalkState::Continue
@@ -124,6 +119,6 @@ pub fn block_iter(opts: &RgOptions) -> Result<BlockIter, RgApiError> {
                 let _ = tx.send(Err(err));
                 WalkState::Quit
             }
-        },
-    ))
+        }
+    }))
 }

{rgapi-0.2.0 → rgapi-0.2.1}/src/lib.rs

@@ -5,13 +5,10 @@ mod nb;
 mod search;
 mod walk;
 
-#[cfg(feature = "python")]
-mod python;
-
 pub use block::{BlockIter, SearchBlock, block_iter};
 pub use nb::{CellRefs, NbCell, NbIter, NbOptions, ancestor_indices, cell_refs, heading_level, nb_iter, nb_search, nb_search_file, section_range};
-pub use search::{MatchSpan, RgIter, RgOptions, SearchKind, SearchLine, compile_regex, rg, rg_iter, search_path, search_text};
-pub use walk::{FindIter, FindOptions, StreamIter, WalkOptions, find, find_iter};
+pub use search::{MatchSpan, RgIter, RgOptions, SearchError, SearchKind, SearchLine, compile_regex, rg, rg_iter, search_path, search_text, spans_for};
+pub use walk::{FindIter, FindOptions, StreamIter, WalkOptions, find, find_iter, find_iter_with, resolve_roots};
 
 #[derive(Debug, Clone)]
 pub struct RgApiError { msg: String }

{rgapi-0.2.0 → rgapi-0.2.1}/src/nb.rs

@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap, HashMap};
 use std::path::Path;
-use std::sync::{Arc, LazyLock};
 use std::sync::atomic::Ordering;
+use std::sync::{Arc, LazyLock};
 
 use grep_matcher::{Captures, Matcher};
 use grep_regex::RegexMatcher;
@@ -47,10 +47,8 @@ fn sigil_caps(text: &str, sigil: &str, body: &str) -> Vec<String> {
     let re = RegexMatcher::new(&format!("{sigil}`({body})`")).expect("sigil pattern compiles");
     let mut caps = re.new_captures().expect("captures allocate");
     let mut res = Vec::new();
-    re.captures_iter(text.as_bytes(), &mut caps, |c| {
-        if let Some(m) = c.get(1) { res.push(text[m.start()..m.end()].to_string()); }
-        true
-    }).expect("regex search is infallible");
+    re.captures_iter(text.as_bytes(), &mut caps, |c| { if let Some(m) = c.get(1) { res.push(text[m.start()..m.end()].to_string()); } true })
+    .expect("regex search is infallible");
     res
 }
 
@@ -85,7 +83,10 @@ pub fn cell_refs(cell: &serde_json::Value) -> CellRefs {
     let prompt = cell["metadata"]["solveit_ai"] == true;
     let mut res = CellRefs::default();
     if prompt { (res.vars, res.cmds) = (sigil_caps(&src, r"\$", "[^`]+"), sigil_caps(&src, "!", "[^`]+")); }
-    if prompt || cell["cell_type"] == "markdown" { res.tools = tool_names(&src); return res; }
+    if prompt || cell["cell_type"] == "markdown" {
+        res.tools = tool_names(&src);
+        return res;
+    }
     for o in cell["outputs"].as_array().into_iter().flatten() {
         if matches!(o["output_type"].as_str(), Some("display_data" | "execute_result")) { res.tools.extend(tool_names(&nb_text(&o["data"]["text/markdown"]))); }
     }
@@ -222,13 +223,8 @@ pub fn nb_iter(opts: &NbOptions) -> Result<NbIter, RgApiError> {
     let filters = Arc::new(PathFilters::new(&opts.walk)?);
     let matcher = compile_nb_regex(&opts.pattern, opts.case_sensitive, opts.smart_case, opts.multiline)?;
     let (cell_context, multiline, max_depth) = (opts.cell_context, opts.multiline, opts.walk.max_depth);
-    Ok(spawn_walk(
-        roots,
-        base,
-        &opts.walk,
-        filters,
-        Vec::new(),
-        move |dent, base, filters, tx, cancel| match nb_entry(dent, base, filters, &matcher, cell_context, multiline, max_depth) {
+    Ok(spawn_walk(roots, base, &opts.walk, filters, Vec::new(), move |dent, base, filters, tx, cancel| {
+        match nb_entry(dent, base, filters, &matcher, cell_context, multiline, max_depth) {
             Ok(cells) => {
                 for cell in cells { if cancel.load(Ordering::Relaxed) || tx.send(Ok(cell)).is_err() { return WalkState::Quit; } }
                 WalkState::Continue
@@ -237,8 +233,8 @@ pub fn nb_iter(opts: &NbOptions) -> Result<NbIter, RgApiError> {
                 let _ = tx.send(Err(err));
                 WalkState::Quit
             }
-        },
-    ))
+        }
+    }))
 }
 
 pub fn nb_search(opts: &NbOptions) -> Result<Vec<NbCell>, RgApiError> { nb_iter(opts)?.collect() }

{rgapi-0.2.0 → rgapi-0.2.1}/src/search.rs

@@ -97,10 +97,7 @@ fn search_entry(
 
 fn is_cancelled(cancel: &Arc<AtomicBool>) -> bool { cancel.load(Ordering::Relaxed) }
 
-fn send_search_error(tx: &SyncSender<Result<SearchLine, RgApiError>>, err: RgApiError) -> WalkState {
-    let _ = tx.send(Err(err));
-    WalkState::Quit
-}
+fn send_search_error(tx: &SyncSender<Result<SearchLine, RgApiError>>, err: RgApiError) -> WalkState { let _ = tx.send(Err(err)); WalkState::Quit }
 
 pub fn compile_regex(pattern: &str, case_sensitive: Option<bool>, smart_case: bool, multiline: bool) -> Result<RegexMatcher, RgApiError> {
     if pattern.is_empty() { return Err(RgApiError::new("pattern may not be empty")); }
@@ -146,7 +143,12 @@ fn search_path_cancelable(
     cancel: Option<Arc<AtomicBool>>,
 ) -> Result<Vec<SearchLine>, RgApiError> {
     let mut builder = SearcherBuilder::new();
-    builder.line_number(true).line_terminator(LineTerminator::crlf()).before_context(before_context).after_context(after_context).binary_detection(BinaryDetection::quit(0));
+    builder
+        .line_number(true)
+        .line_terminator(LineTerminator::crlf())
+        .before_context(before_context)
+        .after_context(after_context)
+        .binary_detection(BinaryDetection::quit(0));
     let mut searcher = builder.build();
     let mut out = Vec::new();
     let search_matcher = matcher.clone();
@@ -222,14 +224,12 @@ impl Sink for CollectSink<'_> {
         self.lines.push(SearchLine { kind, path: self.path.clone(), line_number, lnhash: format_lnhash(line_number, &line), line, matches: Vec::new() });
         Ok(!self.cancelled())
     }
-    fn binary_data(&mut self, _searcher: &grep_searcher::Searcher, _binary_byte_offset: u64) -> Result<bool, Self::Error> {
-        self.lines.clear();
-        Ok(false)
-    }
+    fn binary_data(&mut self, _searcher: &grep_searcher::Searcher, _binary_byte_offset: u64) -> Result<bool, Self::Error> { self.lines.clear(); Ok(false) }
 }
 
 #[derive(Debug)]
-pub(crate) enum SearchError { Message(String), InvalidUtf8 }
+/// A search failure, including invalid UTF-8 in matched text.
+pub enum SearchError { Message(String), InvalidUtf8 }
 impl std::fmt::Display for SearchError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self { Self::Message(msg) => write!(f, "{msg}"), Self::InvalidUtf8 => write!(f, "invalid utf-8") }
@@ -241,13 +241,11 @@ fn bytes_to_line(bytes: &[u8]) -> Result<String, SearchError> {
     let s = std::str::from_utf8(bytes).map_err(|_| SearchError::InvalidUtf8)?;
     Ok(s.trim_end_matches(['\r', '\n']).to_string())
 }
-pub(crate) fn spans_for(matcher: &RegexMatcher, bytes: &[u8]) -> Result<Vec<MatchSpan>, SearchError> {
+/// Return byte offsets for every match in a line.
+pub fn spans_for(matcher: &RegexMatcher, bytes: &[u8]) -> Result<Vec<MatchSpan>, SearchError> {
     let mut spans = Vec::new();
     matcher
-        .find_iter(bytes, |m| {
-            spans.push(MatchSpan { start: m.start(), end: m.end() });
-            true
-        })
+        .find_iter(bytes, |m| { spans.push(MatchSpan { start: m.start(), end: m.end() }); true })
         .map_err(|e| SearchError::Message(e.to_string()))?;
     Ok(spans)
 }

{rgapi-0.2.0 → rgapi-0.2.1}/src/walk.rs

@@ -13,7 +13,6 @@ use crate::RgApiError;
 
 /// Where to walk and which paths to keep. `FindOptions`, `RgOptions` and `NbOptions` each hold one.
 #[derive(Debug, Clone)]
-#[cfg_attr(feature = "python", derive(pyo3::FromPyObject), pyo3(from_item_all))]
 pub struct WalkOptions {
     /// Directories or files to walk. Result paths are relative to the base of the roots. Filters match the same relative paths.
     /// A directory root is its own base. A file root, or a link root that is not followed, has its parent as its base.
@@ -80,38 +79,29 @@ pub fn find_iter(opts: &FindOptions) -> Result<FindIter, RgApiError> { find_iter
 
 /// Like `find_iter`, except that `walk_root_links` walks a root link to a directory instead of returning the link.
 /// Paths under that root are reported under the link.
-pub(crate) fn find_iter_with(opts: &FindOptions, walk_root_links: bool) -> Result<FindIter, RgApiError> {
+pub fn find_iter_with(opts: &FindOptions, walk_root_links: bool) -> Result<FindIter, RgApiError> {
     let walk = &opts.walk;
     let (roots, base) = resolve_roots(walk, false, walk_root_links)?;
     let filters = Arc::new(PathFilters::new(walk)?);
     let pattern = opts.pattern.as_deref().map(build_fd_re).transpose()?;
     // The walker follows every root it is given. A link root returned as itself must not reach it.
     let (links, roots): (Vec<_>, Vec<_>) = roots.into_iter().partition(|r| r.is_symlink() && !walk.follow_links && !(walk_root_links && r.is_dir()));
-    let ready = if walk.min_depth.unwrap_or(0) > 0 { Vec::new() } else {
-        links.iter().map(|r| relative_path(&base, r)).filter(|rel| find_matches(rel, &filters, pattern.as_ref())).map(Path::to_path_buf).collect()
-    };
+    let ready = if walk.min_depth.unwrap_or(0) > 0 { Vec::new() } else { links.iter().map(|r| relative_path(&base, r)).filter(|rel| find_matches(rel, &filters, pattern.as_ref())).map(Path::to_path_buf).collect() };
     let (files, dirs, special_files, panic_probe, max_depth) = (opts.files, opts.dirs, opts.special_files, opts.panic_probe, walk.max_depth);
-    Ok(spawn_walk(
-        roots,
-        base,
-        walk,
-        filters,
-        ready,
-        move |dent, base, filters, tx, cancel| {
-            if panic_probe { panic!("rgapi: deliberate panic for tests (panic_probe)"); }
-            match find_entry(dent, base, filters, pattern.as_ref(), files, dirs, special_files, max_depth) {
-                Ok(Some(path)) => {
-                    if cancel.load(Ordering::Relaxed) || tx.send(Ok(path)).is_err() { return WalkState::Quit; }
-                    WalkState::Continue
-                }
-                Ok(None) => WalkState::Continue,
-                Err(err) => {
-                    let _ = tx.send(Err(err));
-                    WalkState::Quit
-                }
+    Ok(spawn_walk(roots, base, walk, filters, ready, move |dent, base, filters, tx, cancel| {
+        if panic_probe { panic!("rgapi: deliberate panic for tests (panic_probe)"); }
+        match find_entry(dent, base, filters, pattern.as_ref(), files, dirs, special_files, max_depth) {
+            Ok(Some(path)) => {
+                if cancel.load(Ordering::Relaxed) || tx.send(Ok(path)).is_err() { return WalkState::Quit; }
+                WalkState::Continue
+            }
+            Ok(None) => WalkState::Continue,
+            Err(err) => {
+                let _ = tx.send(Err(err));
+                WalkState::Quit
             }
-        },
-    ))
+        }
+    }))
 }
 
 pub struct StreamIter<T> { rx: mpsc::Receiver<Result<T, RgApiError>>, cancel: Arc<AtomicBool>, worker: Option<std::thread::JoinHandle<()>> }
@@ -211,7 +201,9 @@ where
                 let (tx, base, filters, cancel, entry, seen) = (tx.clone(), base.clone(), filters.clone(), worker_cancel.clone(), entry.clone(), seen.clone());
                 Box::new(move |dent| {
                     if cancel.load(Ordering::Relaxed) { return WalkState::Quit; }
-                    if let (Some(seen), Ok(d)) = (&seen, &dent) && !seen.lock().unwrap().insert(d.path().to_path_buf()) { return WalkState::Continue; }
+                    if let (Some(seen), Ok(d)) = (&seen, &dent)
+                        && !seen.lock().unwrap().insert(d.path().to_path_buf())
+                    { return WalkState::Continue; }
                     catch_unwind(AssertUnwindSafe(|| entry(dent, &base, &filters, &tx, &cancel))).unwrap_or_else(|_| {
                         let _ = tx.send(Err(RgApiError::new("internal error during search (this is a bug, please report it)")));
                         WalkState::Quit
@@ -263,9 +255,7 @@ fn dangling_link(err: &ignore::Error) -> Option<&Path> {
 }
 
 fn find_matches(path: &Path, filters: &PathFilters, pattern: Option<&RegexMatcher>) -> bool {
-    if let Some(pattern) = pattern {
-        if !re_match(pattern, &path.file_name().unwrap_or_default().to_string_lossy()) { return false; }
-    }
+    if let Some(pattern) = pattern { if !re_match(pattern, &path.file_name().unwrap_or_default().to_string_lossy()) { return false; } }
     filters.path_allowed(path)
 }
 
@@ -288,14 +278,19 @@ fn normalize_root(path: &Path) -> Result<PathBuf, RgApiError> {
 }
 
 /// Return the distinct roots and their base. Each root is made absolute. With `canonical`, each root is also canonicalized.
-pub(crate) fn resolve_roots(walk: &WalkOptions, canonical: bool, walk_root_links: bool) -> Result<(Vec<PathBuf>, PathBuf), RgApiError> {
+pub fn resolve_roots(walk: &WalkOptions, canonical: bool, walk_root_links: bool) -> Result<(Vec<PathBuf>, PathBuf), RgApiError> {
     let mut roots = Vec::new();
     for root in &walk.roots {
-        let root = if canonical { normalize_root(root)? } else { let r = std::path::absolute(root)?; r.symlink_metadata()?; r };
+        let root = if canonical { normalize_root(root)? } else {
+            let r = std::path::absolute(root)?;
+            r.symlink_metadata()?;
+            r
+        };
         if !roots.contains(&root) { roots.push(root); }
     }
     let follow = walk.follow_links || walk_root_links;
-    let mut bases = roots.iter().map(|r| if (follow || !r.is_symlink()) && r.is_dir() { r.clone() } else { r.parent().map_or_else(|| r.clone(), Path::to_path_buf) });
+    let mut bases =
+        roots.iter().map(|r| if (follow || !r.is_symlink()) && r.is_dir() { r.clone() } else { r.parent().map_or_else(|| r.clone(), Path::to_path_buf) });
     let mut base = bases.next().unwrap_or_default();
     for b in bases { while !b.starts_with(&base) && base.pop() {} }
     Ok((roots, base))
@@ -416,8 +411,12 @@ mod tests {
 
     #[test]
     fn globs_match_names_or_root_relative_components() {
-        for (glob, yes, no) in [("*.py", "src/deep/app.py", "src/app.rs"), ("src/*", "src/app.py", "src/deep/app.py"),
-            ("src/**", "src/deep/app.py", "other/src/app.py"), ("tests", "src/tests", "src/tests/app.py")] {
+        for (glob, yes, no) in [
+            ("*.py", "src/deep/app.py", "src/app.rs"),
+            ("src/*", "src/app.py", "src/deep/app.py"),
+            ("src/**", "src/deep/app.py", "other/src/app.py"),
+            ("tests", "src/tests", "src/tests/app.py"),
+        ] {
             let globs = build_globs(&[glob.into()]).unwrap().unwrap();
             assert!(globs.is_match(yes), "{glob}: {yes}");
             assert!(!globs.is_match(no), "{glob}: {no}");
@@ -428,10 +427,7 @@ mod tests {
         let (tx, rx) = mpsc::channel();
         let cancel = Arc::new(AtomicBool::new(false));
         let worker = std::thread::spawn(move || {
-            for i in items {
-                std::thread::sleep(std::time::Duration::from_millis(delay_ms));
-                if tx.send(Ok(i)).is_err() { return; }
-            }
+            for i in items { std::thread::sleep(std::time::Duration::from_millis(delay_ms)); if tx.send(Ok(i)).is_err() { return; } }
         });
         StreamIter { rx, cancel, worker: Some(worker) }
     }