pseek 3.1.2__tar.gz → 3.2.0__tar.gz

{pseek-3.1.2 → pseek-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pseek
-Version: 3.1.2
+Version: 3.2.0
 Summary: Pseek is a Python CLI toolkit to search files, folders, and text
 Author: Groot
 License-Expression: MIT
@@ -112,12 +112,14 @@ psk -- --path
 | `--re-include`, `--re-exclude` | Limit search results to specific directories or files with regex |
 | `--word` | Match the whole word only (except when `--expr` is enabled, in which case you can make it match whole word by putting `w` before term: `w"foo"`) |
 | `--expr` | Enable boolean query expressions. Example: `r"foo.*bar" and ("bar" or "baz") and not "qux"`. Prefixes: `r=regex`, `c=case-sensitive`, `w=whole-word`, `f=fuzzy` |
+| `--context` | Show N context lines before and after matches, or use N:M to specify before:after |
+| `--depth` | Limit directory traversal to given depth range. By default, there is no limit on search depth |
 | `--timeout` | Stop the search after the specified number of seconds |
 | `--fuzzy` | Enable fuzzy search (Highlighting and counting matches are disabled in this mode if `--word` is not enabled to prevent the program from slowing down). except when `--expr` is enabled, in which case you can make it fuzzy by putting `f` before term: `f"foo"` |
 | `--fuzzy-level` | Fuzzy matching threshold (0-99). Higher values require closer matches (default: `80`) |
 | `--size` | Limit results based on the size of files |
 | `--archive` | Enable search within archive files (e.g. `zip`, `rar`, `7z`, `gz`, `bz2`, `xz`, `tar`, `tar.gz`, `tar.bz2`, `tar.xz`) |
-| `--depth` | Maximum nested archive depth. Example: 2 allows searching up to two archive levels |
+| `--arc-depth` | Limit nested archive to given depth range. By default, there is no limit |
 | `--arc-ext`, `--arc-exc-ext` | Filter by file extension inside archive files |
 | `--arc-include`, `--arc-exclude` | Limit search results to specific set of directories or files inside archive files |
 | `--arc-size` | Limit results based on the size of files in the archive |
@@ -176,7 +178,7 @@ Example:
 psk "hello world"
 ```
 
-**Note:** To use case-sensitive, whole-word matching, regular expression search, and fuzzy search when `--expr` is enabled, we can use [expression prefixes](#expression-prefixes).
+> **Note:** To use case-sensitive, whole-word matching, regular expression search, and fuzzy search when `--expr` is enabled, we can use [expression prefixes](#expression-prefixes).
 
 ### Case Sensitive Search
 
@@ -364,7 +366,51 @@ simultaneously.
 
 Allowed modes: `r`, `c`, `w`, `f`, `rc`, `cr`, `cw`, `wc`, `cf`, `fc`, `wf`, `fw`, `cwf`, `cfw`, `wcf`, `wfc`, `fcw`, `fwc`
 
-**Note:** Whole word matching and regex matching cannot be used at the same time, because we can use `\b` in regex to enable whole word matching: `r"\btext\b"`
+> **Note:** Whole word matching and regex matching cannot be used at the same time, because we can use `\b` in regex to enable whole word matching: `r"\btext\b"`
+
+## Context
+
+Show context lines around each match. The value is specified as `BEFORE:AFTER`:
+
+```bash
+--context 2       # 2 lines before and after
+--context 2:0     # 2 lines before, none after
+--context 0:2     # none before, 2 lines after
+--context 2:5     # 2 lines before, 5 lines after
+--context 2:      # 2 lines before, none after
+--context :2      # none before, 2 lines after
+--context 0       # matching lines only
+```
+
+Nearby matches whose context ranges overlap or directly touch are combined into a single group.
+
+## Depth
+
+Controls how deep the search goes inside directories.
+
+A depth of `0` means that only base path's immediate contents are searched; subdirectories are not entered.
+
+```text
+project/                  ← base directory
+├── file.txt              ← depth 0
+├── folder1/              ← depth 0
+│   ├── file.txt          ← depth 1
+│   └── folder2/          ← depth 1
+│       └── file.txt      ← depth 2
+```
+
+`--depth` can be specified multiple times to search non-contiguous depth ranges:
+
+```bash
+--depth 0              # Direct contents only
+--depth 1              # One level inside
+--depth 2:4            # Depths 2 through 4
+--depth 2 --depth 5:7  # Depths 2 and 5 through 7
+--depth :2             # Depths 0 through 2
+--depth 3:             # Depth 3 and deeper
+```
+
+If `--depth` is not specified, the search has no depth limit.
 
 ## Extension Filters
 
@@ -402,7 +448,7 @@ psk TODO \
 
 Skip those paths.
 
-**Note:** The include and exclude paths will be combined with path argument.
+> **Note:** The include and exclude paths will be combined with path argument.
 
 ## Regex Path Filters
 
@@ -455,7 +501,7 @@ psk config \
 
 Files between `1 MiB` and `10 MiB` will not match.
 
-**Note:** Directory sizes are not calculated recursively. When `--size` is used, directories are automatically excluded from the search results.
+> **Note:** Directory sizes are not calculated recursively. When `--size` is used, directories are automatically excluded from the search results.
 
 ## Archive Search
 
@@ -487,15 +533,24 @@ backup.zip::source.7z::notes.txt
 
 ### Archive Depth
 
-Limit recursion depth:
+The concept of depth in archive is different from `--depth`. Depth in archive is calculated based on nested archives. Each archive that is inside another archive counts as one level of depth.
+
+| Syntax | Meaning                                                  |
+| ------ | -------------------------------------------------------- |
+| `2`    | exactly `2nd` depth                                      |
+| `:2`   | `2nd` depth or lower                                     |
+| `2:`   | `2nd` depth or higher                                    |
+| `2:4`  | between `2` and `4` (Both range boundaries are included) |
+
+`--arc-depth` can be specified multiple times:
 
 ```bash
-psk TODO --archive --depth 2
+psk TODO --archive --arc-depth :2 --arc-depth 5:
 ```
 
-Meaning `archive level 1` and `archive level 2` will be searched. Deeper levels will be skipped.
+Meaning `archive level 3` and `archive level 4` won't be searched.
 
-**Note:** `--depth 0` means perform the search only within this current archive and don't enter nested archives.
+> **Note:** `--arc-depth 0` means perform the search only within this current archive and don't enter nested archives.
 
 ## Archive Filters
 
@@ -535,7 +590,7 @@ This works exactly like the [--size](#size-filtering) option.
 psk TODO --archive --arc-size 10m:40m
 ```
 
-**Note:** Archive directory sizes are usually reported as zero by archive formats, so directory search is disabled if this filter is enabled to avoid incorrect results.
+> **Note:** Archive directory sizes are usually reported as zero by archive formats, so directory search is disabled if this filter is enabled to avoid incorrect results.
 
 ## RAR Backend
 

{pseek-3.1.2 → pseek-3.2.0}/README.md

@@ -83,12 +83,14 @@ psk -- --path
 | `--re-include`, `--re-exclude` | Limit search results to specific directories or files with regex |
 | `--word` | Match the whole word only (except when `--expr` is enabled, in which case you can make it match whole word by putting `w` before term: `w"foo"`) |
 | `--expr` | Enable boolean query expressions. Example: `r"foo.*bar" and ("bar" or "baz") and not "qux"`. Prefixes: `r=regex`, `c=case-sensitive`, `w=whole-word`, `f=fuzzy` |
+| `--context` | Show N context lines before and after matches, or use N:M to specify before:after |
+| `--depth` | Limit directory traversal to given depth range. By default, there is no limit on search depth |
 | `--timeout` | Stop the search after the specified number of seconds |
 | `--fuzzy` | Enable fuzzy search (Highlighting and counting matches are disabled in this mode if `--word` is not enabled to prevent the program from slowing down). except when `--expr` is enabled, in which case you can make it fuzzy by putting `f` before term: `f"foo"` |
 | `--fuzzy-level` | Fuzzy matching threshold (0-99). Higher values require closer matches (default: `80`) |
 | `--size` | Limit results based on the size of files |
 | `--archive` | Enable search within archive files (e.g. `zip`, `rar`, `7z`, `gz`, `bz2`, `xz`, `tar`, `tar.gz`, `tar.bz2`, `tar.xz`) |
-| `--depth` | Maximum nested archive depth. Example: 2 allows searching up to two archive levels |
+| `--arc-depth` | Limit nested archive to given depth range. By default, there is no limit |
 | `--arc-ext`, `--arc-exc-ext` | Filter by file extension inside archive files |
 | `--arc-include`, `--arc-exclude` | Limit search results to specific set of directories or files inside archive files |
 | `--arc-size` | Limit results based on the size of files in the archive |
@@ -147,7 +149,7 @@ Example:
 psk "hello world"
 ```
 
-**Note:** To use case-sensitive, whole-word matching, regular expression search, and fuzzy search when `--expr` is enabled, we can use [expression prefixes](#expression-prefixes).
+> **Note:** To use case-sensitive, whole-word matching, regular expression search, and fuzzy search when `--expr` is enabled, we can use [expression prefixes](#expression-prefixes).
 
 ### Case Sensitive Search
 
@@ -335,7 +337,51 @@ simultaneously.
 
 Allowed modes: `r`, `c`, `w`, `f`, `rc`, `cr`, `cw`, `wc`, `cf`, `fc`, `wf`, `fw`, `cwf`, `cfw`, `wcf`, `wfc`, `fcw`, `fwc`
 
-**Note:** Whole word matching and regex matching cannot be used at the same time, because we can use `\b` in regex to enable whole word matching: `r"\btext\b"`
+> **Note:** Whole word matching and regex matching cannot be used at the same time, because we can use `\b` in regex to enable whole word matching: `r"\btext\b"`
+
+## Context
+
+Show context lines around each match. The value is specified as `BEFORE:AFTER`:
+
+```bash
+--context 2       # 2 lines before and after
+--context 2:0     # 2 lines before, none after
+--context 0:2     # none before, 2 lines after
+--context 2:5     # 2 lines before, 5 lines after
+--context 2:      # 2 lines before, none after
+--context :2      # none before, 2 lines after
+--context 0       # matching lines only
+```
+
+Nearby matches whose context ranges overlap or directly touch are combined into a single group.
+
+## Depth
+
+Controls how deep the search goes inside directories.
+
+A depth of `0` means that only base path's immediate contents are searched; subdirectories are not entered.
+
+```text
+project/                  ← base directory
+├── file.txt              ← depth 0
+├── folder1/              ← depth 0
+│   ├── file.txt          ← depth 1
+│   └── folder2/          ← depth 1
+│       └── file.txt      ← depth 2
+```
+
+`--depth` can be specified multiple times to search non-contiguous depth ranges:
+
+```bash
+--depth 0              # Direct contents only
+--depth 1              # One level inside
+--depth 2:4            # Depths 2 through 4
+--depth 2 --depth 5:7  # Depths 2 and 5 through 7
+--depth :2             # Depths 0 through 2
+--depth 3:             # Depth 3 and deeper
+```
+
+If `--depth` is not specified, the search has no depth limit.
 
 ## Extension Filters
 
@@ -373,7 +419,7 @@ psk TODO \
 
 Skip those paths.
 
-**Note:** The include and exclude paths will be combined with path argument.
+> **Note:** The include and exclude paths will be combined with path argument.
 
 ## Regex Path Filters
 
@@ -426,7 +472,7 @@ psk config \
 
 Files between `1 MiB` and `10 MiB` will not match.
 
-**Note:** Directory sizes are not calculated recursively. When `--size` is used, directories are automatically excluded from the search results.
+> **Note:** Directory sizes are not calculated recursively. When `--size` is used, directories are automatically excluded from the search results.
 
 ## Archive Search
 
@@ -458,15 +504,24 @@ backup.zip::source.7z::notes.txt
 
 ### Archive Depth
 
-Limit recursion depth:
+The concept of depth in archive is different from `--depth`. Depth in archive is calculated based on nested archives. Each archive that is inside another archive counts as one level of depth.
+
+| Syntax | Meaning                                                  |
+| ------ | -------------------------------------------------------- |
+| `2`    | exactly `2nd` depth                                      |
+| `:2`   | `2nd` depth or lower                                     |
+| `2:`   | `2nd` depth or higher                                    |
+| `2:4`  | between `2` and `4` (Both range boundaries are included) |
+
+`--arc-depth` can be specified multiple times:
 
 ```bash
-psk TODO --archive --depth 2
+psk TODO --archive --arc-depth :2 --arc-depth 5:
 ```
 
-Meaning `archive level 1` and `archive level 2` will be searched. Deeper levels will be skipped.
+Meaning `archive level 3` and `archive level 4` won't be searched.
 
-**Note:** `--depth 0` means perform the search only within this current archive and don't enter nested archives.
+> **Note:** `--arc-depth 0` means perform the search only within this current archive and don't enter nested archives.
 
 ## Archive Filters
 
@@ -506,7 +561,7 @@ This works exactly like the [--size](#size-filtering) option.
 psk TODO --archive --arc-size 10m:40m
 ```
 
-**Note:** Archive directory sizes are usually reported as zero by archive formats, so directory search is disabled if this filter is enabled to avoid incorrect results.
+> **Note:** Archive directory sizes are usually reported as zero by archive formats, so directory search is disabled if this filter is enabled to avoid incorrect results.
 
 ## RAR Backend
 

{pseek-3.1.2 → pseek-3.2.0}/pseek/archive.py

@@ -39,7 +39,7 @@ def archive_should_skip(path_info: Path, config, p_size: float, file_ext, is_dir
     return False
 
 
-def extract_names_from_archive(file_path: Path, config, depth: int | None = None,
+def extract_names_from_archive(file_path: Path, config, depth: int = -1,
                                file_bytes: bytes | None = None, parent_label: list[str] | None = None):
     """
     Recursively extract files and directories name from archive files.
@@ -57,8 +57,7 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
 
     file_ext = get_path_suffix(file_path)
     label_prefix = [*parent_label, str(file_path)] if parent_label is not None else []
-    if depth is None:
-            depth = config.depth
+    new_depth = depth + 1
 
     try:
         # Decide the stream source: from disk or memory
@@ -72,8 +71,6 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
                     name = Path(info.filename)
                     new_path_ext = get_path_suffix(name)
                     is_dir = info.is_dir()
-                    # At each recursion, subtract 1 from depth if it's set
-                    new_depth = None if depth is None else depth - 1
 
                     if not archive_should_skip(
                             name,
@@ -82,10 +79,11 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
                             new_path_ext,
                             is_dir
                     ):
-                        yield label_prefix, name, is_dir
+                        if any(mi <= new_depth <= ma for mi, ma in config.arc_depth):
+                            yield label_prefix, name, is_dir
 
                         # Check if this is a nested archive
-                        if new_path_ext in ARCHIVE_EXTS[:-3] and (new_depth is None or new_depth >= 0):
+                        if new_path_ext in ARCHIVE_EXTS[:-3] and any(new_depth < d[1] for d in config.arc_depth):
                             yield from extract_names_from_archive(
                                 name,
                                 config,
@@ -100,7 +98,6 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
                     name = Path(info.filename)
                     new_path_ext = get_path_suffix(name)
                     is_dir = info.is_directory
-                    new_depth = None if depth is None else depth - 1
 
                     if not archive_should_skip(
                             name,
@@ -109,9 +106,10 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
                             new_path_ext,
                             is_dir
                     ):
-                        yield label_prefix, name, is_dir
+                        if any(mi <= new_depth <= ma for mi, ma in config.arc_depth):
+                            yield label_prefix, name, is_dir
 
-                        if new_path_ext in ARCHIVE_EXTS[:-3] and (new_depth is None or new_depth >= 0):
+                        if new_path_ext in ARCHIVE_EXTS[:-3] and any(new_depth < d[1] for d in config.arc_depth):
                             file_data = z.read([info.filename]).get(info.filename)
                             if file_data is None:
                                 continue
@@ -138,7 +136,6 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
                     name = Path(member.name)
                     new_path_ext = get_path_suffix(name)
                     is_dir = member.isdir()
-                    new_depth = None if depth is None else depth - 1
 
                     if not archive_should_skip(
                             name,
@@ -147,9 +144,10 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
                             new_path_ext,
                             is_dir
                     ):
-                        yield label_prefix, name, is_dir
+                        if any(mi <= new_depth <= ma for mi, ma in config.arc_depth):
+                            yield label_prefix, name, is_dir
 
-                        if new_path_ext in ARCHIVE_EXTS[:-3] and (new_depth is None or new_depth >= 0):
+                        if new_path_ext in ARCHIVE_EXTS[:-3] and any(new_depth < d[1] for d in config.arc_depth):
                             f = tf.extractfile(member)
                             if f is None:
                                 continue
@@ -165,7 +163,7 @@ def extract_names_from_archive(file_path: Path, config, depth: int | None = None
         return  # silently skip invalid or unreadable archives
 
 
-def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
+def extract_text_from_archive(file_path: Path, config, depth: int = -1,
                               file_bytes: bytes | None = None, parent_label: list[str] | None = None):
     """
     Recursively extract (path_label, text_content) from any archive file.
@@ -183,8 +181,7 @@ def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
 
     file_ext = get_path_suffix(file_path)
     label_prefix = [*parent_label, str(file_path)] if parent_label is not None else []
-    if depth is None:
-            depth = config.depth
+    new_depth = depth + 1
 
     try:
         # Decide the stream source: from disk or memory
@@ -199,8 +196,6 @@ def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
                         continue
                     
                     file_name = Path(info.filename)
-                    # At each recursion, subtract 1 from depth if it's set
-                    new_depth = None if depth is None else depth - 1
                     new_path_ext = get_path_suffix(file_name)
                     
                     if archive_should_skip(
@@ -222,9 +217,9 @@ def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
 
                     # Check if this is a nested archive
                     if new_path_ext in ARCHIVE_EXTS:
-                        if (new_depth is None or new_depth >= 0):
+                        if any(new_depth < d[1] for d in config.arc_depth):
                             yield from extract_text_from_archive(file_name, config, new_depth, data, label_prefix)
-                    else:
+                    elif any(mi <= new_depth <= ma for mi, ma in config.arc_depth):
                         yield [*label_prefix, str(file_name)], data
         # Handle 7Z archives
         elif file_ext == '7z':
@@ -238,7 +233,6 @@ def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
                         continue
 
                     file_name = Path(info.filename)
-                    new_depth = None if depth is None else depth - 1
                     new_path_ext = get_path_suffix(file_name)
                     
                     if archive_should_skip(
@@ -255,9 +249,9 @@ def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
                     
                     data = head + file_data.read()
                     if new_path_ext in ARCHIVE_EXTS:
-                        if (new_depth is None or new_depth >= 0):
+                        if any(new_depth < d[1] for d in config.arc_depth):
                             yield from extract_text_from_archive(file_name, config, new_depth, data, label_prefix)
-                    else:
+                    elif any(mi <= new_depth <= ma for mi, ma in config.arc_depth):
                         yield [*label_prefix, str(file_name)], data
         # Handle TAR and compressed TAR formats
         elif file_ext in ('tar', 'tar.gz', 'tar.bz2', 'tar.xz'):
@@ -278,7 +272,6 @@ def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
                         continue
 
                     file_name = Path(member.name)
-                    new_depth = None if depth is None else depth - 1
                     new_path_ext = get_path_suffix(file_name)
                     
                     if archive_should_skip(
@@ -295,9 +288,9 @@ def extract_text_from_archive(file_path: Path, config, depth: int | None = None,
 
                     data = head + f.read()
                     if new_path_ext in ARCHIVE_EXTS:
-                        if (new_depth is None or new_depth >= 0):
+                        if any(new_depth < d[1] for d in config.arc_depth):
                             yield from extract_text_from_archive(file_name, config, new_depth, data, label_prefix)
-                    else:
+                    elif any(mi <= new_depth <= ma for mi, ma in config.arc_depth):
                         yield [*label_prefix, str(file_name)], data
         # Handle single compressed files like .gz, .bz2, .xz
         elif file_ext in ARCHIVE_EXTS[-3:]:

{pseek-3.1.2 → pseek-3.2.0}/pseek/cli.py

@@ -11,6 +11,10 @@ BACKEND_PATH = Path(__file__).parent / "RARBackend"
 
 def merge_matches(matches: list[tuple[int, int]]):
     """Merge overlapping matches (for example, if one match was inside another match)"""
+
+    # sort by start position
+    matches.sort()
+
     merged = []
     for start, end in matches:
         if not merged or start > merged[-1][1]:  # No overlap
@@ -32,14 +36,14 @@ def build_highlight(text, matches):
 
     for start, end in matches:
         parts.append(text[last:start])
-        parts.append(click.style(text[start:end], fg='green'))
+        parts.append(click.style(text[start:end], fg='red', bold=True))
         last = end
     parts.append(text[last:])
 
     return ''.join(parts)
 
 
-def echo(results: dict):
+def echo(results: dict, context: bool):
     """Display results with a specific format and color scheme"""
     for match_type, datas in results.items():
         if datas:
@@ -62,26 +66,31 @@ def echo(results: dict):
                             )]
                         )
                     )
-                    
-                    # Print file lines
-                    for line in data.lines:
-                        matches = merge_matches(line.matches)
-                        # Keep the original count so overlapping matches are still counted separately
-                        count = len(line.matches)
-                        
-                        # Show a note if the pattern repeats 3 or more times
-                        count_query = f' ({count} matches)' if count >= 3 else ''
-                        
-                        prefix = click.style(
-                            f"Line {line.number}{count_query}: ",
-                            fg="magenta",
-                        )
-                        output_line = prefix + build_highlight(line.text, matches)
 
-                        click.echo(output_line)
-                    
+                    counter = 0
+                    for group in data.groups:
+                        if any(context):
+                            if counter != 0:
+                                print('---')
+                            else:
+                                counter = 1
+
+                        for line in group.lines:
+                            if line.number in group.matching_lines:
+                                matches = merge_matches(line.matches)
+
+                            prefix = click.style(
+                                f'{line.number}' + (':' if line.number in group.matching_lines else '-'),
+                                fg='magenta'
+                            )
+                            output_line = prefix + (build_highlight(line.text, matches) \
+                                if line.number in group.matching_lines \
+                                else line.text)
+
+                            print(output_line)
+
                     # Print a blank line to separate results
-                    if data.lines:
+                    if data.groups:
                         print()
                 else:  # Print a file or directory match, including archive paths
                     matches = merge_matches(data.matches)
@@ -93,13 +102,13 @@ def echo(results: dict):
                             matches
                         )
 
-                        click.echo(
+                        print(
                             separator.join(
                                 [data.path, *data.virtual_path[0:-1], virtual_file_name]
                             )
                         )
                     else:
-                        click.echo(
+                        print(
                             build_highlight(data.path, matches)
                         )
 
@@ -120,11 +129,11 @@ def echo_stats(config, results, metrics, elapsed_time=None):
     if config.content:
         click.echo(INDENT + f'Files with matched content: {len(results["content"]):,}')
         
-        lines_matched = sum(len(file.lines) for file in results["content"])
+        lines_matched = sum(len(group.matching_lines) for file in results["content"] for group in file.groups)
         matches = sum(
             len(line.matches)
             for file in results["content"]
-            for line in file.lines
+            for group in file.groups for line in group.lines
         )
         
         if lines_matched:
@@ -305,7 +314,7 @@ def check_rar_backend(archive_enabled: bool, tool_path: str, backend: str):
 @click.option('-d', '--directory', is_flag=True, help='Search only in directory names.')
 @click.option('-c', '--content', is_flag=True, help='Search within file contents.')
 # Additional options
-@click.option('-C', '--case-sensitive', is_flag=True,
+@click.option('-s', '--case-sensitive', is_flag=True,
               help='Make the search case-sensitive '
                    '(except when --expr is enabled, '
                    'in which case you can make it case sensitive by putting c before term: c"foo")')
@@ -320,13 +329,17 @@ def check_rar_backend(archive_enabled: bool, tool_path: str, backend: str):
 @click.option('--expr', is_flag=True,
               help='Enable boolean query expressions. Example: r"foo.*bar" and ("bar" or "baz") and not "qux". '
                    'Prefixes: r=regex, c=case-sensitive, w=whole-word, f=fuzzy.')
-@click.option('--timeout', type=click.FloatRange(min=0, min_open=True),
-              help='Stop the search after the specified number of seconds.')
 @click.option('--fuzzy', is_flag=True, help='Enable fuzzy search (approximate matching). '
               'except when --expr is enabled, '
               'in which case you can make it fuzzy by putting f before term: f"foo"')
 @click.option('--fuzzy-level', type=click.IntRange(1, 99), default=80, show_default=True,
               help='Fuzzy matching threshold (1-99). Higher values require closer matches.')
+@click.option('-C', '--context', help='Show N context lines before and after matches, '
+              'or use N:M to specify before:after.')
+@click.option('--depth', multiple=True, help='Limit directory traversal to given depth range. '
+              'By default, there is no limit on search depth.')
+@click.option('--timeout', type=click.FloatRange(min=0, min_open=True),
+              help='Stop the search after the specified number of seconds.')
 # Extension filters
 @click.option('--ext', multiple=True, type=click.STRING,
               help='Include files with these extensions. Example: --ext py --ext js')
@@ -346,8 +359,8 @@ def check_rar_backend(archive_enabled: bool, tool_path: str, backend: str):
 # Archive options
 @click.option('--archive', is_flag=True,
               help='Enable search within archive files (e.g. zip, rar, 7z, gz, bz2, xz, tar, tar.gz, tar.bz2, tar.xz)')
-@click.option('--depth', type=click.IntRange(min=0), show_default=True,
-              help='Maximum nested archive depth. Example: 2 allows searching up to two archive levels.')
+@click.option('--arc-depth', multiple=True,
+              help='Limit nested archive to given depth range. By default, there is no limit.')
 @click.option('--arc-ext', multiple=True, type=click.STRING,
               help='Include files with these extensions inside archive files. Example: --arc-ext py --arc-ext js')
 @click.option('--arc-exc-ext', multiple=True, type=click.STRING,
@@ -363,7 +376,7 @@ def check_rar_backend(archive_enabled: bool, tool_path: str, backend: str):
 # Output option
 @click.option('-a', '--absolute-path', is_flag=True, help='Display full paths for results.')
 @click.option('--paths-only', is_flag=True, help='Only show matching file paths for content search.')
-@click.option('-s', '--stats', is_flag=True,
+@click.option('-S', '--stats', is_flag=True,
               help='Show search statistics including result counts and search time.')
 def search(**kwargs):
     """Search for files, directories, and file content based on the query."""
@@ -389,7 +402,7 @@ def search(**kwargs):
         results, metrics, elapsed, timed_out = search_with_timeout(config)
 
         # Even if the search timed out, display all results found before termination.
-        echo(results)
+        echo(results, config.context)
 
         if timed_out:
             click.secho(
@@ -404,7 +417,7 @@ def search(**kwargs):
         results, metrics = seek(config)
         elapsed = time.perf_counter() - start
         
-        echo(results)
+        echo(results, config.context)
         if config.stats:
             echo_stats(config, results, metrics, elapsed)
 

{pseek-3.1.2 → pseek-3.2.0}/pseek/parser.py

@@ -236,7 +236,5 @@ def find_matches(expr: ExprNode, text: str, num: int = 0) -> list[tuple[int, int
             collect_matches(node.right)
 
     collect_matches(expr)
-    # sort by start position
-    matches.sort()
     
     return matches

{pseek-3.1.2 → pseek-3.2.0}/pseek/searcher.py

@@ -1,10 +1,10 @@
 import mmap, os
 from pathlib import Path
-from collections import defaultdict
+from collections import defaultdict, deque
 from .utils import get_path_suffix, is_binary
 from .parser import parse_query_expression, TermNode, find_matches
 from .archive import ARCHIVE_EXTS, extract_names_from_archive, extract_text_from_archive
-from .structs import FileDirResult, ContentResult, LineMatch
+from .structs import FileDirResult, ContentResult, MatchGroup, Line
 
 
 def should_skip(config, p: Path, file_ext: str, p_size: int) -> bool:
@@ -88,7 +88,7 @@ def search_file_and_dir(config, matches: dict, pattern, p: Path,
                 elif is_dir:
                     add_metric(metrics, result_queue, 'directories_scanned', full_virtual_path)
                 
-                # We cannot use "full_virtual_path[-1]" because it may be limited by --depth
+                # We cannot use "full_virtual_path[-1]" because it may be limited by --arc-depth
                 # and may not enter the archive at all to scan inside it
                 if len(full_virtual_path) >= 3 and get_path_suffix(full_virtual_path[-2]) in ARCHIVE_EXTS[:-3]:
                     add_metric(metrics, result_queue, 'archives_scanned', full_virtual_path)
@@ -129,13 +129,78 @@ def content_contains(content, binary_pattern) -> bool:
     return binary_pattern.search(content) is not None
 
 
+class ContextCollector:
+    """
+    Collects matching lines and their surrounding context into
+    non-overlapping MatchGroups in a single pass.
+    """
+
+    def __init__(self, context: tuple[int, int]):
+        # Lines immediately preceding the current search position
+        self.before_buffer = deque(maxlen=context[0])
+        # Lines after the latest match, kept until the group is finalized
+        # or another match extends the same group
+        self.after_buffer = []
+        self.before = context[0]
+        self.after = context[1]
+        self.lines = []
+        self.matching_lines = set()
+        self.groups = []
+
+    def _finish_group(self):
+        self.lines.extend(self.after_buffer[:self.after])
+        self.groups.append(
+            MatchGroup(
+                self.lines,
+                self.matching_lines
+            )
+        )
+
+        self.before_buffer.clear()
+        # Preserve the latest lines as before-context for the next group.
+        self.before_buffer.extend(self.after_buffer)
+        self.after_buffer.clear()
+        # Because of ownership, we can't use .clear() here.
+        # Using it could also clear values inside MatchGroup.
+        self.lines = []
+        self.matching_lines = set()
+
+    def process(self, line: Line, matched: bool):
+        if matched:
+            if self.matching_lines:
+                self.lines.extend(self.after_buffer)
+                self.lines.append(line)
+
+                self.after_buffer.clear()
+            else:
+                self.lines.extend(self.before_buffer)
+                self.lines.append(line)
+
+            self.matching_lines.add(line.number)
+        else:
+            if self.matching_lines:
+                self.after_buffer.append(line)
+
+                # Keep groups together while their context ranges overlap or touch
+                if len(self.after_buffer) > self.after + self.before:
+                    self._finish_group()
+            else:
+                self.before_buffer.append(line)
+
+    def finish(self) -> list[MatchGroup]:
+        if self.matching_lines:
+            self._finish_group()
+
+        return self.groups
+
+
 def search_content(config, matches: dict, pattern, binary_pattern,
                    p: Path, p_ext: str, metrics, result_queue):
     """Search within the contents of system files and files inside archive files"""
 
     path_str = str(p)
 
-    # First, check if the file is an archive, extract it from the archive and perform a search
+    # Search files content inside archives separately.
     if config.archive and p_ext in ARCHIVE_EXTS:
         for virtual_path, content in extract_text_from_archive(p, config):
             if config.stats:
@@ -161,12 +226,11 @@ def search_content(config, matches: dict, pattern, binary_pattern,
             except UnicodeDecodeError:
                 continue
 
-            lines = []
+            collector = ContextCollector(config.context)
             for num, line in enumerate(decoded_content.splitlines(), 1):
-                if not pattern.evaluate(line):
-                    continue
+                matched = pattern.evaluate(line)
 
-                if config.paths_only:
+                if config.paths_only and matched:
                     add_result(
                         matches,
                         result_queue,
@@ -176,15 +240,17 @@ def search_content(config, matches: dict, pattern, binary_pattern,
                             virtual_path=virtual_path
                         )
                     )
-
                     break
 
-                line_matches = find_matches(pattern, line.strip())
-                lines.append(
-                    LineMatch(num, line.strip(), line_matches)
-                )
+                line_instance = Line(num, line)
+
+                if matched:
+                    line_instance.matches = find_matches(pattern, line)
 
-            if lines:
+                collector.process(line_instance, matched)
+
+            groups = collector.finish()
+            if groups:
                 add_result(
                     matches,
                     result_queue,
@@ -192,14 +258,14 @@ def search_content(config, matches: dict, pattern, binary_pattern,
                     ContentResult(
                         path=path_str,
                         virtual_path=virtual_path,
-                        lines=lines
+                        groups=groups
                     )
                 )
 
         # Skip next block to avoid searching the contents of archive files
         return
 
-    lines = []
+    collector = ContextCollector(config.context)
     # Memory-map the file for efficient access
     with open(p, 'rb') as f, mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
         head = mm[:8192]
@@ -211,72 +277,84 @@ def search_content(config, matches: dict, pattern, binary_pattern,
         # Iterate over each line in the file
         for num, line in enumerate(iter(mm.readline, b''), 1):
             try:
-                # Decode the binary line as UTF-8 and strip whitespace
-                line_decoded = line.decode('utf-8').strip()
+                line_decoded = line.decode('utf-8').rstrip('\r\n')
             except UnicodeDecodeError:
                 # Skip lines that can't be decoded
                 continue
 
-            # If the pattern matches in the decoded line
-            if pattern.evaluate(line_decoded):
-                # Avoid searching through the entire file content if the fast-content flag is True
-                if config.paths_only:
-                    add_result(
-                        matches,
-                        result_queue,
-                        'content',
-                        ContentResult(path=path_str)
-                    )
+            matched = pattern.evaluate(line_decoded)
 
-                    break
-                line_matches = find_matches(pattern, line_decoded)
-                lines.append(
-                    LineMatch(num, line_decoded, line_matches)
+            # Avoid searching through the entire file content if the paths-only flag is True
+            if config.paths_only and matched:
+                add_result(
+                    matches,
+                    result_queue,
+                    'content',
+                    ContentResult(path=path_str)
                 )
+                return
+
+            line_instance = Line(num, line_decoded)
+
+            if matched:
+                line_instance.matches = find_matches(pattern, line_decoded)
 
-    if lines:
+            collector.process(line_instance, matched)
+
+    groups = collector.finish()
+    if groups:
         add_result(
             matches,
             result_queue,
             'content',
             ContentResult(
                 path=path_str,
-                lines=lines
+                groups=groups
             )
         )
 
 
-def walk_logic(path: Path, exclude: set[Path], absolute_path: bool):
+def walk_logic(path: Path, config, depth: int):
     """Recursively walk a directory while pruning excluded subtrees"""
+    
+    new_depth = depth + 1
+
+    try:
+        with os.scandir(path) as entries:
+            for entry in entries:
+                entry_path = Path(entry.path)
+
+                # Excluded directories are pruned before recursion
+                if entry_path in config.exclude:
+                    continue
+
+                if any(mi <= new_depth <= ma for mi, ma in config.depth):
+                    yield entry_path
 
-    with os.scandir(path) as entries:
-        for entry in entries:
-            entry_path = Path(entry.path)
-            if not absolute_path:
                 try:
-                    entry_path_resolved = entry_path.resolve()
+                    is_dir = entry.is_dir(follow_symlinks=False)
                 except OSError:
                     continue
-            else:
-                entry_path_resolved = entry_path
-            
-            if entry_path_resolved in exclude:
-                continue
 
-            if entry.is_dir(follow_symlinks=False):
-                yield from walk_logic(entry_path, exclude, absolute_path)
-            yield entry_path
+                if is_dir and any(new_depth < d[1] for d in config.depth):
+                    yield from walk_logic(entry_path, config, new_depth)
+    except OSError:
+        pass
 
 
-def walk(path: Path, include: set[Path], exclude: set[Path], absolute_path: bool):
+def walk(config):
     """Include paths define traversal roots, avoiding unnecessary traversal 
     of unrelated parts of the tree"""
-    roots = include or {path}
+    roots = config.include or {config.path}
 
     for root in roots:
-        if root.is_dir():
-            yield from walk_logic(root, exclude, absolute_path)
-        yield root
+        depth = len(root.relative_to(config.path).parts) - 1
+
+        if root.is_dir() and not root.is_symlink() and any(depth < d[1] for d in config.depth):
+            yield from walk_logic(root, config, depth)
+
+        if any(mi <= depth <= ma for mi, ma in config.depth):
+            yield root
 
 
 def seek(config, result_queue=None) -> dict:
@@ -292,7 +370,7 @@ def seek(config, result_queue=None) -> dict:
     matches = {'file': [], 'directory': [], 'content': []}
     metrics = defaultdict(set)
 
-    for p in walk(config.path, config.include, config.exclude, config.absolute_path):
+    for p in walk(config):
         try:
             p_ext = get_path_suffix(p)
             p_size = p.stat().st_size

{pseek-3.1.2 → pseek-3.2.0}/pseek/structs.py

@@ -1,5 +1,5 @@
 from click import BadParameter
-import re, sys
+import re
 from pathlib import Path
 from dataclasses import dataclass, field
 from math import isfinite
@@ -27,8 +27,6 @@ def normalize_paths(base_path: Path, paths: tuple[str], param_hint: str, absolut
 
         if absolute_path:
             p = p.resolve()
-        else:
-            p = p.resolve() if param_hint == 'exclude' else p
 
         # Already covered by an existing parent.
         if any(p.is_relative_to(r) for r in result):
@@ -76,42 +74,47 @@ def extract_size(size: str, param_hint: str) -> int:
     return int(number * SUFFIXES[size_suffix])
 
 
-def compile_sizes(sizes: tuple[str], param_hint: str):
-    """Convert sizes list into a list of ranges"""
-    
-    ranges = []
-    
-    for size in sizes:
-        if size.startswith(':'):
-            maximum = extract_size(size[1:], param_hint)
-            ranges.append((0, maximum))
-        elif size.endswith(':'):
-            minimum = extract_size(size[:-1], param_hint)
-            ranges.append((minimum, float('inf')))
-        elif ':' in size:
-            min_str, max_str = size.split(':', 1)
-            
-            if not min_str or not max_str:
-                raise BadParameter(
-                    f'Invalid size range: {size}',
-                    param_hint=f'--{param_hint}',
-                )
-            
-            minimum = extract_size(min_str, param_hint)
-            maximum = extract_size(max_str, param_hint)
+def extract_int(num: str, param_hint: str) -> int:
+    if not num.isdigit():
+        raise BadParameter(
+            f'Invalid value: {num}',
+            param_hint=f'--{param_hint}',
+        )
 
-            if minimum > maximum:
-                raise BadParameter(
-                    'Minimum size cannot be greater than maximum size',
-                    param_hint=f'--{param_hint}',
-                )
-            
-            ranges.append((minimum, maximum))
-        else:
-            exact = extract_size(size, param_hint)
-            ranges.append((exact, exact))
-    
-    return ranges
+    return int(num)
+
+
+def parse_range(data: str, extract_func, param_hint: str) -> tuple[int, int | float]:
+    """Parse str into a range of int or float"""
+
+    if data.startswith(':'):
+        maximum = extract_func(data[1:], param_hint)
+        return (0, maximum)
+    elif data.endswith(':'):
+        minimum = extract_func(data[:-1], param_hint)
+        return (minimum, 0 if param_hint == 'context' else float('inf'))
+    elif ':' in data:
+        min_str, max_str = data.split(':', 1)
+        
+        if not min_str or not max_str:
+            raise BadParameter(
+                f'Invalid range: {data}',
+                param_hint=f'--{param_hint}',
+            )
+        
+        minimum = extract_func(min_str, param_hint)
+        maximum = extract_func(max_str, param_hint)
+
+        if minimum > maximum and param_hint != 'context':
+            raise BadParameter(
+                'Minimum cannot be greater than maximum',
+                param_hint=f'--{param_hint}',
+            )
+        
+        return (minimum, maximum)
+    else:
+        exact = extract_func(data, param_hint)
+        return (exact, exact)
 
 
 @dataclass
@@ -125,6 +128,7 @@ class SearchConfig:
     regex: bool
     word: bool
     expr: bool
+    depth: list[tuple]
     timeout: int | None
     fuzzy: bool
     fuzzy_level: int
@@ -136,7 +140,7 @@ class SearchConfig:
     re_exclude: re.Pattern | None
     size: list[tuple]
     archive: bool
-    depth: int | None
+    arc_depth: list[tuple]
     arc_ext: set[str]
     arc_exc_ext: set[str | None]
     arc_include: set[Path]
@@ -146,6 +150,7 @@ class SearchConfig:
     absolute_path: bool
     paths_only: bool
     stats: bool
+    context: tuple[int]
     
     def __post_init__(self):
         """Post-initialization processing to normalize and validate inputs"""
@@ -188,8 +193,15 @@ class SearchConfig:
         self.re_exclude = compile_regex(self.re_exclude)
         
         # Normalize sizes
-        self.size = compile_sizes(self.size, 'size')
-        self.arc_size = compile_sizes(self.arc_size, 'arc-size')
+        self.size = [parse_range(s, extract_size, 'size') for s in self.size]
+        self.arc_size = [parse_range(s, extract_size, 'arc-size') for s in self.arc_size]
+        
+        # Normalize depth
+        # If depth isn't define, don't impose limit
+        self.depth = [(0, float('inf'))] if not self.depth else [parse_range(d, extract_int, 'depth') for d in self.depth]
+        self.arc_depth = [(0, float('inf'))] if not self.arc_depth else [parse_range(d, extract_int, 'arc-depth') for d in self.arc_depth]
+
+        self.context = parse_range(self.context, extract_int, 'context') if self.context else (0, 0)
 
 
 @dataclass
@@ -204,12 +216,18 @@ class FileDirResult(SearchResult):
 
 
 @dataclass
-class LineMatch:
+class Line:
     number: int
     text: str
     matches: list[tuple[int, int]] = field(default_factory=list)
 
 
+@dataclass
+class MatchGroup:
+    lines: list[Line] = field(default_factory=list)
+    matching_lines: set[int] = field(default_factory=set)
+
+
 @dataclass
 class ContentResult(SearchResult):
-    lines: list[LineMatch] = field(default_factory=list, kw_only=True)
+    groups: list[MatchGroup] = field(default_factory=list, kw_only=True)

{pseek-3.1.2 → pseek-3.2.0}/pseek.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pseek
-Version: 3.1.2
+Version: 3.2.0
 Summary: Pseek is a Python CLI toolkit to search files, folders, and text
 Author: Groot
 License-Expression: MIT
@@ -112,12 +112,14 @@ psk -- --path
 | `--re-include`, `--re-exclude` | Limit search results to specific directories or files with regex |
 | `--word` | Match the whole word only (except when `--expr` is enabled, in which case you can make it match whole word by putting `w` before term: `w"foo"`) |
 | `--expr` | Enable boolean query expressions. Example: `r"foo.*bar" and ("bar" or "baz") and not "qux"`. Prefixes: `r=regex`, `c=case-sensitive`, `w=whole-word`, `f=fuzzy` |
+| `--context` | Show N context lines before and after matches, or use N:M to specify before:after |
+| `--depth` | Limit directory traversal to given depth range. By default, there is no limit on search depth |
 | `--timeout` | Stop the search after the specified number of seconds |
 | `--fuzzy` | Enable fuzzy search (Highlighting and counting matches are disabled in this mode if `--word` is not enabled to prevent the program from slowing down). except when `--expr` is enabled, in which case you can make it fuzzy by putting `f` before term: `f"foo"` |
 | `--fuzzy-level` | Fuzzy matching threshold (0-99). Higher values require closer matches (default: `80`) |
 | `--size` | Limit results based on the size of files |
 | `--archive` | Enable search within archive files (e.g. `zip`, `rar`, `7z`, `gz`, `bz2`, `xz`, `tar`, `tar.gz`, `tar.bz2`, `tar.xz`) |
-| `--depth` | Maximum nested archive depth. Example: 2 allows searching up to two archive levels |
+| `--arc-depth` | Limit nested archive to given depth range. By default, there is no limit |
 | `--arc-ext`, `--arc-exc-ext` | Filter by file extension inside archive files |
 | `--arc-include`, `--arc-exclude` | Limit search results to specific set of directories or files inside archive files |
 | `--arc-size` | Limit results based on the size of files in the archive |
@@ -176,7 +178,7 @@ Example:
 psk "hello world"
 ```
 
-**Note:** To use case-sensitive, whole-word matching, regular expression search, and fuzzy search when `--expr` is enabled, we can use [expression prefixes](#expression-prefixes).
+> **Note:** To use case-sensitive, whole-word matching, regular expression search, and fuzzy search when `--expr` is enabled, we can use [expression prefixes](#expression-prefixes).
 
 ### Case Sensitive Search
 
@@ -364,7 +366,51 @@ simultaneously.
 
 Allowed modes: `r`, `c`, `w`, `f`, `rc`, `cr`, `cw`, `wc`, `cf`, `fc`, `wf`, `fw`, `cwf`, `cfw`, `wcf`, `wfc`, `fcw`, `fwc`
 
-**Note:** Whole word matching and regex matching cannot be used at the same time, because we can use `\b` in regex to enable whole word matching: `r"\btext\b"`
+> **Note:** Whole word matching and regex matching cannot be used at the same time, because we can use `\b` in regex to enable whole word matching: `r"\btext\b"`
+
+## Context
+
+Show context lines around each match. The value is specified as `BEFORE:AFTER`:
+
+```bash
+--context 2       # 2 lines before and after
+--context 2:0     # 2 lines before, none after
+--context 0:2     # none before, 2 lines after
+--context 2:5     # 2 lines before, 5 lines after
+--context 2:      # 2 lines before, none after
+--context :2      # none before, 2 lines after
+--context 0       # matching lines only
+```
+
+Nearby matches whose context ranges overlap or directly touch are combined into a single group.
+
+## Depth
+
+Controls how deep the search goes inside directories.
+
+A depth of `0` means that only base path's immediate contents are searched; subdirectories are not entered.
+
+```text
+project/                  ← base directory
+├── file.txt              ← depth 0
+├── folder1/              ← depth 0
+│   ├── file.txt          ← depth 1
+│   └── folder2/          ← depth 1
+│       └── file.txt      ← depth 2
+```
+
+`--depth` can be specified multiple times to search non-contiguous depth ranges:
+
+```bash
+--depth 0              # Direct contents only
+--depth 1              # One level inside
+--depth 2:4            # Depths 2 through 4
+--depth 2 --depth 5:7  # Depths 2 and 5 through 7
+--depth :2             # Depths 0 through 2
+--depth 3:             # Depth 3 and deeper
+```
+
+If `--depth` is not specified, the search has no depth limit.
 
 ## Extension Filters
 
@@ -402,7 +448,7 @@ psk TODO \
 
 Skip those paths.
 
-**Note:** The include and exclude paths will be combined with path argument.
+> **Note:** The include and exclude paths will be combined with path argument.
 
 ## Regex Path Filters
 
@@ -455,7 +501,7 @@ psk config \
 
 Files between `1 MiB` and `10 MiB` will not match.
 
-**Note:** Directory sizes are not calculated recursively. When `--size` is used, directories are automatically excluded from the search results.
+> **Note:** Directory sizes are not calculated recursively. When `--size` is used, directories are automatically excluded from the search results.
 
 ## Archive Search
 
@@ -487,15 +533,24 @@ backup.zip::source.7z::notes.txt
 
 ### Archive Depth
 
-Limit recursion depth:
+The concept of depth in archive is different from `--depth`. Depth in archive is calculated based on nested archives. Each archive that is inside another archive counts as one level of depth.
+
+| Syntax | Meaning                                                  |
+| ------ | -------------------------------------------------------- |
+| `2`    | exactly `2nd` depth                                      |
+| `:2`   | `2nd` depth or lower                                     |
+| `2:`   | `2nd` depth or higher                                    |
+| `2:4`  | between `2` and `4` (Both range boundaries are included) |
+
+`--arc-depth` can be specified multiple times:
 
 ```bash
-psk TODO --archive --depth 2
+psk TODO --archive --arc-depth :2 --arc-depth 5:
 ```
 
-Meaning `archive level 1` and `archive level 2` will be searched. Deeper levels will be skipped.
+Meaning `archive level 3` and `archive level 4` won't be searched.
 
-**Note:** `--depth 0` means perform the search only within this current archive and don't enter nested archives.
+> **Note:** `--arc-depth 0` means perform the search only within this current archive and don't enter nested archives.
 
 ## Archive Filters
 
@@ -535,7 +590,7 @@ This works exactly like the [--size](#size-filtering) option.
 psk TODO --archive --arc-size 10m:40m
 ```
 
-**Note:** Archive directory sizes are usually reported as zero by archive formats, so directory search is disabled if this filter is enabled to avoid incorrect results.
+> **Note:** Archive directory sizes are usually reported as zero by archive formats, so directory search is disabled if this filter is enabled to avoid incorrect results.
 
 ## RAR Backend
 

{pseek-3.1.2 → pseek-3.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pseek"
-version = "3.1.2"
+version = "3.2.0"
 description = "Pseek is a Python CLI toolkit to search files, folders, and text"
 readme = "README.md"
 license = "MIT"