pseek 2.1.5__tar.gz → 2.2.0__tar.gz

pseek-2.2.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: pseek
+Version: 2.2.0
+Summary: Pseek is a Python library to search files, folders, and text
+Author-email: Arian <ariannasiri86@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ArianN8610/pysearch
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click==8.1.8
+Requires-Dist: lark==1.2.2
+Dynamic: license-file
+
+# Pseek
+
+## Overview
+
+A powerful command-line tool for searching files, directories, and content inside files efficiently. The tool supports searching by name, content, extensions, and more with advanced filtering options.
+
+## Features
+
+* **Search in file & folder names**
+* **Search inside file contents**
+* **Highlight matches** in terminal output
+* **Optimized for speed** with ThreadPoolExecutor
+* **Cross-platform** (Linux, macOS, Windows)
+
+## Installation
+
+### **1️⃣ Install via `pip` (Recommended)**
+
+```sh
+pip install pseek
+```
+
+### **2️⃣ Install from source**
+
+```sh
+git clone https://github.com/ArianN8610/pysearch.git
+cd pseek
+pip install click==8.1.8
+```
+
+## Usage
+
+Run the command with a search query:
+```sh
+pseek <query> [options]
+```
+
+## Examples
+
+### Search for a keyword in file & folder names
+
+```sh
+pseek "my_keyword" --path /path/to/search --file --directory
+```
+
+### Search inside file contents
+
+```sh
+pseek "error" --path /var/logs --content
+```
+
+### Search only in specific file types
+
+```sh
+pseek "TODO" --path ./projects --ext py --ext txt
+```
+
+### Search by regex
+
+```sh
+pseek "error\d+" --regex
+```
+
+## Command Options
+
+| Option                         | Description                                                                                                                                                                                                                                                                                   |
+|--------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `--path`                       | Base directory to search in (default: current directory `.`)                                                                                                                                                                                                                                  |
+| `--file`                       | Search only in file names                                                                                                                                                                                                                                                                     |
+| `--directory`                  | Search only in directory names                                                                                                                                                                                                                                                                |
+| `--content`                    | Search inside file contents                                                                                                                                                                                                                                                                   |
+| `--ext`, `--exclude-ext`       | Filter by file extension (e.g., `.txt`, `.log`)                                                                                                                                                                                                                                               |
+| `--case-sensitive`             | 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")                                                                                                                                                 |
+| `--regex`                      | Use regular expressions to search (except when --expr is enabled, in which case you can make it regex by putting r before term: r"foo")                                                                                                                                                       |
+| `--include`, `--exclude`       | Limit search results to specific set of directories or files                                                                                                                                                                                                                                  |
+| `--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 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", ...) |
+| `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories                                                                                                                                                                                                                                   |
+| `--full-path`                  | Display full path of files and directories                                                                                                                                                                                                                                                    |
+| `--no-content`                 | Only display files path for content search                                                                                                                                                                                                                                                    |

pseek-2.2.0/README.md

@@ -0,0 +1,81 @@
+# Pseek
+
+## Overview
+
+A powerful command-line tool for searching files, directories, and content inside files efficiently. The tool supports searching by name, content, extensions, and more with advanced filtering options.
+
+## Features
+
+* **Search in file & folder names**
+* **Search inside file contents**
+* **Highlight matches** in terminal output
+* **Optimized for speed** with ThreadPoolExecutor
+* **Cross-platform** (Linux, macOS, Windows)
+
+## Installation
+
+### **1️⃣ Install via `pip` (Recommended)**
+
+```sh
+pip install pseek
+```
+
+### **2️⃣ Install from source**
+
+```sh
+git clone https://github.com/ArianN8610/pysearch.git
+cd pseek
+pip install click==8.1.8
+```
+
+## Usage
+
+Run the command with a search query:
+```sh
+pseek <query> [options]
+```
+
+## Examples
+
+### Search for a keyword in file & folder names
+
+```sh
+pseek "my_keyword" --path /path/to/search --file --directory
+```
+
+### Search inside file contents
+
+```sh
+pseek "error" --path /var/logs --content
+```
+
+### Search only in specific file types
+
+```sh
+pseek "TODO" --path ./projects --ext py --ext txt
+```
+
+### Search by regex
+
+```sh
+pseek "error\d+" --regex
+```
+
+## Command Options
+
+| Option                         | Description                                                                                                                                                                                                                                                                                   |
+|--------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `--path`                       | Base directory to search in (default: current directory `.`)                                                                                                                                                                                                                                  |
+| `--file`                       | Search only in file names                                                                                                                                                                                                                                                                     |
+| `--directory`                  | Search only in directory names                                                                                                                                                                                                                                                                |
+| `--content`                    | Search inside file contents                                                                                                                                                                                                                                                                   |
+| `--ext`, `--exclude-ext`       | Filter by file extension (e.g., `.txt`, `.log`)                                                                                                                                                                                                                                               |
+| `--case-sensitive`             | 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")                                                                                                                                                 |
+| `--regex`                      | Use regular expressions to search (except when --expr is enabled, in which case you can make it regex by putting r before term: r"foo")                                                                                                                                                       |
+| `--include`, `--exclude`       | Limit search results to specific set of directories or files                                                                                                                                                                                                                                  |
+| `--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 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", ...) |
+| `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories                                                                                                                                                                                                                                   |
+| `--full-path`                  | Display full path of files and directories                                                                                                                                                                                                                                                    |
+| `--no-content`                 | Only display files path for content search                                                                                                                                                                                                                                                    |

{pseek-2.1.5 → pseek-2.2.0}/pseek/cli.py

@@ -11,9 +11,23 @@ from .searcher import Search
 @click.option('-d', '--directory', is_flag=True, help='Search only in directory names.')
 @click.option('-c', '--content', is_flag=True, help='Search inside file contents.')
 # Additional options
-@click.option('-C', '--case-sensitive', is_flag=True, help='Make the search case-sensitive.')
-@click.option('--regex', is_flag=True, help='Use regular expression for searching.')
-@click.option('-w', '--word', is_flag=True, help='Match whole words only.')
+@click.option('-C', '--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")')
+@click.option('-r', '--regex', is_flag=True,
+              help='Use regular expressions to search '
+                   '(except when --expr is enabled, '
+                   'in which case you can make it regex by putting r before term: r"foo")')
+@click.option('-w', '--word', is_flag=True,
+              help='Match whole words only '
+                   '(except when --expr is enabled, '
+                   'in which case you can make it match whole word by putting w before term: w"foo")')
+@click.option('--expr', is_flag=True,
+              help='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", ...)')
 # Extension filters
 @click.option('--ext', multiple=True, type=click.STRING,
               help='Include files with these extensions. Example: --ext py --ext js')
@@ -35,7 +49,7 @@ from .searcher import Search
 @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, max_size, min_size, full_path, no_content):
+           re_include, re_exclude, word, expr, max_size, min_size, full_path, no_content):
     """Search for files, directories, and file content based on the query."""
     # If no search type is specified, search in all types.
     if not any((file, directory, content)):
@@ -54,6 +68,7 @@ def search(query, path, file, directory, content, case_sensitive, ext, exclude_e
         re_include=re_include,
         re_exclude=re_exclude,
         whole_word=word,
+        expr=expr,
         max_size=max_size,
         min_size=min_size,
         full_path=full_path,

pseek-2.2.0/pseek/parser.py

@@ -0,0 +1,187 @@
+import re
+import sys
+import click
+from lark import Lark, Transformer
+from .utils import compile_regex
+
+
+class ExprNode:
+    """Base class for expression tree nodes"""
+    def evaluate(self, text: str) -> bool:
+        raise NotImplementedError
+
+
+class TermNode(ExprNode):
+    """Node representing a single search term"""
+    def __init__(self, term: str, regex, whole_word, case_sensitive):
+        self.raw_term = term
+        self.whole_word = whole_word
+        self.case_sensitive = case_sensitive
+
+        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'
+
+        self.pattern = compile_regex(term, flags)  # Precompile the regex pattern for performance
+
+    def evaluate(self, text: str) -> bool:
+        return bool(self.pattern.search(text))
+
+    def count_matches(self, text: str) -> int:
+        """Count how many times the pattern appears in the text"""
+        return len(list(self.pattern.finditer(text)))
+
+    def get_binary_pattern(self) -> re.Pattern:
+        """Return a compiled binary regex pattern"""
+        return re.compile(self.pattern.pattern.encode("utf-8"), self.pattern.flags)
+
+
+class NotNode(ExprNode):
+    """Node representing logical NOT"""
+    def __init__(self, child: ExprNode):
+        self.child = child
+
+    def evaluate(self, text: str) -> bool:
+        return not self.child.evaluate(text)
+
+
+class AndNode(ExprNode):
+    """Node representing logical AND"""
+    def __init__(self, left: ExprNode, right: ExprNode):
+        self.left = left
+        self.right = right
+
+    def evaluate(self, text: str) -> bool:
+        return self.left.evaluate(text) and self.right.evaluate(text)
+
+
+class OrNode(ExprNode):
+    """Node representing logical OR"""
+    def __init__(self, left: ExprNode, right: ExprNode):
+        self.left = left
+        self.right = right
+
+    def evaluate(self, text: str) -> bool:
+        return self.left.evaluate(text) or self.right.evaluate(text)
+
+
+# Lark grammar for parsing logical expressions
+query_grammar = r"""
+?start: expr
+
+?expr: or_expr
+
+?or_expr: and_expr
+        | or_expr "or" and_expr     -> or_expr
+
+?and_expr: not_expr
+         | and_expr "and" not_expr  -> and_expr
+
+?not_expr: "not" not_expr           -> not_expr
+         | term
+
+?term: PREFIXED_STRING          -> prefixed_string
+     | ESCAPED_STRING           -> string
+     | "(" expr ")"
+
+PREFIXED_STRING: /(r|c|w|rc|cr|cw|wc)"([^"\\]|\\.)*"/
+
+%import common.ESCAPED_STRING
+%import common.WS
+%ignore WS
+"""
+
+
+class TreeToExpr(Transformer):
+    """Transform parsed tree into expression tree (ExprNode subclasses)"""
+    def __init__(self):
+        super().__init__()
+
+    def string(self, s):
+        """ Match normal quoted string: "foo" """
+        term = s[0][1:-1]  # Remove surrounding quotes (e.g., "foo" -> foo)
+        return TermNode(
+            term,
+            False,
+            False,
+            False
+        )
+
+    def prefixed_string(self, s):
+        text = str(s[0])  # e.g., 'rc"pattern"'
+        prefix = text.split('"', 1)[0].lower()
+        content = text.split('"', 1)[1][:-1]
+
+        return TermNode(
+            content,
+            regex='r' in prefix,
+            whole_word='w' in prefix,
+            case_sensitive='c' in prefix,
+        )
+
+    def and_expr(self, args):
+        return AndNode(args[0], args[1])
+
+    def or_expr(self, args):
+        return OrNode(args[0], args[1])
+
+    def not_expr(self, args):
+        return NotNode(args[0])
+
+
+def parse_query_expression(query: str, expr, regex, whole_word, case_sensitive) -> 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)
+
+    # Otherwise, parse using Lark
+    parser = Lark(query_grammar, parser="lalr")
+    try:
+        tree = parser.parse(query)
+        return TreeToExpr().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:
+    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)):
+            collect_matches(node.left)
+            collect_matches(node.right)
+        elif isinstance(node, NotNode):
+            collect_matches(node.child)
+
+    collect_matches(expr)
+
+    # Remove overlaps (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))
+
+    # Create the final text with highlight
+    result = []
+    last = 0
+    for start, end in merged:
+        result.append(text[last:start])
+        result.append(click.style(text[start:end], fg='green'))
+        last = end
+    result.append(text[last:])
+
+    return ''.join(result)

{pseek-2.1.5 → pseek-2.2.0}/pseek/searcher.py

@@ -1,8 +1,8 @@
-import re
-import sys
-import click
 import mmap
+import click
 from pathlib import Path
+from .utils import compile_regex
+from .parser import parse_query_expression, TermNode, highlight_text_safe
 from concurrent.futures import ThreadPoolExecutor
 
 # Extensions that are not suitable for content search (binary, media, etc.)
@@ -19,18 +19,9 @@ EXCLUDED_EXTENSIONS = {
 }
 
 
-def compile_regex(txt, flags=0):
-    if txt is not None:
-        try:
-            return re.compile(txt, flags)
-        except re.error as e:
-            click.echo(click.style(f"Regex compile error: {e}", fg='red'))
-            sys.exit(1)
-
-
 class Search:
     def __init__(self, base_path, query, case_sensitive, ext, exclude_ext, regex, include, exclude, re_include,
-                 re_exclude, whole_word, max_size, min_size, full_path, no_content):
+                 re_exclude, whole_word, expr, max_size, min_size, full_path, no_content):
         """Initialize search parameters"""
         self.base_path = Path(base_path)
         self.query = query
@@ -38,11 +29,12 @@ class Search:
         self.ext = set(ext)
         self.exclude_ext = set(exclude_ext)
         self.regex = regex
-        self.include = {Path(p) for p in include}
-        self.exclude = {Path(p) for p in exclude}
+        self.include = {Path(p).resolve() for p in include}
+        self.exclude = {Path(p).resolve() for p in exclude}
         self.re_include = re_include
         self.re_exclude = re_exclude
         self.whole_word = whole_word
+        self.expr = expr
         self.max_size = max_size
         self.min_size = min_size
         self.full_path = full_path
@@ -83,18 +75,7 @@ class Search:
 
     def search(self, search_type: str):
         """Main search function. search_type can be 'file', 'directory' or 'content'"""
-        query = self.query
-
-        # Prepare query: escape if not regex
-        if not self.regex:
-            query = re.escape(query)
-
-        # Apply whole-word matching only if not using regex (or if desired behavior is defined)
-        if self.whole_word and not self.regex:
-            query = rf'\b{query}\b'
-
-        flags = 0 if self.case_sensitive else re.IGNORECASE  # Adjust case sensitivity
-        pattern = compile_regex(query, flags)  # Precompile the regex pattern for performance
+        pattern = parse_query_expression(self.query, self.expr, self.regex, self.whole_word, self.case_sensitive)
 
         if search_type in ('file', 'directory'):
             matches = []
@@ -104,19 +85,25 @@ class Search:
                 except Exception:
                     continue
                 # Skip if conditions fail or if name doesn't match the query
-                if self.should_skip(p_resolved, search_type) or not pattern.search(p.name):
+                if self.should_skip(p_resolved, search_type) or not pattern.evaluate(p.name):
                     continue
 
                 # Highlight matched query in the name
-                highlighted_name = pattern.sub(lambda m: click.style(m.group(), fg='green'), p.name)
+                highlighted_name = highlight_text_safe(pattern, p.name)
                 # Choose parent path based on full_path flag
                 p_parent = p_resolved.parent if self.full_path else p.parent
                 matches.append(f'{p_parent}\\{highlighted_name}')
         else:  # content search
             # Use dictionary: key: file path (colored), value: list of line matches
             matches = {} if not self.no_content else set()
-            # Compile binary version of the pattern
-            pattern_bytes = re.compile(pattern.pattern.encode('utf-8'))
+
+            # If expression is simple and is a single TermNode, we can use binary pattern
+            binary_pattern = None
+            if isinstance(pattern, TermNode):
+                try:
+                    binary_pattern = pattern.get_binary_pattern()
+                except Exception:
+                    binary_pattern = None
 
             def process_file(file_path: Path):
                 """Process a single file for content search"""
@@ -129,48 +116,55 @@ class Search:
                     with open(file_path, 'rb') as f:
                         # Memory-map the file for efficient access
                         with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
-                            # Search for the pattern in the entire file as bytes
-                            if pattern_bytes.search(mm):
-                                # Choose the file path format based on the full_path setting
-                                file_label = str(file_path.resolve()) if self.full_path else str(file_path)
-
-                                # Avoid searching through the entire file content if the fast-content flag is True
-                                if self.no_content:
-                                    matches.add(click.style(file_label, fg='cyan'))
+                            if binary_pattern is not None:
+                                if not binary_pattern.search(mm):
+                                    return
+                            else:
+                                # fallback: decode whole file for complex expressions
+                                try:
+                                    content = mm.read().decode('utf-8')
+                                except UnicodeDecodeError:
+                                    return
+
+                                if not pattern.evaluate(content):
                                     return
 
-                                lines = []
-                                mm.seek(0)  # Move the cursor to the beginning of the file
-
-                                # 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()
-                                    except UnicodeDecodeError:
-                                        # Skip lines that can't be decoded
-                                        continue
-
-                                    # If the pattern matches in the decoded line
-                                    if pattern_list := list(pattern.finditer(line_decoded)):
-                                        # Count how many times the pattern appears in the line
-                                        count = len(pattern_list)
-                                        # Highlight the matching parts in green
-                                        highlighted = pattern.sub(
-                                            lambda m: click.style(m.group(), fg='green'),
-                                            line_decoded
-                                        )
-                                        # 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
-                                        lines.append(
-                                            click.style(f'Line {num}{count_query}: ', fg='magenta') + highlighted
-                                        )
-
-                                # If any matching lines were found
-                                if lines:
-                                    # Add the file and its matching lines to the results
-                                    matches[click.style(file_label, fg='cyan')] = lines
+                            # Choose the file path format based on the full_path setting
+                            file_label = str(file_path.resolve()) if self.full_path else str(file_path)
+
+                            # Avoid searching through the entire file content if the fast-content flag is True
+                            if self.no_content:
+                                matches.add(click.style(file_label, fg='cyan'))
+                                return
+
+                            lines = []
+                            mm.seek(0)  # Move the cursor to the beginning of the file
+
+                            # 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()
+                                except UnicodeDecodeError:
+                                    # Skip lines that can't be decoded
+                                    continue
+
+                                # If the pattern matches in the decoded line
+                                if pattern.evaluate(line_decoded):
+                                    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)
+                                    # 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
+                                    lines.append(
+                                        click.style(f'Line {num}{count_query}: ', fg='magenta') + highlighted
+                                    )
+
+                            # If any matching lines were found
+                            if lines:
+                                # Add the file and its matching lines to the results
+                                matches[click.style(file_label, fg='cyan')] = lines
                 except Exception:
                     return
 

pseek-2.2.0/pseek/utils.py

@@ -0,0 +1,12 @@
+import re
+import sys
+import click
+
+
+def compile_regex(txt, flags=0):
+    if txt is not None:
+        try:
+            return re.compile(txt, flags)
+        except re.error as e:
+            click.echo(click.style(f"Regex compile error: {e}", fg='red'))
+            sys.exit(1)

pseek-2.2.0/pseek.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: pseek
+Version: 2.2.0
+Summary: Pseek is a Python library to search files, folders, and text
+Author-email: Arian <ariannasiri86@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ArianN8610/pysearch
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click==8.1.8
+Requires-Dist: lark==1.2.2
+Dynamic: license-file
+
+# Pseek
+
+## Overview
+
+A powerful command-line tool for searching files, directories, and content inside files efficiently. The tool supports searching by name, content, extensions, and more with advanced filtering options.
+
+## Features
+
+* **Search in file & folder names**
+* **Search inside file contents**
+* **Highlight matches** in terminal output
+* **Optimized for speed** with ThreadPoolExecutor
+* **Cross-platform** (Linux, macOS, Windows)
+
+## Installation
+
+### **1️⃣ Install via `pip` (Recommended)**
+
+```sh
+pip install pseek
+```
+
+### **2️⃣ Install from source**
+
+```sh
+git clone https://github.com/ArianN8610/pysearch.git
+cd pseek
+pip install click==8.1.8
+```
+
+## Usage
+
+Run the command with a search query:
+```sh
+pseek <query> [options]
+```
+
+## Examples
+
+### Search for a keyword in file & folder names
+
+```sh
+pseek "my_keyword" --path /path/to/search --file --directory
+```
+
+### Search inside file contents
+
+```sh
+pseek "error" --path /var/logs --content
+```
+
+### Search only in specific file types
+
+```sh
+pseek "TODO" --path ./projects --ext py --ext txt
+```
+
+### Search by regex
+
+```sh
+pseek "error\d+" --regex
+```
+
+## Command Options
+
+| Option                         | Description                                                                                                                                                                                                                                                                                   |
+|--------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `--path`                       | Base directory to search in (default: current directory `.`)                                                                                                                                                                                                                                  |
+| `--file`                       | Search only in file names                                                                                                                                                                                                                                                                     |
+| `--directory`                  | Search only in directory names                                                                                                                                                                                                                                                                |
+| `--content`                    | Search inside file contents                                                                                                                                                                                                                                                                   |
+| `--ext`, `--exclude-ext`       | Filter by file extension (e.g., `.txt`, `.log`)                                                                                                                                                                                                                                               |
+| `--case-sensitive`             | 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")                                                                                                                                                 |
+| `--regex`                      | Use regular expressions to search (except when --expr is enabled, in which case you can make it regex by putting r before term: r"foo")                                                                                                                                                       |
+| `--include`, `--exclude`       | Limit search results to specific set of directories or files                                                                                                                                                                                                                                  |
+| `--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 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", ...) |
+| `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories                                                                                                                                                                                                                                   |
+| `--full-path`                  | Display full path of files and directories                                                                                                                                                                                                                                                    |
+| `--no-content`                 | Only display files path for content search                                                                                                                                                                                                                                                    |

{pseek-2.1.5 → pseek-2.2.0}/pseek.egg-info/SOURCES.txt

@@ -1,9 +1,11 @@
 LICENSE
 README.md
-setup.py
+pyproject.toml
 pseek/__init__.py
 pseek/cli.py
+pseek/parser.py
 pseek/searcher.py
+pseek/utils.py
 pseek.egg-info/PKG-INFO
 pseek.egg-info/SOURCES.txt
 pseek.egg-info/dependency_links.txt

{pseek-2.1.5 → pseek-2.2.0}/pseek.egg-info/requires.txt

@@ -1 +1,2 @@
 click==8.1.8
+lark==1.2.2

pseek-2.2.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pseek"
+version = "2.2.0"
+description = "Pseek is a Python library to search files, folders, and text"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    {name = "Arian", email = "ariannasiri86@gmail.com"}
+]
+requires-python = ">=3.6"
+dependencies = [
+    "click==8.1.8",
+    "lark==1.2.2"
+]
+urls = {Homepage = "https://github.com/ArianN8610/pysearch"}
+
+[project.scripts]
+pseek = "pseek.cli:search"

pseek-2.1.5/PKG-INFO

@@ -1,105 +0,0 @@
-Metadata-Version: 2.4
-Name: pseek
-Version: 2.1.5
-Summary: Pseek is a Python library to search files, folders, and text
-Home-page: https://github.com/ArianN8610/pysearch
-Author: Arian
-Author-email: ariannasiri86@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: click==8.1.8
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Pseek
-
-## Overview
-
-A powerful command-line tool for searching files, directories, and content inside files efficiently. The tool supports searching by name, content, extensions, and more with advanced filtering options.
-
-## Features
-
-* **Search in file & folder names**
-* **Search inside file contents**
-* **Highlight matches** in terminal output
-* **Optimized for speed** with ThreadPoolExecutor
-* **Cross-platform** (Linux, macOS, Windows)
-
-## Installation
-
-### **1️⃣ Install via `pip` (Recommended)**
-
-```sh
-pip install pseek
-```
-
-### **2️⃣ Install from source**
-
-```sh
-git clone https://github.com/ArianN8610/pysearch.git
-cd pseek
-pip install click==8.1.8
-```
-
-## Usage
-
-Run the command with a search query:
-```sh
-pseek <query> [options]
-```
-
-## Examples
-
-### Search for a keyword in file & folder names
-
-```sh
-pseek "my_keyword" --path /path/to/search --file --directory
-```
-
-### Search inside file contents
-
-```sh
-pseek "error" --path /var/logs --content
-```
-
-### Search only in specific file types
-
-```sh
-pseek "TODO" --path ./projects --ext py --ext txt
-```
-
-### Search by regex
-
-```sh
-pseek "error\d+" --regex
-```
-
-## Command Options
-
-| Option                         | Description                                                      |
-|--------------------------------|------------------------------------------------------------------|
-| `--path`                       | Base directory to search in (default: current directory `.`)     |
-| `--file`                       | Search only in file names                                        |
-| `--directory`                  | Search only in directory names                                   |
-| `--content`                    | Search inside file contents                                      |
-| `--ext`, `--exclude-ext`       | Filter by file extension (e.g., `.txt`, `.log`)                  |
-| `--case-sensitive`             | Make the search case-sensitive                                   |
-| `--regex`                      | Use regular expression for searching                             |
-| `--include`, `--exclude`       | Limit search results to specific set of directories or files     |
-| `--re-include`, `--re-exclude` | Limit search results to specific directories or files with regex |
-| `--word`                       | Match the whole word only                                        |
-| `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories      |
-| `--full-path`                  | Display full path of files and directories                       |
-| `--no-content`                 | Only display files path for content search                       |

pseek-2.1.5/README.md

@@ -1,80 +0,0 @@
-# Pseek
-
-## Overview
-
-A powerful command-line tool for searching files, directories, and content inside files efficiently. The tool supports searching by name, content, extensions, and more with advanced filtering options.
-
-## Features
-
-* **Search in file & folder names**
-* **Search inside file contents**
-* **Highlight matches** in terminal output
-* **Optimized for speed** with ThreadPoolExecutor
-* **Cross-platform** (Linux, macOS, Windows)
-
-## Installation
-
-### **1️⃣ Install via `pip` (Recommended)**
-
-```sh
-pip install pseek
-```
-
-### **2️⃣ Install from source**
-
-```sh
-git clone https://github.com/ArianN8610/pysearch.git
-cd pseek
-pip install click==8.1.8
-```
-
-## Usage
-
-Run the command with a search query:
-```sh
-pseek <query> [options]
-```
-
-## Examples
-
-### Search for a keyword in file & folder names
-
-```sh
-pseek "my_keyword" --path /path/to/search --file --directory
-```
-
-### Search inside file contents
-
-```sh
-pseek "error" --path /var/logs --content
-```
-
-### Search only in specific file types
-
-```sh
-pseek "TODO" --path ./projects --ext py --ext txt
-```
-
-### Search by regex
-
-```sh
-pseek "error\d+" --regex
-```
-
-## Command Options
-
-| Option                         | Description                                                      |
-|--------------------------------|------------------------------------------------------------------|
-| `--path`                       | Base directory to search in (default: current directory `.`)     |
-| `--file`                       | Search only in file names                                        |
-| `--directory`                  | Search only in directory names                                   |
-| `--content`                    | Search inside file contents                                      |
-| `--ext`, `--exclude-ext`       | Filter by file extension (e.g., `.txt`, `.log`)                  |
-| `--case-sensitive`             | Make the search case-sensitive                                   |
-| `--regex`                      | Use regular expression for searching                             |
-| `--include`, `--exclude`       | Limit search results to specific set of directories or files     |
-| `--re-include`, `--re-exclude` | Limit search results to specific directories or files with regex |
-| `--word`                       | Match the whole word only                                        |
-| `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories      |
-| `--full-path`                  | Display full path of files and directories                       |
-| `--no-content`                 | Only display files path for content search                       |

pseek-2.1.5/pseek.egg-info/PKG-INFO

@@ -1,105 +0,0 @@
-Metadata-Version: 2.4
-Name: pseek
-Version: 2.1.5
-Summary: Pseek is a Python library to search files, folders, and text
-Home-page: https://github.com/ArianN8610/pysearch
-Author: Arian
-Author-email: ariannasiri86@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: click==8.1.8
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Pseek
-
-## Overview
-
-A powerful command-line tool for searching files, directories, and content inside files efficiently. The tool supports searching by name, content, extensions, and more with advanced filtering options.
-
-## Features
-
-* **Search in file & folder names**
-* **Search inside file contents**
-* **Highlight matches** in terminal output
-* **Optimized for speed** with ThreadPoolExecutor
-* **Cross-platform** (Linux, macOS, Windows)
-
-## Installation
-
-### **1️⃣ Install via `pip` (Recommended)**
-
-```sh
-pip install pseek
-```
-
-### **2️⃣ Install from source**
-
-```sh
-git clone https://github.com/ArianN8610/pysearch.git
-cd pseek
-pip install click==8.1.8
-```
-
-## Usage
-
-Run the command with a search query:
-```sh
-pseek <query> [options]
-```
-
-## Examples
-
-### Search for a keyword in file & folder names
-
-```sh
-pseek "my_keyword" --path /path/to/search --file --directory
-```
-
-### Search inside file contents
-
-```sh
-pseek "error" --path /var/logs --content
-```
-
-### Search only in specific file types
-
-```sh
-pseek "TODO" --path ./projects --ext py --ext txt
-```
-
-### Search by regex
-
-```sh
-pseek "error\d+" --regex
-```
-
-## Command Options
-
-| Option                         | Description                                                      |
-|--------------------------------|------------------------------------------------------------------|
-| `--path`                       | Base directory to search in (default: current directory `.`)     |
-| `--file`                       | Search only in file names                                        |
-| `--directory`                  | Search only in directory names                                   |
-| `--content`                    | Search inside file contents                                      |
-| `--ext`, `--exclude-ext`       | Filter by file extension (e.g., `.txt`, `.log`)                  |
-| `--case-sensitive`             | Make the search case-sensitive                                   |
-| `--regex`                      | Use regular expression for searching                             |
-| `--include`, `--exclude`       | Limit search results to specific set of directories or files     |
-| `--re-include`, `--re-exclude` | Limit search results to specific directories or files with regex |
-| `--word`                       | Match the whole word only                                        |
-| `--max-size`, `--min-size`     | Specify maximum and minimum sizes for files and directories      |
-| `--full-path`                  | Display full path of files and directories                       |
-| `--no-content`                 | Only display files path for content search                       |

pseek-2.1.5/setup.py

@@ -1,24 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.md", encoding="utf-8") as f:
-    long_description = f.read()
-
-setup(
-    name="pseek",
-    version="2.1.5",
-    author="Arian",
-    author_email="ariannasiri86@gmail.com",
-    description="Pseek is a Python library to search files, folders, and text",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/ArianN8610/pysearch",
-    packages=find_packages(),
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.6",
-    install_requires=["click==8.1.8"],
-    entry_points={"console_scripts": ["pseek=pseek.cli:search"]}
-)