rgapi 0.1.0__tar.gz → 0.1.1__tar.gz

{rgapi-0.1.0 → rgapi-0.1.1}/.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - run: cargo test
 
   build:
@@ -21,7 +21,7 @@ jobs:
         python: ['3.10', '3.11', '3.12', '3.13']
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
       - uses: actions/setup-python@v5
         with:
@@ -44,7 +44,7 @@ jobs:
       id-token: write
       contents: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: PyO3/maturin-action@v1
         with:
           command: sdist

{rgapi-0.1.0 → rgapi-0.1.1}/Cargo.lock

@@ -306,7 +306,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rgapi"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "globset",
  "grep-matcher",

{rgapi-0.1.0 → rgapi-0.1.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rgapi"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Python API for ripgrep-style file walking and searching"

{rgapi-0.1.0 → rgapi-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Summary: Python API for ripgrep-style file walking and searching
@@ -77,6 +77,8 @@ matches      list of (start, end) byte offsets for match rows
 
 Search is case-sensitive by default, matching `rg`. Use `smart_case=True` for `rg --smart-case` behavior, or `case_sensitive=False` to force case-insensitive matching.
 
+`rg` and `rg_iter` check Python signals while waiting for search results, so notebook interrupts and `KeyboardInterrupt` cancel traversal cooperatively. Cancellation is prompt between files and while results are streaming; a single huge file that produces no callbacks may continue until that file scan returns.
+
 ## Benchmarks
 
 `tools/bench.py` compares the `rg` CLI with in-process `rgapi`. Run it against a release build. One run on this machine, using best time from seven repeats:

{rgapi-0.1.0 → rgapi-0.1.1}/README.md

@@ -62,6 +62,8 @@ matches      list of (start, end) byte offsets for match rows
 
 Search is case-sensitive by default, matching `rg`. Use `smart_case=True` for `rg --smart-case` behavior, or `case_sensitive=False` to force case-insensitive matching.
 
+`rg` and `rg_iter` check Python signals while waiting for search results, so notebook interrupts and `KeyboardInterrupt` cancel traversal cooperatively. Cancellation is prompt between files and while results are streaming; a single huge file that produces no callbacks may continue until that file scan returns.
+
 ## Benchmarks
 
 `tools/bench.py` compares the `rg` CLI with in-process `rgapi`. Run it against a release build. One run on this machine, using best time from seven repeats:

{rgapi-0.1.0 → rgapi-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rgapi"
-version = "0.1.0"
+version = "0.1.1"
 description = "Python API for ripgrep-style file walking and searching"
 license = {text = "MIT OR Apache-2.0"}
 requires-python = ">=3.10"

rgapi-0.1.1/python/rgapi/__init__.py

@@ -0,0 +1,208 @@
+from . import _core
+
+Regex = _core.Regex
+SearchLine = _core.SearchLine
+RgIter = _core.RgIter
+def compile(
+    pattern, # Regex pattern to compile
+    case_sensitive=None, # True/False forces case; None allows `smart_case`
+    smart_case=False # Match `rg --smart-case` behavior
+):
+    "Compile a regex matcher for `search_text`, `search_path`, and direct matching."
+    return _core.compile(pattern, case_sensitive=case_sensitive, smart_case=smart_case)
+
+class SearchResults(list):
+    "List of `SearchLine` rows with rg-style text display."
+    def __str__(self): return "\n".join(map(str, self))
+    def _repr_pretty_(self, p, cycle): p.text("..." if cycle else str(self))
+
+
+def _listify(value):
+    if value is None: return []
+    if isinstance(value, str): return [value]
+    return list(value)
+
+
+def _filters(glob=None, include=None, exclude=None, ext=None):
+    includes = _listify(include) + _listify(glob)
+    for suffix in _listify(ext):
+        suffix = str(suffix)
+        if suffix.startswith("."): suffix = suffix[1:]
+        includes.append(f"*.{suffix}")
+    return includes, _listify(exclude)
+
+
+def _context(context, before_context, after_context):
+    if context: return context, context
+    return before_context, after_context
+
+
+def walk(
+    root=".", # Directory to walk
+    hidden=False, # Include hidden files and directories
+    ignore=True, # Respect `.gitignore` and other ignore files
+    max_depth=None, # Maximum directory depth to descend
+    min_depth=None, # Minimum depth for returned paths
+    max_filesize=None, # Skip files larger than this many bytes
+    follow_links=False, # Follow symbolic links while walking
+    same_file_system=False, # Do not cross filesystem boundaries
+    path_re=None, # Regex that returned relative paths must match
+    skip_path_re=None, # Regex for relative paths to skip
+    skip_dir=None, # Directory glob or globs to prune
+    skip_dir_re=None, # Directory regex used to prune traversal
+    files=True, # Include files in results
+    dirs=False # Include directories in results
+):
+    "Walk a directory and return relative file and/or directory paths."
+    return _core.walk(root, hidden, ignore, max_depth, min_depth, max_filesize, follow_links,
+        same_file_system, path_re, skip_path_re, _listify(skip_dir), skip_dir_re, files, dirs)
+
+
+def fd(
+    root=".", # Directory to walk
+    pattern=None, # Substring that relative paths must contain
+    glob=None, # Include glob or globs; alias for `include`
+    include=None, # Include glob or globs, e.g. `*.py`
+    exclude=None, # Exclude glob or globs, e.g. `test_*.py`
+    ext=None, # Extension or extensions to include, without needing `*.`
+    hidden=False, # Include hidden files and directories
+    ignore=True, # Respect `.gitignore` and other ignore files
+    max_depth=None, # Maximum directory depth to descend
+    min_depth=None, # Minimum depth for returned paths
+    max_filesize=None, # Skip files larger than this many bytes
+    follow_links=False, # Follow symbolic links while walking
+    same_file_system=False, # Do not cross filesystem boundaries
+    path_re=None, # Regex that returned relative paths must match
+    skip_path_re=None, # Regex for relative paths to skip
+    skip_dir=None, # Directory glob or globs to prune
+    skip_dir_re=None, # Directory regex used to prune traversal
+    files=True, # Include files in results
+    dirs=False # Include directories in results
+):
+    "Find paths with fd-style filters and gitignore support."
+    include, exclude = _filters(glob, include, exclude, ext)
+    return _core.find(root, pattern, include, exclude, hidden, ignore, max_depth, min_depth, max_filesize,
+        follow_links, same_file_system, path_re, skip_path_re, _listify(skip_dir), skip_dir_re, files, dirs)
+
+
+def _rg_args(pattern, root, glob, include, exclude, ext, hidden, ignore, max_depth, min_depth, max_filesize,
+    follow_links, same_file_system, path_re, skip_path_re, skip_dir, skip_dir_re, case_sensitive, smart_case,
+    before_context, after_context, context):
+    include, exclude = _filters(glob, include, exclude, ext)
+    before_context, after_context = _context(context, before_context, after_context)
+    return (pattern, root, include, exclude, hidden, ignore, max_depth, min_depth, max_filesize, follow_links, same_file_system,
+        path_re, skip_path_re, _listify(skip_dir), skip_dir_re, case_sensitive, smart_case, before_context, after_context)
+
+
+def rg(
+    pattern, # Regex pattern to search for
+    root=".", # Directory to search
+    glob=None, # Include glob or globs; alias for `include`
+    include=None, # Include glob or globs, e.g. `*.py`
+    exclude=None, # Exclude glob or globs, e.g. `test_*.py`
+    ext=None, # Extension or extensions to include, without needing `*.`
+    hidden=False, # Include hidden files and directories
+    ignore=True, # Respect `.gitignore` and other ignore files
+    max_depth=None, # Maximum directory depth to descend
+    min_depth=None, # Minimum depth for returned/searched files
+    max_filesize=None, # Skip files larger than this many bytes
+    follow_links=False, # Follow symbolic links while walking
+    same_file_system=False, # Do not cross filesystem boundaries
+    path_re=None, # Regex that searched relative paths must match
+    skip_path_re=None, # Regex for relative paths to skip
+    skip_dir=None, # Directory glob or globs to prune
+    skip_dir_re=None, # Directory regex used to prune traversal
+    case_sensitive=None, # True/False forces case; None allows `smart_case`
+    smart_case=False, # Match `rg --smart-case` behavior
+    before_context=0, # Lines of context before each match, like `rg -B`
+    after_context=0, # Lines of context after each match, like `rg -A`
+    context=0, # Sets both before and after context, like `rg -C`
+    paths=False, # Return unique matched paths instead of rows
+    count=False # Return total match span count instead of rows
+):
+    "Search files and return `SearchResults`, matched paths, or a count."
+    assert not (paths and count), "paths and count are mutually exclusive"
+    args = _rg_args(pattern, root, glob, include, exclude, ext, hidden, ignore, max_depth, min_depth, max_filesize,
+        follow_links, same_file_system, path_re, skip_path_re, skip_dir, skip_dir_re, case_sensitive, smart_case,
+        before_context, after_context, context)
+    if paths:
+        seen, res = set(), []
+        for row in _core.rg_iter(*args):
+            if row.kind != "match" or row.path in seen: continue
+            seen.add(row.path)
+            res.append(row.path)
+        return res
+    if count: return sum(len(row.matches) for row in _core.rg_iter(*args) if row.kind == "match")
+    return SearchResults(_core.rg(*args))
+
+
+def rg_iter(
+    pattern, # Regex pattern to search for
+    root=".", # Directory to search
+    glob=None, # Include glob or globs; alias for `include`
+    include=None, # Include glob or globs, e.g. `*.py`
+    exclude=None, # Exclude glob or globs, e.g. `test_*.py`
+    ext=None, # Extension or extensions to include, without needing `*.`
+    hidden=False, # Include hidden files and directories
+    ignore=True, # Respect `.gitignore` and other ignore files
+    max_depth=None, # Maximum directory depth to descend
+    min_depth=None, # Minimum depth for returned/searched files
+    max_filesize=None, # Skip files larger than this many bytes
+    follow_links=False, # Follow symbolic links while walking
+    same_file_system=False, # Do not cross filesystem boundaries
+    path_re=None, # Regex that searched relative paths must match
+    skip_path_re=None, # Regex for relative paths to skip
+    skip_dir=None, # Directory glob or globs to prune
+    skip_dir_re=None, # Directory regex used to prune traversal
+    case_sensitive=None, # True/False forces case; None allows `smart_case`
+    smart_case=False, # Match `rg --smart-case` behavior
+    before_context=0, # Lines of context before each match, like `rg -B`
+    after_context=0, # Lines of context after each match, like `rg -A`
+    context=0 # Sets both before and after context, like `rg -C`
+):
+    "Search files lazily, yielding `SearchLine` rows."
+    args = _rg_args(pattern, root, glob, include, exclude, ext, hidden, ignore, max_depth, min_depth, max_filesize,
+        follow_links, same_file_system, path_re, skip_path_re, skip_dir, skip_dir_re, case_sensitive, smart_case,
+        before_context, after_context, context)
+    return _core.rg_iter(*args)
+
+
+def search_text(
+    matcher, # Compiled `Regex` from `compile()`
+    text, # Text to search
+    path="<text>", # Path label stored in results
+    before_context=0, # Lines of context before each match
+    after_context=0, # Lines of context after each match
+    context=0 # Sets both before and after context, like `rg -C`
+):
+    "Search an in-memory string with a compiled matcher."
+    before_context, after_context = _context(context, before_context, after_context)
+    return SearchResults(_core.search_text(matcher, text, path, before_context, after_context))
+
+
+def search_path(
+    matcher, # Compiled `Regex` from `compile()`
+    path, # File path to search
+    display_path=None, # Path stored in results; defaults to `path`
+    before_context=0, # Lines of context before each match
+    after_context=0, # Lines of context after each match
+    context=0 # Sets both before and after context, like `rg -C`
+):
+    "Search one file with a compiled matcher."
+    before_context, after_context = _context(context, before_context, after_context)
+    return SearchResults(_core.search_path(matcher, path, display_path, before_context, after_context))
+
+
+__all__ = [
+    "Regex",
+    "RgIter",
+    "SearchLine",
+    "SearchResults",
+    "compile",
+    "fd",
+    "rg",
+    "rg_iter",
+    "search_path",
+    "search_text",
+    "walk",
+]

{rgapi-0.1.0 → rgapi-0.1.1}/src/python.rs

@@ -1,5 +1,7 @@
 use grep_matcher::Matcher;
 use std::path::PathBuf;
+use std::sync::mpsc::RecvTimeoutError;
+use std::time::Duration;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
@@ -7,7 +9,7 @@ use pyo3::types::{PyAny, PyDict};
 
 use crate::search::spans_for;
 use crate::{
-    compile_regex, find, rg, rg_iter as rg_iter_core, search_path as search_path_core,
+    compile_regex, find, rg_iter as rg_iter_core, search_path as search_path_core,
     search_text as search_text_core, FindOptions, RgIter, RgOptions, SearchLine,
 };
 
@@ -70,12 +72,11 @@ impl RgIterPy {
     fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
         slf
     }
-    fn __next__(mut slf: PyRefMut<'_, Self>) -> PyResult<Option<SearchLinePy>> {
-        match slf.inner.next() {
-            Some(Ok(line)) => Ok(Some(SearchLinePy::from(line))),
-            Some(Err(err)) => Err(PyValueError::new_err(err.to_string())),
-            None => Ok(None),
-        }
+    fn __next__(mut slf: PyRefMut<'_, Self>, py: Python<'_>) -> PyResult<Option<SearchLinePy>> {
+        next_rg_line_py(py, &mut slf.inner)
+    }
+    fn cancel(&self) {
+        self.inner.cancel();
     }
     fn __repr__(&self) -> String {
         "RgIter(SearchLine stream)".to_string()
@@ -93,6 +94,35 @@ impl RgIterPy {
         Ok(())
     }
 }
+fn check_signals_or_cancel(py: Python<'_>, iter: &RgIter) -> PyResult<()> {
+    if let Err(err) = py.check_signals() {
+        iter.cancel();
+        return Err(err);
+    }
+    Ok(())
+}
+
+fn next_rg_line_py(py: Python<'_>, iter: &mut RgIter) -> PyResult<Option<SearchLinePy>> {
+    loop {
+        check_signals_or_cancel(py, iter)?;
+        let res = py.allow_threads(|| iter.next_timeout(Duration::from_millis(50)));
+        check_signals_or_cancel(py, iter)?;
+        match res {
+            Ok(Ok(line)) => return Ok(Some(SearchLinePy::from(line))),
+            Ok(Err(err)) => return Err(PyValueError::new_err(err.to_string())),
+            Err(RecvTimeoutError::Disconnected) => return Ok(None),
+            Err(RecvTimeoutError::Timeout) => continue,
+        }
+    }
+}
+
+fn collect_rg_py(py: Python<'_>, mut iter: RgIter) -> PyResult<Vec<SearchLinePy>> {
+    let mut res = Vec::new();
+    while let Some(line) = next_rg_line_py(py, &mut iter)? {
+        res.push(line);
+    }
+    Ok(res)
+}
 #[pyclass(name = "Regex")]
 #[derive(Clone)]
 struct RegexPy {
@@ -294,6 +324,7 @@ fn search_path_py(
 #[pyfunction(name = "rg")]
 #[pyo3(signature = (pattern, root=".", include=None, exclude=None, hidden=false, ignore=true, max_depth=None, min_depth=None, max_filesize=None, follow_links=false, same_file_system=false, path_re=None, skip_path_re=None, skip_dir=None, skip_dir_re=None, case_sensitive=None, smart_case=false, before_context=0, after_context=0))]
 fn rg_py(
+    py: Python<'_>,
     pattern: String,
     root: &str,
     include: Option<Vec<String>>,
@@ -335,9 +366,8 @@ fn rg_py(
         before_context,
         after_context,
     };
-    rg(&opts)
-        .map(|lines| lines.into_iter().map(SearchLinePy::from).collect())
-        .map_err(|e| PyValueError::new_err(e.to_string()))
+    let iter = rg_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
+    collect_rg_py(py, iter)
 }
 #[pyfunction(name = "rg_iter")]
 #[pyo3(signature = (pattern, root=".", include=None, exclude=None, hidden=false, ignore=true, max_depth=None, min_depth=None, max_filesize=None, follow_links=false, same_file_system=false, path_re=None, skip_path_re=None, skip_dir=None, skip_dir_re=None, case_sensitive=None, smart_case=false, before_context=0, after_context=0))]

{rgapi-0.1.0 → rgapi-0.1.1}/src/search.rs

@@ -1,6 +1,10 @@
 use std::path::{Path, PathBuf};
-use std::sync::mpsc::{self, Receiver, Sender};
-use std::sync::Arc;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    mpsc::{self, Receiver, RecvTimeoutError, Sender},
+    Arc,
+};
+use std::time::Duration;
 
 use grep_matcher::Matcher;
 use grep_regex::{RegexMatcher, RegexMatcherBuilder};
@@ -109,25 +113,49 @@ pub fn rg_iter(opts: &RgOptions) -> Result<RgIter, RgApiError> {
     )?);
     let matcher = compile_regex(&opts.pattern, opts.case_sensitive, opts.smart_case)?;
     let opts = opts.clone();
+    let cancel = Arc::new(AtomicBool::new(false));
+    let worker_cancel = cancel.clone();
     let (tx, rx) = mpsc::channel();
-    let worker = std::thread::spawn(move || run_parallel_search(root, opts, filters, matcher, tx));
+    let worker = std::thread::spawn(move || {
+        run_parallel_search(root, opts, filters, matcher, tx, worker_cancel)
+    });
     Ok(RgIter {
         rx,
+        cancel,
         _worker: worker,
     })
 }
 
 pub struct RgIter {
     rx: Receiver<Result<SearchLine, RgApiError>>,
+    cancel: Arc<AtomicBool>,
     _worker: std::thread::JoinHandle<()>,
 }
 
+impl RgIter {
+    pub fn cancel(&self) {
+        self.cancel.store(true, Ordering::Relaxed);
+    }
+
+    pub fn next_timeout(
+        &mut self,
+        timeout: Duration,
+    ) -> Result<Result<SearchLine, RgApiError>, RecvTimeoutError> {
+        self.rx.recv_timeout(timeout)
+    }
+}
+
 impl Iterator for RgIter {
     type Item = Result<SearchLine, RgApiError>;
     fn next(&mut self) -> Option<Self::Item> {
         self.rx.recv().ok()
     }
 }
+impl Drop for RgIter {
+    fn drop(&mut self) {
+        self.cancel();
+    }
+}
 
 fn run_parallel_search(
     root: PathBuf,
@@ -135,6 +163,7 @@ fn run_parallel_search(
     filters: Arc<PathFilters>,
     matcher: RegexMatcher,
     tx: Sender<Result<SearchLine, RgApiError>>,
+    cancel: Arc<AtomicBool>,
 ) {
     let mut walker = WalkBuilder::new(&root);
     configure_walker(
@@ -157,6 +186,7 @@ fn run_parallel_search(
         let matcher = matcher.clone();
         let before_context = before_context;
         let after_context = after_context;
+        let cancel = cancel.clone();
         Box::new(move |entry| {
             search_entry(
                 entry,
@@ -166,6 +196,7 @@ fn run_parallel_search(
                 before_context,
                 after_context,
                 &tx,
+                &cancel,
             )
         })
     });
@@ -179,7 +210,11 @@ fn search_entry(
     before_context: usize,
     after_context: usize,
     tx: &Sender<Result<SearchLine, RgApiError>>,
+    cancel: &Arc<AtomicBool>,
 ) -> WalkState {
+    if is_cancelled(cancel) {
+        return WalkState::Quit;
+    }
     let dent = match entry {
         Ok(dent) => dent,
         Err(err) => return send_search_error(tx, RgApiError::new(err.to_string())),
@@ -198,10 +233,20 @@ fn search_entry(
     if !filters.path_allowed(&rel) {
         return WalkState::Continue;
     }
-    match search_path(path, rel, matcher.clone(), before_context, after_context) {
+    match search_path_cancelable(
+        path,
+        rel,
+        matcher.clone(),
+        before_context,
+        after_context,
+        Some(cancel.clone()),
+    ) {
         Ok(lines) => {
+            if is_cancelled(cancel) {
+                return WalkState::Quit;
+            }
             for line in lines {
-                if tx.send(Ok(line)).is_err() {
+                if is_cancelled(cancel) || tx.send(Ok(line)).is_err() {
                     return WalkState::Quit;
                 }
             }
@@ -211,6 +256,10 @@ fn search_entry(
     }
 }
 
+fn is_cancelled(cancel: &Arc<AtomicBool>) -> bool {
+    cancel.load(Ordering::Relaxed)
+}
+
 fn send_search_error(tx: &Sender<Result<SearchLine, RgApiError>>, err: RgApiError) -> WalkState {
     let _ = tx.send(Err(err));
     WalkState::Quit
@@ -250,6 +299,24 @@ pub fn search_path(
     matcher: RegexMatcher,
     before_context: usize,
     after_context: usize,
+) -> Result<Vec<SearchLine>, RgApiError> {
+    search_path_cancelable(
+        path,
+        display_path,
+        matcher,
+        before_context,
+        after_context,
+        None,
+    )
+}
+
+fn search_path_cancelable(
+    path: &Path,
+    display_path: String,
+    matcher: RegexMatcher,
+    before_context: usize,
+    after_context: usize,
+    cancel: Option<Arc<AtomicBool>>,
 ) -> Result<Vec<SearchLine>, RgApiError> {
     let mut builder = SearcherBuilder::new();
     builder
@@ -264,6 +331,7 @@ pub fn search_path(
         path: display_path,
         matcher,
         lines: &mut out,
+        cancel,
     };
     match searcher.search_path(search_matcher, path, sink) {
         Ok(()) => Ok(out),
@@ -305,6 +373,7 @@ fn search_bytes(
         path: display_path,
         matcher,
         lines: &mut out,
+        cancel: None,
     };
     searcher
         .search_slice(search_matcher, bytes, sink)
@@ -316,6 +385,15 @@ struct CollectSink<'a> {
     path: String,
     matcher: RegexMatcher,
     lines: &'a mut Vec<SearchLine>,
+    cancel: Option<Arc<AtomicBool>>,
+}
+impl CollectSink<'_> {
+    fn cancelled(&self) -> bool {
+        match &self.cancel {
+            Some(cancel) => is_cancelled(cancel),
+            None => false,
+        }
+    }
 }
 
 impl Sink for CollectSink<'_> {
@@ -326,6 +404,9 @@ impl Sink for CollectSink<'_> {
         _searcher: &grep_searcher::Searcher,
         mat: &SinkMatch<'_>,
     ) -> Result<bool, Self::Error> {
+        if self.cancelled() {
+            return Ok(false);
+        }
         let line = bytes_to_line(mat.bytes())?;
         let spans = spans_for(&self.matcher, mat.bytes())?;
         self.lines.push(SearchLine {
@@ -335,7 +416,7 @@ impl Sink for CollectSink<'_> {
             line,
             matches: spans,
         });
-        Ok(true)
+        Ok(!self.cancelled())
     }
 
     fn context(
@@ -343,6 +424,9 @@ impl Sink for CollectSink<'_> {
         _searcher: &grep_searcher::Searcher,
         ctx: &SinkContext<'_>,
     ) -> Result<bool, Self::Error> {
+        if self.cancelled() {
+            return Ok(false);
+        }
         let kind = match ctx.kind() {
             SinkContextKind::Before => SearchKind::Before,
             SinkContextKind::After => SearchKind::After,
@@ -355,7 +439,7 @@ impl Sink for CollectSink<'_> {
             line: bytes_to_line(ctx.bytes())?,
             matches: Vec::new(),
         });
-        Ok(true)
+        Ok(!self.cancelled())
     }
     fn binary_data(
         &mut self,

{rgapi-0.1.0 → rgapi-0.1.1}/tests/test_rgapi.py

@@ -1,3 +1,7 @@
+import _thread, threading
+
+import pytest
+
 from rgapi import Regex, SearchResults, compile, fd, rg, rg_iter, search_path, search_text, walk
 
 
@@ -102,6 +106,15 @@ def test_rg_returns_structured_matches_context_and_relative_paths(tmp_path):
     assert str(stream) == repr(stream)
 
 
+def test_rg_keyboard_interrupt_cancels(tmp_path):
+    (tmp_path / "big.txt").write_text("alpha beta gamma\n" * 1_000_000)
+    timer = threading.Timer(0.001, _thread.interrupt_main)
+    try:
+        with pytest.raises(KeyboardInterrupt):
+            timer.start()
+            rg("needle_that_is_not_present", str(tmp_path))
+    finally: timer.cancel()
+
 def test_direct_regex_and_search_apis(tmp_path):
     make_tree(tmp_path)
     matcher = compile("todo")

rgapi-0.1.0/python/rgapi/__init__.py

@@ -1,106 +0,0 @@
-from . import _core
-
-Regex = _core.Regex
-SearchLine = _core.SearchLine
-RgIter = _core.RgIter
-compile = _core.compile
-
-class SearchResults(list):
-    def __str__(self): return "\n".join(map(str, self))
-    def _repr_pretty_(self, p, cycle): p.text("..." if cycle else str(self))
-
-
-def _listify(value):
-    if value is None: return []
-    if isinstance(value, str): return [value]
-    return list(value)
-
-
-def _filters(glob=None, include=None, exclude=None, ext=None):
-    includes = _listify(include) + _listify(glob)
-    for suffix in _listify(ext):
-        suffix = str(suffix)
-        if suffix.startswith("."): suffix = suffix[1:]
-        includes.append(f"*.{suffix}")
-    return includes, _listify(exclude)
-
-
-def _context(context, before_context, after_context):
-    if context: return context, context
-    return before_context, after_context
-
-
-def walk(root=".", hidden=False, ignore=True, max_depth=None, min_depth=None, max_filesize=None, follow_links=False,
-    same_file_system=False, path_re=None, skip_path_re=None, skip_dir=None, skip_dir_re=None, files=True, dirs=False):
-    return _core.walk(root, hidden, ignore, max_depth, min_depth, max_filesize, follow_links,
-        same_file_system, path_re, skip_path_re, _listify(skip_dir), skip_dir_re, files, dirs)
-
-
-def fd(root=".", pattern=None, glob=None, include=None, exclude=None, ext=None, hidden=False, ignore=True, max_depth=None,
-    min_depth=None, max_filesize=None, follow_links=False, same_file_system=False, path_re=None,
-    skip_path_re=None, skip_dir=None, skip_dir_re=None, files=True, dirs=False):
-    include, exclude = _filters(glob, include, exclude, ext)
-    return _core.find(root, pattern, include, exclude, hidden, ignore, max_depth, min_depth, max_filesize,
-        follow_links, same_file_system, path_re, skip_path_re, _listify(skip_dir), skip_dir_re, files, dirs)
-
-
-def _rg_args(pattern, root, glob, include, exclude, ext, hidden, ignore, max_depth, min_depth, max_filesize,
-    follow_links, same_file_system, path_re, skip_path_re, skip_dir, skip_dir_re, case_sensitive, smart_case,
-    before_context, after_context, context):
-    include, exclude = _filters(glob, include, exclude, ext)
-    before_context, after_context = _context(context, before_context, after_context)
-    return (pattern, root, include, exclude, hidden, ignore, max_depth, min_depth, max_filesize, follow_links, same_file_system,
-        path_re, skip_path_re, _listify(skip_dir), skip_dir_re, case_sensitive, smart_case, before_context, after_context)
-
-
-def rg(pattern, root=".", glob=None, include=None, exclude=None, ext=None, hidden=False, ignore=True, max_depth=None,
-    min_depth=None, max_filesize=None, follow_links=False, same_file_system=False, path_re=None,
-    skip_path_re=None, skip_dir=None, skip_dir_re=None, case_sensitive=None, smart_case=False, before_context=0, after_context=0,
-    context=0, paths=False, count=False):
-    assert not (paths and count), "paths and count are mutually exclusive"
-    args = _rg_args(pattern, root, glob, include, exclude, ext, hidden, ignore, max_depth, min_depth, max_filesize,
-        follow_links, same_file_system, path_re, skip_path_re, skip_dir, skip_dir_re, case_sensitive, smart_case,
-        before_context, after_context, context)
-    if paths:
-        seen, res = set(), []
-        for row in _core.rg_iter(*args):
-            if row.kind != "match" or row.path in seen: continue
-            seen.add(row.path)
-            res.append(row.path)
-        return res
-    if count: return sum(len(row.matches) for row in _core.rg_iter(*args) if row.kind == "match")
-    return SearchResults(_core.rg(*args))
-
-
-def rg_iter(pattern, root=".", glob=None, include=None, exclude=None, ext=None, hidden=False, ignore=True, max_depth=None,
-    min_depth=None, max_filesize=None, follow_links=False, same_file_system=False, path_re=None, skip_path_re=None,
-    skip_dir=None, skip_dir_re=None, case_sensitive=None, smart_case=False, before_context=0, after_context=0, context=0):
-    args = _rg_args(pattern, root, glob, include, exclude, ext, hidden, ignore, max_depth, min_depth, max_filesize,
-        follow_links, same_file_system, path_re, skip_path_re, skip_dir, skip_dir_re, case_sensitive, smart_case,
-        before_context, after_context, context)
-    return _core.rg_iter(*args)
-
-
-def search_text(matcher, text, path="<text>", before_context=0, after_context=0, context=0):
-    before_context, after_context = _context(context, before_context, after_context)
-    return SearchResults(_core.search_text(matcher, text, path, before_context, after_context))
-
-
-def search_path(matcher, path, display_path=None, before_context=0, after_context=0, context=0):
-    before_context, after_context = _context(context, before_context, after_context)
-    return SearchResults(_core.search_path(matcher, path, display_path, before_context, after_context))
-
-
-__all__ = [
-    "Regex",
-    "RgIter",
-    "SearchLine",
-    "SearchResults",
-    "compile",
-    "fd",
-    "rg",
-    "rg_iter",
-    "search_path",
-    "search_text",
-    "walk",
-]