rgapi 0.1.28__tar.gz → 0.1.30__tar.gz

{rgapi-0.1.28 → rgapi-0.1.30}/Cargo.lock

@@ -330,7 +330,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rgapi"
-version = "0.1.28"
+version = "0.1.30"
 dependencies = [
  "crc32fast",
  "globset",

{rgapi-0.1.28 → rgapi-0.1.30}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rgapi"
-version = "0.1.28"
+version = "0.1.30"
 edition = "2024"
 rust-version = "1.91"
 license = "Apache-2.0"

{rgapi-0.1.28 → rgapi-0.1.30}/DEV.md

@@ -52,4 +52,6 @@ Rust callers can consume a `StreamIter` with `cancel_and_join()` to cancel, drai
 
 Notebook hierarchy uses `heading_level(source)`, `section_range(levels, idx)` and `ancestor_indices(levels, idx)`. Callers supply zero for non-heading cells. Heading detection skips blank lines and lines starting with `#|`, then checks the first remaining line against `^#{1,6} \w`. It does not search past ordinary text. Section ranges include the addressed cell and end before the next equal-or-higher heading; non-headings select themselves. Ancestors exclude the addressed cell and are returned outermost first. These are calculations over the supplied levels, without retained outline state. Rustygate uses them for its cell selectors.
 
+`cell_refs(cell)` takes an nbformat cell as a `serde_json::Value` and returns its sigil references as `CellRefs { vars, cmds, tools }`, in order of appearance, with duplicates. A prompt cell has `solveit_ai: true` in its metadata. `vars` holds each `expr` written as `` $`expr` `` in a prompt cell's source. `cmds` holds each `cmd` written as `` !`cmd` `` in a prompt cell's source. `tools` holds each name written as `` &`name` `` or `` &`[a, b]` ``. A name holds word characters and dots. `cell_refs` reads `tools` from the source of a prompt or Markdown cell. For every other cell it reads the `text/markdown` data of `display_data` and `execute_result` outputs. It never reads a prompt cell's outputs. This function is Rust-only. Rustygate uses it for the cells API's `refs=true`.
+
 This package intentionally has no CLI. Python is the interface.

{rgapi-0.1.28 → rgapi-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.1.28
+Version: 0.1.30
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore>=2.2.29
@@ -12,7 +12,7 @@ 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: Apache-2.0
+License-Expression: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Homepage, https://github.com/AnswerDotAI/rgapi
@@ -124,6 +124,8 @@ Pass `lnhashs=True` to `rg` or `rg_iter` to display hash addresses instead of li
 
 For other result forms, use `rg(..., paths=True)` to return unique matched paths or `rg(..., count=True)` to count match spans. `paths` and `count` cannot both be set.
 
+`^` and `$` match at the start and end of each line. A line ends at `\n` or `\r\n`. `$` also matches before a `\r` that has no `\n` after it. `rg`, `rgstr`, and `nbrg` without `multiline=True` raise `ValueError` for a pattern that contains a literal `\n` or `\r`.
+
 ### Path results
 
 `fd`, `walk`, and `ls` return `PathResults`, a list of absolute `Path` objects. So do `rg` and `nbrg` with `paths=True`, and their async equivalents. Indexing or iterating returns ordinary Paths:

{rgapi-0.1.28 → rgapi-0.1.30}/README.md

@@ -103,6 +103,8 @@ Pass `lnhashs=True` to `rg` or `rg_iter` to display hash addresses instead of li
 
 For other result forms, use `rg(..., paths=True)` to return unique matched paths or `rg(..., count=True)` to count match spans. `paths` and `count` cannot both be set.
 
+`^` and `$` match at the start and end of each line. A line ends at `\n` or `\r\n`. `$` also matches before a `\r` that has no `\n` after it. `rg`, `rgstr`, and `nbrg` without `multiline=True` raise `ValueError` for a pattern that contains a literal `\n` or `\r`.
+
 ### Path results
 
 `fd`, `walk`, and `ls` return `PathResults`, a list of absolute `Path` objects. So do `rg` and `nbrg` with `paths=True`, and their async equivalents. Indexing or iterating returns ordinary Paths:

{rgapi-0.1.28 → rgapi-0.1.30}/pyproject.toml

@@ -1,12 +1,12 @@
 [build-system]
-requires = ["maturin>=1.0,<2.0"]
+requires = ["maturin>=1.9.2,<2.0"]
 build-backend = "maturin"
 
 [project]
 name = "rgapi"
 dynamic = ["version"]
 description = "Python API for ripgrep-style file walking and searching"
-license = {text = "Apache-2.0"}
+license = "Apache-2.0"
 requires-python = ">=3.10"
 readme = "README.md"
 authors = [{name = "Jeremy Howard", email = "j@fast.ai"}]

{rgapi-0.1.28 → rgapi-0.1.30}/python/rgapi/skill.py

@@ -6,8 +6,8 @@ For orientation, start with `rg(summary=True)`; use line-level results where nee
 
 ## Search units
 
-- `rg`: lines, or `SearchBlock` rows with `summary=True`. Blank/whitespace-only lines separate blocks; multiple matches in one block yield one row. Context counts the selected unit. Summary mode cannot combine with `paths` or `count`, but supports hashed block boundaries.
-- `nbrg`: `NbResults` of `NbCell` rows from source only, never metadata/outputs. `multiline=True` matches across cell lines while `^`/`$` remain line anchors; ordinary line-oriented `rg` rejects newline patterns.
+- `rg`: lines, or `SearchBlock` rows with `summary=True`. Blank/whitespace-only lines separate blocks; multiple matches in one block yield one row. Context counts the selected unit. Summary mode cannot combine with `paths` or `count`, but supports hashed block boundaries. `^`/`$` anchor each line. A line ends at LF or CRLF.
+- `nbrg`: `NbResults` of `NbCell` rows from source only, never metadata/outputs. `multiline=True` matches across cell lines while `^`/`$` remain line anchors; ordinary line-oriented `rg` rejects patterns containing a newline or carriage return.
 - Traversal/search run in parallel in Rust; sort when stable order is required. `path_re`/`skip_path_re` filter paths without pruning; `skip_dir`/`skip_dir_re` prune subtrees.
 
 ## Result fields and display

{rgapi-0.1.28 → rgapi-0.1.30}/src/lib.rs

@@ -9,7 +9,7 @@ mod walk;
 mod python;
 
 pub use block::{BlockIter, SearchBlock, block_iter};
-pub use nb::{NbCell, NbIter, NbOptions, ancestor_indices, heading_level, nb_iter, nb_search, nb_search_file, section_range};
+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, find, find_iter};
 

{rgapi-0.1.28 → rgapi-0.1.30}/src/nb.rs

@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, LazyLock};
 use std::sync::atomic::Ordering;
 
-use grep_matcher::Matcher;
+use grep_matcher::{Captures, Matcher};
 use grep_regex::RegexMatcher;
 use ignore::{DirEntry, WalkState};
 use serde::Deserialize;
@@ -42,6 +42,56 @@ pub fn ancestor_indices(levels: &[usize], idx: usize) -> Vec<usize> {
     parents
 }
 
+/// Group 1 of every `` sigil`body` `` match in `text`, in order of appearance. `sigil` and `body` are regex fragments.
+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");
+    res
+}
+
+/// Names written as `` &`name` `` or `` &`[a, b]` `` in `text`. A name holds word characters and dots.
+fn tool_names(text: &str) -> Vec<String> {
+    let groups = sigil_caps(text, "&", r"[\w.]+|\[[\w.,\s]+\]");
+    groups.iter().flat_map(|g| g.split(['[', ']', ','])).map(str::trim).filter(|s| !s.is_empty()).map(String::from).collect()
+}
+
+/// nbformat multiline text, a string or a list of strings, as one string.
+fn nb_text(v: &serde_json::Value) -> String {
+    match v { serde_json::Value::String(s) => s.clone(), serde_json::Value::Array(a) => a.iter().filter_map(|o| o.as_str()).collect(), _ => String::new() }
+}
+
+/// The sigil references in one notebook cell, in order of appearance.
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct CellRefs {
+    /// Each `expr` written as `` $`expr` ``
+    pub vars: Vec<String>,
+    /// Each `cmd` written as `` !`cmd` ``
+    pub cmds: Vec<String>,
+    /// Each name written as `` &`name` `` or `` &`[a, b]` ``
+    pub tools: Vec<String>,
+}
+
+/// The sigil references in `cell`, an nbformat cell. A prompt cell has `solveit_ai: true` in its metadata.
+/// `vars` and `cmds` come from a prompt cell's source. `tools` comes from the source of a prompt or Markdown cell.
+/// For every other cell, `tools` comes from the `text/markdown` data of its `display_data` and `execute_result` outputs.
+/// A prompt cell's outputs are never read.
+pub fn cell_refs(cell: &serde_json::Value) -> CellRefs {
+    let src = nb_text(&cell["source"]);
+    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; }
+    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"]))); }
+    }
+    res
+}
+
 #[derive(Debug, Clone)]
 pub struct NbOptions {
     pub root: PathBuf,

{rgapi-0.1.28 → rgapi-0.1.30}/src/search.rs

@@ -5,7 +5,7 @@ use std::sync::{
     mpsc::SyncSender,
 };
 
-use grep_matcher::Matcher;
+use grep_matcher::{LineTerminator, Matcher};
 use grep_regex::{RegexMatcher, RegexMatcherBuilder};
 use grep_searcher::{BinaryDetection, SearcherBuilder, Sink, SinkContext, SinkContextKind, SinkError, SinkMatch};
 use ignore::{DirEntry, WalkState};
@@ -167,8 +167,8 @@ fn send_search_error(tx: &SyncSender<Result<SearchLine, RgApiError>>, err: RgApi
 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")); }
     let mut builder = RegexMatcherBuilder::new();
-    if multiline { builder.multi_line(true); }
-    else { builder.line_terminator(Some(b'\n')); }
+    builder.multi_line(true).crlf(true);
+    if multiline { builder.line_terminator(None); }
     match case_sensitive {
         Some(true) => {
             builder.case_insensitive(false);
@@ -208,7 +208,7 @@ fn search_path_cancelable(
     cancel: Option<Arc<AtomicBool>>,
 ) -> Result<Vec<SearchLine>, RgApiError> {
     let mut builder = SearcherBuilder::new();
-    builder.line_number(true).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();
@@ -236,7 +236,7 @@ fn search_bytes(
     multiline: bool,
 ) -> Result<Vec<SearchLine>, RgApiError> {
     let mut builder = SearcherBuilder::new();
-    builder.line_number(true).before_context(before_context).after_context(after_context).multi_line(multiline);
+    builder.line_number(true).line_terminator(LineTerminator::crlf()).before_context(before_context).after_context(after_context).multi_line(multiline);
     let mut searcher = builder.build();
     let mut out = Vec::new();
     let search_matcher = matcher.clone();

{rgapi-0.1.28 → rgapi-0.1.30}/tests/test_rgapi.py

@@ -188,8 +188,7 @@ def test_depth_size_and_filesystem_options(tmp_path):
 def test_lnhash_matches_fastcore(tmp_path):
     from fastcore.tools import lnhash as py_hash
     make_tree(tmp_path)
-    for row in rg(".", str(tmp_path)):
-        assert row.lnhash == py_hash(row.line_number, row.line)
+    for row in rg(".", str(tmp_path)): assert row.lnhash == py_hash(row.line_number, row.line)
 
 
 def test_rg_returns_structured_matches_context_and_relative_paths(tmp_path):
@@ -662,3 +661,13 @@ def test_nbrg_multiline(tmp_path):
     m, = res[0].matches
     assert m.line_number == 1 and "export" in m.line and "import" in m.line
     assert nbrg(r"^import", str(tmp_path), multiline=True, count=True) == 2   # ^ still means line start
+
+
+def test_line_anchor_spans(tmp_path):
+    "`$` anchors at line end in match spans, for LF and CRLF lines. `count=True` sums those spans."
+    (tmp_path/"a.txt").write_text("foo\nbar foo\nfoo bar\nlast foo")
+    assert sorted((r.line_number, r.matches) for r in rg(r"foo$", tmp_path)) == [(1, [(0, 3)]), (2, [(4, 7)]), (4, [(5, 8)])]
+    assert rg(r"foo$", tmp_path, count=True) == 3
+    assert [r.matches for r in rgstr(r"foo$", "foo\nbar foo")] == [[(0, 3)], [(4, 7)]]
+    (tmp_path/"crlf.txt").write_bytes(b"foo\r\nbar foo\r\n")
+    assert sorted((r.line_number, r.line, r.matches) for r in rg(r"foo$", tmp_path/"crlf.txt")) == [(1, "foo", [(0, 3)]), (2, "bar foo", [(4, 7)])]