pseek 2.4.0__tar.gz → 2.5.0__tar.gz

{pseek-2.4.0 → pseek-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pseek
-Version: 2.4.0
+Version: 2.5.0
 Summary: Pseek is a Python library to search files, folders, and text
 Author-email: Arian <ariannasiri86@gmail.com>
 License-Expression: MIT
@@ -12,6 +12,7 @@ Requires-Dist: click==8.1.8
 Requires-Dist: lark==1.2.2
 Requires-Dist: py7zr==1.0.0
 Requires-Dist: rarfile==4.2
+Requires-Dist: rapidfuzz==3.13.0
 Dynamic: license-file
 
 # Pseek
@@ -95,6 +96,8 @@ pseek "error\d+" --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 to write conditions in the query. Example: `r"foo.*bar" and ("bar" or "baz") and not "qux"` (To use regex, word, and case-sensitive features, you can use the prefixes `r`, `w`, and `c` before terms. Allowed modes: `r`, `w`, `c`, `wc`, `cw`, `rc`, `cr`. Examples: `r"foo.*bar"`, `wc"Foo"`, `cr".*Foo"`, ...) |
 | `--timeout`                    | To stop the search after a specified period of time (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)                                                                                                                                                                     |
+| `--fuzzy_level`                | Similarity threshold from 0 to 99 for fuzzy search (default: `80`)                                                                                                                                                                                                                                                        |
 | `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories                                                                                                                                                                                                                                                               |
 | `--archive`                    | Enable search within archive files (e.g. `zip`, `rar`, `7z`, `gz`, `bz2`, `xz`, `tar`, `tar.gz`, `tar.bz2`, `tar.xz`)                                                                                                                                                                                                     |
 | `--arc-ext`, `--arc-ee`        | Filter by file extension inside archive files                                                                                                                                                                                                                                                                             |

{pseek-2.4.0 → pseek-2.5.0}/README.md

@@ -79,6 +79,8 @@ pseek "error\d+" --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 to write conditions in the query. Example: `r"foo.*bar" and ("bar" or "baz") and not "qux"` (To use regex, word, and case-sensitive features, you can use the prefixes `r`, `w`, and `c` before terms. Allowed modes: `r`, `w`, `c`, `wc`, `cw`, `rc`, `cr`. Examples: `r"foo.*bar"`, `wc"Foo"`, `cr".*Foo"`, ...) |
 | `--timeout`                    | To stop the search after a specified period of time (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)                                                                                                                                                                     |
+| `--fuzzy_level`                | Similarity threshold from 0 to 99 for fuzzy search (default: `80`)                                                                                                                                                                                                                                                        |
 | `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories                                                                                                                                                                                                                                                               |
 | `--archive`                    | Enable search within archive files (e.g. `zip`, `rar`, `7z`, `gz`, `bz2`, `xz`, `tar`, `tar.gz`, `tar.bz2`, `tar.xz`)                                                                                                                                                                                                     |
 | `--arc-ext`, `--arc-ee`        | Filter by file extension inside archive files                                                                                                                                                                                                                                                                             |

{pseek-2.4.0 → pseek-2.5.0}/pseek/cli.py

@@ -23,7 +23,6 @@ def run_search_process(file, directory, content, search_instance):
     click.echo(click.style(message, fg='red'))
 
 
-
 @click.command()
 @click.argument('query')
 @click.option('-p', '--path', type=click.Path(exists=True, file_okay=False, dir_okay=True),
@@ -52,6 +51,9 @@ def run_search_process(file, directory, content, search_instance):
                    'Examples: r"foo.*bar", wc"Foo", cr".*Foo", ...)')
 @click.option('--timeout', type=click.INT,
               help='To stop the search after a specified period of time (Seconds)')
+@click.option('--fuzzy', is_flag=True, help='Enable fuzzy search (approximate matching).')
+@click.option('--fuzzy-level', type=click.IntRange(0, 99), default=80, show_default=True,
+              help='Similarity threshold from 0 to 99 for fuzzy search.')
 # Extension filters
 @click.option('--ext', multiple=True, type=click.STRING,
               help='Include files with these extensions. Example: --ext py --ext js')
@@ -89,12 +91,29 @@ def run_search_process(file, directory, content, search_instance):
 @click.option('--full-path', is_flag=True, help='Display full paths for results.')
 @click.option('--no-content', is_flag=True, help='Only display files path for content search.')
 def search(query, path, file, directory, content, case_sensitive, ext, exclude_ext, regex, include, exclude,
-           re_include, re_exclude, word, expr, timeout, max_size, min_size, archive, arc_ext, arc_ee, arc_inc,
-           arc_exc, arc_max, arc_min, rarfb, full_path, no_content):
+           re_include, re_exclude, word, expr, timeout, fuzzy, fuzzy_level, max_size, min_size, archive, arc_ext,
+           arc_ee, arc_inc, arc_exc, arc_max, arc_min, rarfb, full_path, no_content):
     """Search for files, directories, and file content based on the query."""
 
     check_rar_backend(archive, rarfb, query)
 
+    if not expr and fuzzy:
+        if not word:
+            click.echo(
+                click.style(
+                    "Warning: Fuzzy substring highlighting and counting matches are disabled to improve performance.\n",
+                    fg="yellow"
+                )
+            )
+        else:
+            click.echo(
+                click.style(
+                    'Warning: When using "--fuzzy" and "--word", it is better to have the query be a word and '
+                    'not a phrase, as this will cause errors in the results.\n',
+                    fg="yellow"
+                )
+            )
+
     # If no search type is specified, search in all types.
     if not any((file, directory, content)):
         file = directory = content = True
@@ -113,6 +132,8 @@ def search(query, path, file, directory, content, case_sensitive, ext, exclude_e
         re_exclude=re_exclude,
         whole_word=word,
         expr=expr,
+        fuzzy=fuzzy,
+        fuzzy_level=fuzzy_level,
         max_size=max_size,
         min_size=min_size,
         archive=archive,

{pseek-2.4.0 → pseek-2.5.0}/pseek/parser.py

@@ -3,6 +3,7 @@ import sys
 import click
 from lark import Lark, Transformer
 from .utils import compile_regex
+from rapidfuzz import fuzz
 
 
 class ExprNode:
@@ -13,31 +14,64 @@ class ExprNode:
 
 class TermNode(ExprNode):
     """Node representing a single search term"""
-    def __init__(self, term: str, regex, whole_word, case_sensitive):
+    def __init__(self, term: str, regex, whole_word, case_sensitive, fuzzy, fuzzy_level):
         self.raw_term = term
         self.whole_word = whole_word
         self.case_sensitive = case_sensitive
+        self.fuzzy = fuzzy
+        self.fuzzy_level = fuzzy_level
 
-        flags = 0 if case_sensitive else re.IGNORECASE  # Adjust case sensitivity
+        if not fuzzy:
+            flags = 0 if case_sensitive else re.IGNORECASE  # Adjust case sensitivity
 
-        # Build the regex pattern
-        if not regex:
-            term = re.escape(term)  # Escape if not regex
-            # Apply whole-word matching only if not using regex (or if desired behavior is defined)
-            if whole_word:
-                term = r'\b' + term + r'\b'
+            # Build the regex pattern
+            if not regex:
+                term = re.escape(term)  # Escape if not regex
+                # Apply whole-word matching only if not using regex (or if desired behavior is defined)
+                if whole_word:
+                    term = r'\b' + term + r'\b'
 
-        self.pattern = compile_regex(term, flags)  # Precompile the regex pattern for performance
+            self.pattern = compile_regex(term, flags)  # Precompile the regex pattern for performance
 
     def evaluate(self, text: str) -> bool:
-        return bool(self.pattern.search(text))
+        if not self.fuzzy:
+            return bool(self.pattern.search(text))
+
+        # Fuzzy search mode
+        text_cmp = text if self.case_sensitive else text.lower()
+        term = self.raw_term if self.case_sensitive else self.raw_term.lower()
+
+        if self.whole_word:
+            words = re.findall(r'\w+', text_cmp)
+            return any(fuzz.ratio(term, word) >= self.fuzzy_level for word in words)
+        else:
+            # Use the correct method depending on the len of str to increase accuracy and avoid illogical matching
+            if len(text_cmp) > len(term):
+                score = fuzz.partial_ratio(term, text_cmp)
+            else:
+                score = fuzz.ratio(term, text_cmp)
+            return score >= self.fuzzy_level
+
 
     def count_matches(self, text: str) -> int:
-        """Count how many times the pattern appears in the text"""
-        return len(list(self.pattern.finditer(text)))
+        """Count how many times the pattern or fuzzy term appears in the text"""
+        if not self.fuzzy:
+            return len(list(self.pattern.finditer(text)))
+
+        text_cmp = text if self.case_sensitive else text.lower()
+        term = self.raw_term if self.case_sensitive else self.raw_term.lower()
+
+        if self.whole_word:
+            words = re.findall(r'\w+', text_cmp)
+            return sum(1 for word in words if fuzz.ratio(term, word) >= self.fuzzy_level)
+
+        # Optionally could implement a sliding window here, but it's expensive
+        return 0
 
     def get_binary_pattern(self) -> re.Pattern:
         """Return a compiled binary regex pattern"""
+        if self.fuzzy:
+            raise NotImplementedError("Binary pattern is not supported for fuzzy matching.")
         return re.compile(self.pattern.pattern.encode("utf-8"), self.pattern.flags)
 
 
@@ -99,8 +133,10 @@ PREFIXED_STRING: /(r|c|w|rc|cr|cw|wc)"([^"\\]|\\.)*"/
 
 class TreeToExpr(Transformer):
     """Transform parsed tree into expression tree (ExprNode subclasses)"""
-    def __init__(self):
+    def __init__(self, fuzzy, fuzzy_level):
         super().__init__()
+        self.fuzzy = fuzzy
+        self.fuzzy_level = fuzzy_level
 
     def string(self, s):
         """ Match normal quoted string: "foo" """
@@ -109,7 +145,9 @@ class TreeToExpr(Transformer):
             term,
             False,
             False,
-            False
+            False,
+            self.fuzzy,
+            self.fuzzy_level
         )
 
     def prefixed_string(self, s):
@@ -122,6 +160,8 @@ class TreeToExpr(Transformer):
             regex='r' in prefix,
             whole_word='w' in prefix,
             case_sensitive='c' in prefix,
+            fuzzy=self.fuzzy,
+            fuzzy_level=self.fuzzy_level
         )
 
     def and_expr(self, args):
@@ -134,48 +174,72 @@ class TreeToExpr(Transformer):
         return NotNode(args[0])
 
 
-def parse_query_expression(query: str, expr, regex, whole_word, case_sensitive) -> ExprNode:
+def parse_query_expression(query: str, expr, regex, whole_word, case_sensitive, fuzzy, fuzzy_level) -> ExprNode:
     """
     Function to parse the query and return expression tree.
     If expr is False, treat the whole query as a single term.
     """
 
     if not expr:
-        return TermNode(query, regex, whole_word, case_sensitive)
+        return TermNode(query, regex, whole_word, case_sensitive, fuzzy, fuzzy_level)
 
     # Otherwise, parse using Lark
     parser = Lark(query_grammar, parser="lalr")
     try:
         tree = parser.parse(query)
-        return TreeToExpr().transform(tree)
+        return TreeToExpr(fuzzy, fuzzy_level).transform(tree)
     except Exception as e:
         click.echo(click.style("Query parser error:\n\n", fg='red') + str(e))
         sys.exit(1)
 
 
-def highlight_text_safe(expr: ExprNode, text: str) -> str:
+def highlight_text(expr: ExprNode, text: str, fuzzy: bool) -> str:
+    """
+    Highlight matching parts of the text.
+    Only highlights fuzzy matches when whole_word=True.
+    """
     matches = []
 
     def collect_matches(node):
         if isinstance(node, TermNode):
-            for match in node.pattern.finditer(text):
-                matches.append((match.start(), match.end()))
-        elif isinstance(node, (AndNode, OrNode)):
+            # Skip fuzzy highlight if whole_word is False
+            if node.fuzzy:
+                if not node.whole_word:
+                    return  # skip highlighting
+                text_cmp = text if node.case_sensitive else text.lower()
+                term = node.raw_term if node.case_sensitive else node.raw_term.lower()
+
+                # collect word matches
+                for match in re.finditer(r'\w+', text_cmp):
+                    word = match.group()
+                    if fuzz.ratio(term, word) >= node.fuzzy_level:
+                        matches.append((match.start(), match.end()))
+            else:
+                for match in node.pattern.finditer(text):
+                    matches.append((match.start(), match.end()))
+        elif isinstance(node, AndNode) or isinstance(node, OrNode):
             collect_matches(node.left)
             collect_matches(node.right)
         elif isinstance(node, NotNode):
             collect_matches(node.child)
 
+    # If fuzzy is enabled but whole_word is False, return plain text
+    if fuzzy and isinstance(expr, TermNode) and not expr.whole_word:
+        return text
+
     collect_matches(expr)
 
-    # Remove overlaps (for example, if one match was inside another match)
+    # Sort and merge overlapping matches (for example, if one match was inside another match)
     matches.sort()  # sort by start position
     merged = []
     for start, end in matches:
         if not merged or start >= merged[-1][1]:  # no overlap
             merged.append((start, end))
+        else:
+            # Merge overlapping
+            merged[-1] = (merged[-1][0], max(merged[-1][1], end))
 
-    # Create the final text with highlight
+    # Build highlighted text
     result = []
     last = 0
     for start, end in merged:

{pseek-2.4.0 → pseek-2.5.0}/pseek/searcher.py

@@ -2,7 +2,7 @@ import mmap
 import click
 from pathlib import Path
 from .utils import compile_regex, get_archive_path_size, try_decode
-from .parser import parse_query_expression, TermNode, highlight_text_safe
+from .parser import parse_query_expression, TermNode, highlight_text
 from concurrent.futures import ThreadPoolExecutor
 import zipfile
 import py7zr
@@ -30,8 +30,8 @@ EXCLUDED_EXTENSIONS = (
 
 class Search:
     def __init__(self, base_path, query, case_sensitive, ext, exclude_ext, regex, include, exclude, re_include,
-                 re_exclude, whole_word, expr, max_size, min_size, archive, arc_ext, arc_ee, arc_inc, arc_exc,
-                 arc_max, arc_min, full_path, no_content):
+                 re_exclude, whole_word, expr, fuzzy, fuzzy_level, max_size, min_size, archive, arc_ext, arc_ee,
+                 arc_inc, arc_exc, arc_max, arc_min, full_path, no_content):
         """Initialize search parameters"""
         self.base_path = Path(base_path)
         self.query = query
@@ -45,6 +45,8 @@ class Search:
         self.re_exclude = compile_regex(re_exclude)
         self.whole_word = whole_word
         self.expr = expr
+        self.fuzzy = fuzzy
+        self.fuzzy_level = fuzzy_level
         self.max_size = max_size
         self.min_size = min_size
         self.archive = archive
@@ -301,7 +303,8 @@ class Search:
 
     def search(self, search_type: str):
         """Main search function. search_type can be 'file', 'directory' or 'content'"""
-        pattern = parse_query_expression(self.query, self.expr, self.regex, self.whole_word, self.case_sensitive)
+        pattern = parse_query_expression(self.query, self.expr, self.regex, self.whole_word, self.case_sensitive,
+                                         self.fuzzy, self.fuzzy_level)
 
         if search_type in ('file', 'directory'):
             matches = []
@@ -320,14 +323,14 @@ class Search:
 
                 if pattern.evaluate(p.name) and not (search_type == 'directory' and p_resolved.is_file()):
                     # Highlight matched query in the name
-                    highlighted_name = highlight_text_safe(pattern, p.name)
+                    highlighted_name = highlight_text(pattern, p.name, self.fuzzy)
                     matches.append(f'{p_parent}\\{highlighted_name}')
 
                 # Search for files and directories name inside archive files if archive is active
                 if self.archive and p_ext in ('zip', 'rar', '7z', 'tar', 'tar.gz', 'tar.bz2', 'tar.xz'):
                     for name in self.extract_names_from_archive(p_resolved, search_type):
                         if pattern.evaluate(name.name):
-                            highlighted_name = highlight_text_safe(pattern, name.name)
+                            highlighted_name = highlight_text(pattern, name.name, self.fuzzy)
                             matches.append(f'{p_parent}\\{p.name}::{name.parent}\\{highlighted_name}')
         else:  # content search
             # Use dictionary: key: file path (colored), value: list of line matches
@@ -375,7 +378,7 @@ class Search:
 
                                 count = pattern.count_matches(line) if isinstance(pattern, TermNode) else 0
                                 # Highlight the matching parts in green
-                                highlighted = highlight_text_safe(pattern, line)
+                                highlighted = highlight_text(pattern, line, self.fuzzy)
                                 # Show a note if the pattern repeats 3 or more times
                                 count_query = f' - Repeated {count} times' if count >= 3 else ''
                                 # Format the output line with line number and highlighted matches
@@ -427,7 +430,7 @@ class Search:
                                         return
                                     count = pattern.count_matches(line_decoded) if isinstance(pattern, TermNode) else 0
                                     # Highlight the matching parts in green
-                                    highlighted = highlight_text_safe(pattern, line_decoded)
+                                    highlighted = highlight_text(pattern, line_decoded, self.fuzzy)
                                     # Show a note if the pattern repeats 3 or more times
                                     count_query = f' - Repeated {count} times' if count >= 3 else ''
                                     # Format the output line with line number and highlighted matches

{pseek-2.4.0 → pseek-2.5.0}/pseek.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pseek
-Version: 2.4.0
+Version: 2.5.0
 Summary: Pseek is a Python library to search files, folders, and text
 Author-email: Arian <ariannasiri86@gmail.com>
 License-Expression: MIT
@@ -12,6 +12,7 @@ Requires-Dist: click==8.1.8
 Requires-Dist: lark==1.2.2
 Requires-Dist: py7zr==1.0.0
 Requires-Dist: rarfile==4.2
+Requires-Dist: rapidfuzz==3.13.0
 Dynamic: license-file
 
 # Pseek
@@ -95,6 +96,8 @@ pseek "error\d+" --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 to write conditions in the query. Example: `r"foo.*bar" and ("bar" or "baz") and not "qux"` (To use regex, word, and case-sensitive features, you can use the prefixes `r`, `w`, and `c` before terms. Allowed modes: `r`, `w`, `c`, `wc`, `cw`, `rc`, `cr`. Examples: `r"foo.*bar"`, `wc"Foo"`, `cr".*Foo"`, ...) |
 | `--timeout`                    | To stop the search after a specified period of time (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)                                                                                                                                                                     |
+| `--fuzzy_level`                | Similarity threshold from 0 to 99 for fuzzy search (default: `80`)                                                                                                                                                                                                                                                        |
 | `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories                                                                                                                                                                                                                                                               |
 | `--archive`                    | Enable search within archive files (e.g. `zip`, `rar`, `7z`, `gz`, `bz2`, `xz`, `tar`, `tar.gz`, `tar.bz2`, `tar.xz`)                                                                                                                                                                                                     |
 | `--arc-ext`, `--arc-ee`        | Filter by file extension inside archive files                                                                                                                                                                                                                                                                             |

{pseek-2.4.0 → pseek-2.5.0}/pseek.egg-info/requires.txt

@@ -2,3 +2,4 @@ click==8.1.8
 lark==1.2.2
 py7zr==1.0.0
 rarfile==4.2
+rapidfuzz==3.13.0

{pseek-2.4.0 → pseek-2.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pseek"
-version = "2.4.0"
+version = "2.5.0"
 description = "Pseek is a Python library to search files, folders, and text"
 readme = "README.md"
 license = "MIT"
@@ -17,7 +17,8 @@ dependencies = [
     "click==8.1.8",
     "lark==1.2.2",
     "py7zr==1.0.0",
-    "rarfile==4.2"
+    "rarfile==4.2",
+    "rapidfuzz==3.13.0"
 ]
 urls = {Homepage = "https://github.com/ArianN8610/pysearch"}