rgapi 0.1.26__tar.gz → 0.1.27__tar.gz

{rgapi-0.1.26 → rgapi-0.1.27}/Cargo.lock

@@ -24,9 +24,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
 
 [[package]]
 name = "core_detect"
@@ -215,7 +215,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 3.0.5",
+ "syn 3.0.6",
 ]
 
 [[package]]
@@ -330,7 +330,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rgapi"
-version = "0.1.26"
+version = "0.1.27"
 dependencies = [
  "crc32fast",
  "globset",
@@ -391,7 +391,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.5",
+ "syn 3.0.6",
 ]
 
 [[package]]
@@ -426,9 +426,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.5"
+version = "3.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -443,9 +443,9 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.24"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+checksum = "ab72a15cf68d77cb0987d3684aa8a45c5ef827e8cb49ee2f30bfd7ba2feb519f"
 
 [[package]]
 name = "walkdir"

{rgapi-0.1.26 → rgapi-0.1.27}/Cargo.toml

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

{rgapi-0.1.26 → rgapi-0.1.27}/DEV.md

@@ -38,15 +38,15 @@ The GitHub workflow builds wheels for Python 3.10-3.13 on Linux and macOS and pu
 
 ## Design notes
 
-Paths in `fd`, `walk`, `rg`, and `rg_iter` results are relative to the requested root and use `/` separators. Traversal uses `ignore::WalkParallel`, so result order is not part of the API contract. Search results are structured rows; collected result lists use rg-style `str()` and notebook display. `SearchLine.lnhash` is computed with the same CRC-32-based line-content hash format as exhash (`lineno|hash|`, low 16 bits of CRC-32 over the line's UTF-8 bytes); `lnhashs=True` only changes row display, not `line_number` or matching behavior. Path regexes filter returned/searched paths; `skip_dir` and `skip_dir_re` prune traversal through `ignore::WalkBuilder::filter_entry`. Depth, size, symlink, filesystem, hidden, and ignore options are direct `ignore::WalkBuilder` settings. `rg_iter` exposes the same parallel search stream that `rg` collects by default; `paths=True` and `count=True` consume that stream with different reducers. Binary files and invalid UTF-8 are skipped for now.
+Python discovery and `paths=True` results contain absolute `pathlib.Path` objects. Structured search rows retain root-relative string labels with `/` separators. Traversal uses `ignore::WalkParallel`, so result order is not part of the API contract. Search results are structured rows; collected result lists use rg-style `str()` and notebook display. `SearchLine.lnhash` is computed with the same CRC-32-based line-content hash format as exhash (`lineno|hash|`, low 16 bits of CRC-32 over the line's UTF-8 bytes); `lnhashs=True` only changes row display, not `line_number` or matching behavior. Path regexes filter returned/searched paths; `skip_dir` and `skip_dir_re` prune traversal through `ignore::WalkBuilder::filter_entry`. Depth, size, filesystem, hidden, and ignore options use `ignore::WalkBuilder` settings. Discovery checks root links with `symlink_metadata` and returns an unfollowed link through a ready stream without a worker. This also supports dangling roots, which the underlying walker would reject. Other discovery roots use absolute paths without canonicalizing. Content searches retain canonical root resolution. `rg_iter` exposes the same parallel search stream that `rg` collects by default; `paths=True` and `count=True` consume that stream with different reducers. Text search skips binary files and invalid UTF-8 content.
 
-Streaming engine: `walk.rs` owns the generic machinery. `StreamIter<T>` is the worker-thread-plus-bounded-channel iterator (`sync_channel(8192)`, so producers block rather than buffer without limit when a consumer lags), and `spawn_walk` owns the shared scaffold: walker config, panic catching, cancel flag, and worker thread. `rg_iter` (`T = SearchLine`), `block_iter` (`T = SearchBlock`), `nb_iter` (`T = NbCell`), and `find_iter` (`T = String`, the path walk) plug entry closures into that engine. Block search reads each file once, searches it once, groups nonblank lines into blocks, maps matching lines to their blocks, and expands context by block index. Each `SearchBlock` carries numeric boundaries plus hashes for its first and last source lines. Python keeps both and chooses the displayed address without another file read.
+Streaming engine: `walk.rs` owns the generic machinery. `StreamIter<T>` is the worker-thread-plus-bounded-channel iterator (`sync_channel(8192)`, so producers block rather than buffer without limit when a consumer lags), and `spawn_walk` owns the shared scaffold: walker config, panic catching, cancel flag, and worker thread. `rg_iter` (`T = SearchLine`), `block_iter` (`T = SearchBlock`), `nb_iter` (`T = NbCell`), and `find_iter` (`T = PathBuf`, the path walk) plug entry closures into that engine. Block search reads each file once, searches it once, groups nonblank lines into blocks, maps matching lines to their blocks, and expands context by block index. Each `SearchBlock` carries numeric boundaries plus hashes for its first and last source lines. Python keeps both and chooses the displayed address without another file read.
 
 Async API: `fda`, `fda_iter`, `rga`, `rga_iter`, `nbrga`, and `nbrga_iter` wrap the corresponding private core operations. `rga(summary=True)` uses `_core.block_search_async`; ordinary `rga` uses `_core.rg_async`. Each collected core function takes a Python callback, runs on Rust threads through the generic `stream_async` helper, and delivers with one GIL attach at the end. Iterator forms use `stream_iter_async` and attach once per batch. The Python side settles an `asyncio.Future` or feeds an `asyncio.Queue` via `loop.call_soon_threadsafe`; no Python thread blocks and `asyncio.to_thread` is not involved. `AsyncHandle.cancel()` sets the same atomic flag used by the Rust iterators.
 
 Truncation is recorded on collected results: `max_results` sets `stop_reason="max_results"`, and `timeout_ms` on `rg`/`rga`/`nbrg`/`nbrga`/`fd`/`fda`/`walk`/`ls` sets `stop_reason="timeout"`. `SearchResults`, `BlockResults`, `PathResults`, and `NbResults` share this through `_Results`; `complete` means `stop_reason is None`. In block summary mode, `max_results` counts matching blocks and keeps their block context. `count=True` returns a plain int, so it rejects timeouts and block summary mode.
 
-Path results are `FileEntry` rows: a `str` subclass carrying the walk root, so paths stay plain strings for compatibility while stat info loads lazily (one cached `os.lstat` per entry, read only on attribute access). The wrapping happens at result construction on the Python side; Rust still streams plain strings. `PathResults.__repr__` shows an `ls -l`-style listing capped at `MAX_REPR` rows, so a huge result never stats everything, while `str()` stays one plain path per line. `ls` is `fd` with shell-style defaults (one level, dirs, ignore rules off), re-sorted with `stop_reason` preserved.
+Rust discovery returns root-relative `PathBuf` values. Glob filters operate on native paths; only regex matching uses string labels. PyO3 converts discovery roots and results with its filesystem-path support. Python joins each result to its absolute base without resolving links. `PathResults` stores that display base and completion status, including across slices. Its `__repr__` uses `Path.lstat()` for an `ls -l`-style listing capped at `MAX_REPR` rows. `str()` returns one root-relative name per line. `ls` is `fd` with shell-style defaults (one level, dirs, ignore rules off), sorted in place.
 
 Rust callers can consume a `StreamIter` with `cancel_and_join()` to cancel, drain queued results, and wait for the walk's workers to finish. `Drop` remains nonblocking. Since filesystem calls already in progress must return before joining completes, keep `cancel_and_join()` off async executors.
 

{rgapi-0.1.26 → rgapi-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.1.26
+Version: 0.1.27
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore>=1.14.6
@@ -77,17 +77,17 @@ pip install rgapi
 
 ## File discovery
 
-`fd` and `walk` return slash-separated paths relative to `root`. Pass `root` as a `str` or `pathlib.Path`. The sync and async APIs expand `~` and accept `.`, `./`, and paths containing `..`.
+`fd` and `walk` return absolute `pathlib.Path` objects. Use them directly with `.read_text()`, `.open()`, `.stat()`, or other filesystem operations. Their collected results display names relative to `root`. Pass `root` as a `str` or `Path`. The sync and async APIs expand `~` and accept `.`, `./`, and paths containing `..`.
 
 Discovery uses the `ignore` crate with ripgrep's default filters. It reads `.gitignore`, `.ignore`, and `.rgignore` files. `.rgignore` takes precedence over `.gitignore`. Pass `ignore=False` to disable all ignore-file filtering, including `.rgignore`.
 
-Hidden files are skipped unless `hidden=True`. Symlinks are followed only with `follow_links=True`. Use `same_file_system=True` to avoid crossing filesystem boundaries.
+Hidden files are skipped unless `hidden=True`. Discovery returns symlinks themselves, including explicitly named roots and dangling links. Set `follow_links=True` to traverse their targets. Paths retain the symlink spelling. Use `same_file_system=True` to avoid crossing filesystem boundaries.
 
 Traversal runs in parallel without guaranteed result order. Use `sorted(...)` when order matters.
 
 `fd` adds filename filters to `walk`. Its `pattern` is a smart-case regex matched against each basename. Lowercase patterns match case-insensitively. A pattern containing uppercase letters is case-sensitive. Use `path_re` to match the slash-separated relative path instead.
 
-`include` and `exclude` use glob syntax. `glob=` is an alias for `include=`. A basename glob such as `*.py` also matches nested paths such as `src/app.py`.
+`include` and `exclude` use case-sensitive glob syntax. `glob=` is an alias for `include=`. Patterns without `/` match names at any depth, so `*.py` matches `src/app.py`. Patterns containing `/` are root-relative. `*` stays within a path component; `**` spans directories: `src/*` matches immediate children, whereas `src/**` also matches deeper descendants. Matching a directory with `exclude` prunes its entire subtree. Includes never prune traversal. Excludes always win, and includes do not override ignore rules.
 
 Filter extensions with `ext="py"` or `ext=["py", "rs"]`. Extension and glob filters must both match. For example, `include="src/*", ext="py"` requires `src/*` and `*.py`, like combining `rg -g` with `-t`.
 
@@ -95,7 +95,7 @@ Set `min_depth` and `max_depth` to bound recursion. `max_filesize` skips files a
 
 `ls` follows the shell command's listing conventions. It uses `fd` with `max_depth=1`, includes directories, disables ignore rules, and sorts by name. Set `hidden=True` for `ls -a` behaviour. All `fd` filters remain available.
 
-`fd_iter` yields `FileEntry` paths as the walk finds them. It accepts every `fd` filter. Stopping iteration ends the walk. It does not accept `timeout_ms`.
+`fd_iter` yields absolute `Path` objects as the walk finds them. It accepts every `fd` filter. Stopping iteration ends the walk. It does not accept `timeout_ms`.
 
 `path_re` and `skip_path_re` filter slash-separated relative paths using regexes. They select returned paths or searched files without changing traversal. To skip entire subtrees, use `skip_dir` with a glob or `skip_dir_re` with a regex.
 
@@ -126,11 +126,23 @@ For other result forms, use `rg(..., paths=True)` to return unique matched paths
 
 ### Path results
 
-`fd`, `walk`, and `ls` return `PathResults`. So do `rg` and `nbrg` with `paths=True`. This is a list of `FileEntry` rows.
+`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:
 
-A `FileEntry` is a `str` subclass containing a relative path. Its `stat` property calls `os.lstat` on first access and caches the result. It returns `None` if the path has vanished. `size`, `mtime`, and `is_dir` use the cached stat result. The object also supports ordinary string operations.
+```python
+for path in fd("src", ext="py"):
+    text = path.read_text()
+    size = path.stat().st_size
+```
+
+Use `.name`, `.suffix`, and `.relative_to(root)` for path components. `.stat()` follows symlinks; `.lstat()` inspects the link itself. `.readlink()` returns a link's target. Discovery preserves native filenames, including literal backslashes on Unix and non-UTF-8 names on filesystems that support them.
+
+`PathResults` displays as an `ls -l`-style listing of at most `rgapi.MAX_REPR` rows. A final `… N more` line reports omitted rows. The listing uses `.lstat()` only on displayed rows. `show_target=True` adds symlink targets. `str(res)` returns one root-relative name per line. Slices retain the display root and completion status. `list(res)` returns the absolute Paths without the custom display.
+
+Structured text and notebook search rows retain root-relative string labels in their `path` fields. Content searches still follow explicitly named root links. This differs from discovery's default of returning the link itself.
+
+The Rust `find` and `find_iter` APIs return native `PathBuf` values relative to the root. For an explicitly named file or unfollowed root link, the result is its basename.
 
-`PathResults` displays as an `ls -l`-style listing of at most `rgapi.MAX_REPR` rows. A final `… N more` line reports omitted rows. Only displayed rows need stat calls. `str()` returns one plain path per line. `list(res)` also displays plain paths.
+Rust callers can set `FindOptions::special_files` to also discover FIFOs, sockets, and device nodes, for example to reject unsupported entries during archiving. This defaults to false; normal discovery returns regular files, directories when requested, and symlinks.
 
 ### Limits and timeouts
 

{rgapi-0.1.26 → rgapi-0.1.27}/README.md

@@ -56,17 +56,17 @@ pip install rgapi
 
 ## File discovery
 
-`fd` and `walk` return slash-separated paths relative to `root`. Pass `root` as a `str` or `pathlib.Path`. The sync and async APIs expand `~` and accept `.`, `./`, and paths containing `..`.
+`fd` and `walk` return absolute `pathlib.Path` objects. Use them directly with `.read_text()`, `.open()`, `.stat()`, or other filesystem operations. Their collected results display names relative to `root`. Pass `root` as a `str` or `Path`. The sync and async APIs expand `~` and accept `.`, `./`, and paths containing `..`.
 
 Discovery uses the `ignore` crate with ripgrep's default filters. It reads `.gitignore`, `.ignore`, and `.rgignore` files. `.rgignore` takes precedence over `.gitignore`. Pass `ignore=False` to disable all ignore-file filtering, including `.rgignore`.
 
-Hidden files are skipped unless `hidden=True`. Symlinks are followed only with `follow_links=True`. Use `same_file_system=True` to avoid crossing filesystem boundaries.
+Hidden files are skipped unless `hidden=True`. Discovery returns symlinks themselves, including explicitly named roots and dangling links. Set `follow_links=True` to traverse their targets. Paths retain the symlink spelling. Use `same_file_system=True` to avoid crossing filesystem boundaries.
 
 Traversal runs in parallel without guaranteed result order. Use `sorted(...)` when order matters.
 
 `fd` adds filename filters to `walk`. Its `pattern` is a smart-case regex matched against each basename. Lowercase patterns match case-insensitively. A pattern containing uppercase letters is case-sensitive. Use `path_re` to match the slash-separated relative path instead.
 
-`include` and `exclude` use glob syntax. `glob=` is an alias for `include=`. A basename glob such as `*.py` also matches nested paths such as `src/app.py`.
+`include` and `exclude` use case-sensitive glob syntax. `glob=` is an alias for `include=`. Patterns without `/` match names at any depth, so `*.py` matches `src/app.py`. Patterns containing `/` are root-relative. `*` stays within a path component; `**` spans directories: `src/*` matches immediate children, whereas `src/**` also matches deeper descendants. Matching a directory with `exclude` prunes its entire subtree. Includes never prune traversal. Excludes always win, and includes do not override ignore rules.
 
 Filter extensions with `ext="py"` or `ext=["py", "rs"]`. Extension and glob filters must both match. For example, `include="src/*", ext="py"` requires `src/*` and `*.py`, like combining `rg -g` with `-t`.
 
@@ -74,7 +74,7 @@ Set `min_depth` and `max_depth` to bound recursion. `max_filesize` skips files a
 
 `ls` follows the shell command's listing conventions. It uses `fd` with `max_depth=1`, includes directories, disables ignore rules, and sorts by name. Set `hidden=True` for `ls -a` behaviour. All `fd` filters remain available.
 
-`fd_iter` yields `FileEntry` paths as the walk finds them. It accepts every `fd` filter. Stopping iteration ends the walk. It does not accept `timeout_ms`.
+`fd_iter` yields absolute `Path` objects as the walk finds them. It accepts every `fd` filter. Stopping iteration ends the walk. It does not accept `timeout_ms`.
 
 `path_re` and `skip_path_re` filter slash-separated relative paths using regexes. They select returned paths or searched files without changing traversal. To skip entire subtrees, use `skip_dir` with a glob or `skip_dir_re` with a regex.
 
@@ -105,11 +105,23 @@ For other result forms, use `rg(..., paths=True)` to return unique matched paths
 
 ### Path results
 
-`fd`, `walk`, and `ls` return `PathResults`. So do `rg` and `nbrg` with `paths=True`. This is a list of `FileEntry` rows.
+`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:
 
-A `FileEntry` is a `str` subclass containing a relative path. Its `stat` property calls `os.lstat` on first access and caches the result. It returns `None` if the path has vanished. `size`, `mtime`, and `is_dir` use the cached stat result. The object also supports ordinary string operations.
+```python
+for path in fd("src", ext="py"):
+    text = path.read_text()
+    size = path.stat().st_size
+```
+
+Use `.name`, `.suffix`, and `.relative_to(root)` for path components. `.stat()` follows symlinks; `.lstat()` inspects the link itself. `.readlink()` returns a link's target. Discovery preserves native filenames, including literal backslashes on Unix and non-UTF-8 names on filesystems that support them.
+
+`PathResults` displays as an `ls -l`-style listing of at most `rgapi.MAX_REPR` rows. A final `… N more` line reports omitted rows. The listing uses `.lstat()` only on displayed rows. `show_target=True` adds symlink targets. `str(res)` returns one root-relative name per line. Slices retain the display root and completion status. `list(res)` returns the absolute Paths without the custom display.
+
+Structured text and notebook search rows retain root-relative string labels in their `path` fields. Content searches still follow explicitly named root links. This differs from discovery's default of returning the link itself.
+
+The Rust `find` and `find_iter` APIs return native `PathBuf` values relative to the root. For an explicitly named file or unfollowed root link, the result is its basename.
 
-`PathResults` displays as an `ls -l`-style listing of at most `rgapi.MAX_REPR` rows. A final `… N more` line reports omitted rows. Only displayed rows need stat calls. `str()` returns one plain path per line. `list(res)` also displays plain paths.
+Rust callers can set `FindOptions::special_files` to also discover FIFOs, sockets, and device nodes, for example to reject unsupported entries during archiving. This defaults to false; normal discovery returns regular files, directories when requested, and symlinks.
 
 ### Limits and timeouts
 

{rgapi-0.1.26 → rgapi-0.1.27}/pyproject.toml

@@ -43,3 +43,6 @@ cache-keys = [{ file = "pyproject.toml" }, { file = "src/**/*.rs" }, { file = "C
 
 [tool.fastship]
 branch = "main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

{rgapi-0.1.26 → rgapi-0.1.27}/python/rgapi/__init__.py

@@ -1,8 +1,7 @@
-import asyncio, os, re
+import asyncio, re
 from contextlib import aclosing
 from datetime import datetime
-from functools import cached_property
-from stat import S_ISDIR, S_ISLNK, filemode
+from stat import S_ISLNK, filemode
 
 from os import fspath
 from pathlib import Path
@@ -42,48 +41,32 @@ def _hsize(n):
         n /= 1024
     return f"{n:.0f}" if u == "B" else f"{n:.1f}{u}"
 
-class FileEntry(str):
-    "Relative path that lazily stats itself for `size`/`mtime`/`is_dir`/`link_target` and `ls -l`-style display"
-    def __new__(cls, path, root=".", show_target=False):
-        self = super().__new__(cls, path)
-        self.root,self.show_target = os.path.abspath(root),show_target
-        return self
-    @cached_property
-    def stat(self):
-        "Cached `os.lstat` result; `None` if the path has vanished"
-        try: return os.lstat(os.path.join(self.root, self))
-        except OSError: return None
-    @property
-    def size(self): return None if self.stat is None else self.stat.st_size
-    @property
-    def mtime(self): return None if self.stat is None else datetime.fromtimestamp(self.stat.st_mtime)
-    @property
-    def is_dir(self): return self.stat is not None and S_ISDIR(self.stat.st_mode)
-    @cached_property
-    def link_target(self):
-        "`os.readlink` result for a symlink; `None` otherwise"
-        if self.stat is None or not S_ISLNK(self.stat.st_mode): return None
-        try: return os.readlink(os.path.join(self.root, self))
-        except OSError: return None
-    def _line(self):
-        if self.stat is None: return f"{'?':10} {'?':>7} {'?':16} {self}"
-        tgt = f" -> {self.link_target}" if self.show_target and self.link_target is not None else ""
-        return f"{filemode(self.stat.st_mode)} {_hsize(self.stat.st_size):>7} {self.mtime:%Y-%m-%d %H:%M} {self}{tgt}"
-    def _repr_markdown_(self): return f"`{self._line()}`"
-
-def _entry_root(root):
-    "Stat base for `FileEntry`: a file root's entries are named relative to its parent"
-    return os.path.dirname(root) if os.path.isfile(root) else root
-
-def _fe(paths, root, show_target=False):
-    root = _entry_root(root)
-    return (FileEntry(p, root, show_target) for p in paths)
+def _path_base(root, follow_links=True):
+    root = Path(root).absolute()
+    return root if (follow_links or not root.is_symlink()) and root.is_dir() else root.parent
 
 class PathResults(_Results):
-    "List of relative `FileEntry` paths; repr is `ls -l`-style, `str()` is line-per-path"
-    def __str__(self): return "\n".join(self)
+    "Absolute `Path` objects with root-relative plain and `ls -l`-style displays"
+    def __init__(self, paths=(), root=".", show_target=False):
+        self.root,self.show_target = Path(root).absolute(),show_target
+        super().__init__(self.root/p for p in paths)
+    def __getitem__(self, key):
+        res = super().__getitem__(key)
+        if not isinstance(key, slice): return res
+        res = PathResults(res, self.root, self.show_target)
+        res.stop_reason = self.stop_reason
+        return res
+    def __str__(self): return "\n".join(p.relative_to(self.root).as_posix() for p in self)
+    def _line(self, path):
+        name = path.relative_to(self.root).as_posix()
+        try:
+            st = path.lstat()
+            tgt = f" -> {path.readlink()}" if self.show_target and S_ISLNK(st.st_mode) else ""
+        except OSError: return f"{'?':10} {'?':>7} {'?':16} {name}"
+        mtime = datetime.fromtimestamp(st.st_mtime)
+        return f"{filemode(st.st_mode)} {_hsize(st.st_size):>7} {mtime:%Y-%m-%d %H:%M} {name}{tgt}"
     def __repr__(self):
-        res = [p._line() if isinstance(p, FileEntry) else str(p) for p in self[:MAX_REPR]]
+        res = [self._line(p) for p in self[:MAX_REPR]]
         if len(self) > MAX_REPR: res.append(f"… {len(self)-MAX_REPR:,} more")
         if self.stop_reason is not None: res.append(f"… truncated: {self.stop_reason}")
         return "\n".join(res)
@@ -127,11 +110,11 @@ def walk(
     dirs:bool=False, # Include directories in results
     timeout_ms:int|None=None, # Cancel the walk after this long and return partial results
 ) -> PathResults:
-    "Walk a directory and return relative file and/or directory paths."
-    rt = _fs_path(root)
+    "Walk a directory and return absolute file and/or directory Paths."
+    rt = Path(root).expanduser().absolute()
     paths, timed_out = _core.walk(rt, 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, timeout_ms)
-    return _mk_results(PathResults, _fe(paths, rt), False, timed_out)
+    return _mk_results(PathResults, paths, False, timed_out, root=_path_base(rt, follow_links))
 
 
 def _walk_args(
@@ -166,10 +149,10 @@ def fd(
     timeout_ms:int|None=None, # Cancel the walk after this long and return partial results
     **kwargs
 ) -> PathResults:
-    "Find paths with fd-style filters and gitignore support."
-    rt = _fs_path(root)
+    "Find absolute Paths with fd-style filters and gitignore support."
+    rt = Path(root).expanduser().absolute()
     paths, timed_out = _core.find(rt, pattern, *_walk_args(**kwargs), files, dirs, timeout_ms)
-    return _mk_results(PathResults, _fe(paths, rt, show_target), False, timed_out)
+    return _mk_results(PathResults, paths, False, timed_out, root=_path_base(rt, kwargs.get('follow_links', False)), show_target=show_target)
 
 
 @delegates(_walk_args)
@@ -180,9 +163,10 @@ def fd_iter(
     dirs:bool=False, # Include directories in results
     **kwargs
 ):
-    "Walk lazily, yielding `FileEntry` paths as they are found; early exit stops the walk."
-    rt = _fs_path(root)
-    return _fe(_core.find_iter(rt, pattern, *_walk_args(**kwargs), files, dirs), rt)
+    "Walk lazily, yielding absolute Paths; early exit stops the walk."
+    rt = Path(root).expanduser().absolute()
+    base = _path_base(rt, kwargs.get('follow_links', False))
+    return (base/p for p in _core.find_iter(rt, pattern, *_walk_args(**kwargs), files, dirs))
 
 
 @delegates(fd)
@@ -197,9 +181,8 @@ def ls(
 ) -> PathResults:
     "List a directory like `ls`: one level, directories included, ignore rules off, sorted by name."
     res = fd(root, pattern, hidden=hidden, dirs=dirs, max_depth=max_depth, ignore=ignore, **kwargs)
-    out = PathResults(sorted(res))
-    out.stop_reason = res.stop_reason
-    return out
+    res.sort()
+    return res
 
 async def _acall(fn, *args):
     "Run a `_core` async op: settle a Future from its callback; cancel the op if abandoned"
@@ -228,9 +211,9 @@ async def fda(
     **kwargs
 ) -> PathResults:
     "Async `fd`: find paths on Rust threads without blocking the event loop."
-    rt = _fs_path(root)
+    rt = Path(root).expanduser().absolute()
     paths, timed_out = await _acall(_core.find_async, rt, pattern, *_walk_args(**kwargs), files, dirs, timeout_ms)
-    return _mk_results(PathResults, _fe(paths, rt), False, timed_out)
+    return _mk_results(PathResults, paths, False, timed_out, root=_path_base(rt, kwargs.get('follow_links', False)))
 
 
 @delegates(_walk_args)
@@ -242,12 +225,13 @@ async def fda_iter(
     batch_max:int=512, # Largest batch of paths delivered to the event loop at once
     **kwargs
 ):
-    "Async `fd_iter`: yield `FileEntry` paths as they are found; early exit stops the walk."
-    rt = _fs_path(root)
+    "Async `fd_iter`: yield absolute Paths; early exit stops the walk."
+    rt = Path(root).expanduser().absolute()
+    base = _path_base(rt, kwargs.get('follow_links', False))
     async with aclosing(_abatches(_core.find_iter_async, batch_max, rt, pattern,
         *_walk_args(**kwargs), files, dirs)) as batches:
         async for paths in batches:
-            for p in _fe(paths, rt): yield p
+            for p in paths: yield base/p
 
 
 
@@ -267,8 +251,8 @@ def _cap_rows(rows, n):
     return res, False
 
 
-def _mk_results(cls, items, capped, timed_out):
-    res = cls(items)
+def _mk_results(cls, items, capped, timed_out, **kwargs):
+    res = cls(items, **kwargs)
     if capped: res.stop_reason = "max_results"
     elif timed_out: res.stop_reason = "timeout"
     return res
@@ -276,15 +260,15 @@ def _mk_results(cls, items, capped, timed_out):
 
 def _paths_reduce(rows, root, max_results, timed_out=False):
     "Unique matched paths as `PathResults` from rows with `kind`/`path`, capped at `max_results`"
-    seen,res,capped,er = set(),[],False,_entry_root(root)
+    seen,res,capped = set(),[],False
     for row in rows:
         if row.kind != "match" or row.path in seen: continue
         if max_results is not None and len(res) == max_results:
             capped = True
             break
         seen.add(row.path)
-        res.append(FileEntry(row.path, er))
-    return _mk_results(PathResults, res, capped, timed_out)
+        res.append(row.path)
+    return _mk_results(PathResults, res, capped, timed_out, root=_path_base(Path(root).resolve()))
 
 def _rg_post(rows, paths, count, max_results, timed_out, root):
     "Reduce collected rows to the requested `rg`/`rga` result form"
@@ -324,8 +308,8 @@ def rg(
     if summary:
         rows,timed_out = _core.block_search(*args, timeout_ms)
         return _block_post(rows, max_results, before_context, after_context, timed_out, maxlen, lnhashs)
-    if count: return sum(len(row.matches) for row in _core.rg_iter(*args) if row.kind == "match")
-    if paths and timeout_ms is None: return _paths_reduce(_core.rg_iter(*args), rt, max_results)
+    if count: return sum(len(row.matches) for row in _core.rg_iter(*args, False) if row.kind == "match")
+    if paths and timeout_ms is None: return _paths_reduce(_core.rg_iter(*args, False), rt, max_results)
     rows, timed_out = _core.rg(*args, lnhashs, timeout_ms)
     return _rg_post(rows, paths, False, max_results, timed_out, rt)
 

{rgapi-0.1.26 → rgapi-0.1.27}/python/rgapi/nb.py

@@ -63,7 +63,7 @@ def search_nb(
     "Search one `.ipynb` file's cell sources, returning matched cells."
     disp = _display_path(path if display_path is None else display_path)
     rows = _core.nb_search_file(pattern, _fs_path(path), disp, case_sensitive=case_sensitive,
-        smart_case=smart_case, cell_context=cell_context)
+        smart_case=smart_case, cell_context=cell_context, multiline=False)
     res = NbResults(_rows_to_cells(rows, maxlen))
     res.sort(key=lambda c: c.cell_index)
     return res

{rgapi-0.1.26 → rgapi-0.1.27}/python/rgapi/skill.py

@@ -12,9 +12,11 @@ For orientation, start with `rg(summary=True)`; use line-level results where nee
 
 ## Result fields and display
 
-`FileEntry` is a slash-separated relative-path `str` with lazy `size`/`mtime`/`is_dir`/`stat`. Path lists render as ls-style tables capped at `MAX_REPR`; `str(res)`/`list(res)` yield plain paths. Unfollowed symlinks remain, marked `l`; `link_target` is their target or `None` for non-links. `ls(hidden=True)` corresponds to `ls -a`.
+Discovery and `paths=True` results contain absolute `pathlib.Path` objects. Use them directly: `p.read_text()`, `p.name`, `p.stat().st_size`, `p.stat().st_mtime`, and `p.is_dir()`. `.stat()` follows links; `.lstat()` inspects the link itself. Discovery returns symlinks themselves, including root links and dangling links, unless `follow_links=True`. `.readlink()` returns a link's target. `ls(hidden=True)` corresponds to `ls -a`.
 
-Search rows provide `asdict()`. All paths are relative to the search root:
+`PathResults` displays root-relative names in ls-style tables capped at `MAX_REPR`. `str(res)` returns one relative name per line; `list(res)` contains absolute Paths. Slices retain the display root and completion status. `show_target=True` appends link targets in the listing.
+
+Search rows provide `asdict()`. Their `path` fields remain root-relative string labels. Content searches follow explicitly named root links:
 
 | Row | Location | Content/matches | `kind` |
 |---|---|---|---|

{rgapi-0.1.26 → rgapi-0.1.27}/src/block.rs

@@ -97,7 +97,7 @@ fn block_entry(
     let Some(ft) = dent.file_type() else { return Ok(Vec::new()); };
     if !ft.is_file() { return Ok(Vec::new()); }
     let rel = rel_path(root, path);
-    if !filters.path_allowed(&rel) { return Ok(Vec::new()); }
+    if !filters.path_allowed(Path::new(&rel)) { return Ok(Vec::new()); }
     let bytes = match std::fs::read(path) { Ok(bytes) => bytes, Err(_) => return Ok(Vec::new()) };
     process_file(rel, &bytes, matcher, before_context, after_context)
 }

{rgapi-0.1.26 → rgapi-0.1.27}/src/nb.rs

@@ -174,7 +174,7 @@ fn nb_entry(
     let Some(ft) = dent.file_type() else { return Ok(Vec::new()); };
     if !ft.is_file() { return Ok(Vec::new()); }
     let rel = rel_path(root, path);
-    if !filters.path_allowed(&rel) { return Ok(Vec::new()); }
+    if !filters.path_allowed(Path::new(&rel)) { return Ok(Vec::new()); }
     let bytes = match std::fs::read(path) { Ok(b) => b, Err(_) => return Ok(Vec::new()) };
     process_file(rel, &bytes, matcher, cell_context, multiline)
 }