pseek 2.0.0__tar.gz → 2.1.1__tar.gz

{pseek-2.0.0 → pseek-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pseek
-Version: 2.0.0
+Version: 2.1.1
 Summary: Pseek is a Python library to search files, folders, and text
 Home-page: https://github.com/ArianN8610/pysearch
 Author: Arian
@@ -93,7 +93,7 @@ pseek "error\d+" --regex
 | `--file`                   | Search only in file names                                    |
 | `--directory`              | Search only in directory names                               |
 | `--content`                | Search inside file contents                                  |
-| `--ext`                    | Filter by file extension (e.g., `.txt`, `.log`)              |
+| `--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 |

{pseek-2.0.0 → pseek-2.1.1}/README.md

@@ -69,7 +69,7 @@ pseek "error\d+" --regex
 | `--file`                   | Search only in file names                                    |
 | `--directory`              | Search only in directory names                               |
 | `--content`                | Search inside file contents                                  |
-| `--ext`                    | Filter by file extension (e.g., `.txt`, `.log`)              |
+| `--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 |

pseek-2.1.1/pseek/cli.py

@@ -0,0 +1,73 @@
+import click
+from .searcher import Search
+
+
+@click.command()
+@click.argument('query')
+@click.option('-p', '--path', type=click.Path(exists=True, file_okay=False, dir_okay=True),
+              default='.', show_default=True, help='Base directory to search in.')
+# Search type options
+@click.option('-f', '--file', is_flag=True, help='Search only in file names.')
+@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('--word', is_flag=True, help='Match whole words only.')
+# Extension filters
+@click.option('--ext', multiple=True, type=click.STRING,
+              help='Include files with these extensions. Example: --ext py --ext js')
+@click.option('-E', '--exclude-ext', multiple=True, type=click.STRING,
+              help='Exclude files with these extensions. Example: --exclude-ext jpg --exclude-ext exe')
+# Include/Exclude specific paths (files or directories)
+@click.option('-i', '--include', type=click.Path(exists=True, file_okay=True, dir_okay=True),
+              multiple=True, help='Directories or files to include in search.')
+@click.option('-e', '--exclude', type=click.Path(exists=True, file_okay=True, dir_okay=True),
+              multiple=True, help='Directories or files to exclude from search.')
+# Size filters
+@click.option('--max-size', type=click.FLOAT, help='Maximum file/directory size (in MB).')
+@click.option('--min-size', type=click.FLOAT, help='Minimum file/directory size (in MB).')
+# Output option
+@click.option('--full-path', is_flag=True, help='Display full paths for results.')
+def search(query, path, file, directory, content, case_sensitive, ext, exclude_ext, regex,
+           include, exclude, word, max_size, min_size, full_path):
+    """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)):
+        file = directory = content = True
+
+    # Initialize the Search class with provided options.
+    search_instance = Search(
+        base_path=path,
+        query=query,
+        case_sensitive=case_sensitive,
+        ext=ext,
+        exclude_ext=exclude_ext,
+        regex=regex,
+        include=include,
+        exclude=exclude,
+        whole_word=word,
+        max_size=max_size,
+        min_size=min_size,
+        full_path=full_path
+    )
+
+    total_results = 0
+
+    # Search for files if requested.
+    if file:
+        total_results += search_instance.search('file').echo('Files', 'file')
+    # Search for directories if requested and extension filters are not active.
+    if directory and not (ext or exclude_ext):
+        total_results += search_instance.search('directory').echo('Directories', 'directory')
+    # Search for content inside files if requested.
+    if content:
+        total_results += search_instance.search('content').echo('Contents', 'content')
+
+    # Display final summary message.
+    message = f'\nTotal results: {total_results}' if total_results else 'No results found'
+    click.echo(click.style(message, fg='red'))
+
+
+if __name__ == "__main__":
+    search()

pseek-2.1.1/pseek/searcher.py

@@ -0,0 +1,182 @@
+import re
+import sys
+import click
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor
+
+# Extensions that are not suitable for content search (binary, media, etc.)
+EXCLUDED_EXTENSIONS = {
+    'jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp', 'svg',
+    'mp4', 'mov', 'avi', 'mkv', 'webm', 'flv', 'm4v', 'mpg', 'wmv',
+    'mp3', 'wav', 'ogg', 'flac', 'aac', 'wma', 'opus',
+    'exe', 'dll', 'bin', 'iso', 'img', 'dat', 'dmg', 'class', 'so', 'o', 'obj',
+    'zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz',
+    'ttf', 'otf', 'woff', 'woff2', 'eot',
+    'db', 'sqlite', 'mdf', 'bak', 'log', 'jsonl', 'dat',
+    'apk', 'ipa', 'deb', 'rpm', 'pkg', 'appimage', 'jar', 'war',
+    'pyc', 'ps1', 'pem', 'pyd', 'whl'
+}
+
+
+class Search:
+    def __init__(self, base_path, query, case_sensitive, ext, exclude_ext, regex, include, exclude, whole_word,
+                 max_size, min_size, full_path):
+        """Initialize search parameters"""
+        self.base_path = base_path
+        self.query = query
+        self.case_sensitive = case_sensitive
+        self.ext = ext
+        self.exclude_ext = exclude_ext
+        self.regex = regex
+        self.include = include
+        self.exclude = exclude
+        self.whole_word = whole_word
+        self.max_size = max_size
+        self.min_size = min_size
+        self.full_path = full_path
+        self.result = None
+
+    def conditions(self, p_resolved: Path, search_type: str) -> bool:
+        """
+        Check whether the file/directory should be skipped based on various filters.
+        Returns True if the path should be skipped.
+        """
+        try:
+            p_size_mb = p_resolved.stat().st_size / 1_048_576  # Convert size to MB
+        except OSError:
+            # If path is inaccessible, skip it.
+            return True
+
+        # Prepare include/exclude sets as resolved Paths
+        include_paths = {Path(p).resolve() for p in self.include}
+        exclude_paths = {Path(p).resolve() for p in self.exclude}
+
+        file_ext = p_resolved.suffix[1:]
+
+        # Conditions for skipping:
+        if (include_paths and not any(p_resolved.is_relative_to(inc) for inc in include_paths)) \
+                or (exclude_paths and any(p_resolved.is_relative_to(exc) for exc in exclude_paths)) \
+                or (self.ext and file_ext not in self.ext) \
+                or (self.exclude_ext and file_ext in self.exclude_ext) \
+                or (search_type == 'content' and file_ext in EXCLUDED_EXTENSIONS) \
+                or (self.max_size and p_size_mb > self.max_size) \
+                or (self.min_size and p_size_mb < self.min_size) \
+                or ((search_type in ('file', 'content')) and not p_resolved.is_file()) \
+                or (search_type == 'directory' and not p_resolved.is_dir()):
+            return True
+
+        return False
+
+    def search(self, search_type: str):
+        """Main search function. search_type can be 'file', 'directory' or 'content'"""
+        base_path = Path(self.base_path)
+        query = self.query
+
+        # Prepare query: escape if not regex
+        if not self.regex:
+            query = re.escape(query)
+        else:
+            try:
+                re.compile(query)  # Validate regex pattern
+            except re.error:
+                click.echo(click.style('Invalid regex pattern: ', fg='red') + query)
+                sys.exit(1)
+
+        # 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
+
+        # Precompile the regex pattern for performance
+        try:
+            pattern = re.compile(query, flags)
+        except re.error as e:
+            click.echo(click.style(f"Regex compile error: {e}", fg='red'))
+            sys.exit(1)
+
+        if search_type in ('file', 'directory'):
+            matches = []
+            for p in base_path.rglob('*'):
+                try:
+                    p_resolved = p.resolve()
+                except Exception:
+                    continue
+                # Skip if conditions fail or if name doesn't match the query
+                if self.conditions(p_resolved, search_type) or not pattern.search(p.name):
+                    continue
+
+                # Highlight matched query in the name
+                highlighted_name = pattern.sub(lambda m: click.style(m.group(), fg='green'), 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:  # For content search
+            # Use dictionary: key: file path (colored), value: list of line matches
+            matches = {}
+
+            def process_file(file_path: Path):
+                """Process a single file for content search"""
+                try:
+                    p_resolved = file_path.resolve()
+                except Exception:
+                    return
+
+                # Skip file if any filter condition is met
+                if self.conditions(p_resolved, 'content'):
+                    return
+
+                line_matches = []
+                try:
+                    # Read file line by line
+                    with open(p_resolved, 'r', encoding='utf-8', errors='ignore') as f:
+                        for num, line in enumerate(f, 1):
+                            line = line.strip()
+                            if pattern.search(line):
+                                # Count occurrences of query in line
+                                count = len(list(pattern.finditer(line)))
+                                highlighted_line = pattern.sub(lambda m: click.style(m.group(), fg='green'), line)
+                                count_query = f'- Repeated {count} times' if count >= 3 else ''
+                                line_matches.append(
+                                    click.style(f'Line {num}{count_query}: ', fg='magenta') + highlighted_line
+                                )
+                except Exception:
+                    return  # Skip unreadable files
+
+                if line_matches:
+                    file_label = str(p_resolved) if self.full_path else str(file_path)
+                    # Use colored file path as key
+                    matches[click.style(file_label, fg='cyan')] = line_matches
+
+            # Create a list of files to process (filter out inaccessible ones early)
+            files_to_process = [file for file in base_path.rglob('*')]
+            with ThreadPoolExecutor() as executor:
+                executor.map(process_file, files_to_process)
+
+        self.result = matches
+        return self
+
+    def echo(self, title: str, result_name: str) -> int:
+        """
+        Display the search results with a title.
+        Returns the count of results.
+        """
+        count_result = 0
+
+        if self.result:
+            click.echo(click.style(f'\n{title}:\n', fg='yellow'))
+            if isinstance(self.result, dict):
+                # For content search results
+                for key, value in self.result.items():
+                    click.echo(key)
+                    click.echo('\n'.join(value) + '\n')
+                    count_result += len(value)
+            else:
+                # For file/directory search results
+                count_result = len(self.result)
+                click.echo('\n'.join(self.result))
+
+            if count_result >= 3:
+                click.echo(click.style(f'\n{count_result} results found for {result_name}', fg='blue'))
+
+        return count_result

{pseek-2.0.0 → pseek-2.1.1}/pseek.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pseek
-Version: 2.0.0
+Version: 2.1.1
 Summary: Pseek is a Python library to search files, folders, and text
 Home-page: https://github.com/ArianN8610/pysearch
 Author: Arian
@@ -93,7 +93,7 @@ pseek "error\d+" --regex
 | `--file`                   | Search only in file names                                    |
 | `--directory`              | Search only in directory names                               |
 | `--content`                | Search inside file contents                                  |
-| `--ext`                    | Filter by file extension (e.g., `.txt`, `.log`)              |
+| `--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 |

{pseek-2.0.0 → pseek-2.1.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="pseek",
-    version="2.0.0",
+    version="2.1.1",
     author="Arian",
     author_email="ariannasiri86@gmail.com",
     description="Pseek is a Python library to search files, folders, and text",

pseek-2.0.0/pseek/cli.py

@@ -1,48 +0,0 @@
-import click
-from .searcher import Search
-
-
-@click.command()
-@click.argument('query')
-@click.option('-p', '--path', type=click.Path(exists=True, file_okay=False, dir_okay=True), default='.',
-              show_default=True, help='Base directory to search in.')
-@click.option('-f', '--file', is_flag=True, help='Search only in file names.')
-@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.')
-@click.option('-C', '--case-sensitive', is_flag=True, help='Make the search case-sensitive.')
-@click.option('--ext', multiple=True, type=click.STRING,
-              help='Filter results by file extension. Example: --ext py --ext js')
-@click.option('--regex', is_flag=True, help='Use regular expression for searching.')
-@click.option('-i', '--include', type=click.Path(exists=True, file_okay=True, dir_okay=True),
-              multiple=True, help='Directories or files that contain search results.')
-@click.option('-e', '--exclude', type=click.Path(exists=True, file_okay=True, dir_okay=True),
-              multiple=True, help='Directories or files not included in search results.')
-@click.option('--word', is_flag=True, help='Search for results that match the whole word.')
-@click.option('--max-size', type=click.FLOAT, help='Maximum size directory or file can have (MB)')
-@click.option('--min-size', type=click.FLOAT, help='Minimum size directory or file can have (MB)')
-@click.option('--full-path', is_flag=True, help='Display complete paths of files and directories.')
-def search(query, path, file, directory, content, case_sensitive, ext, regex, include, exclude, word,
-           max_size, min_size, full_path):
-    """Search for files, directories, and content based on the query."""
-
-    # Enable all search types if none are explicitly selected
-    if not any([file, directory, content]):
-        file = directory = content = True
-
-    count_results = 0
-    search_class = Search(path, query, case_sensitive, ext, regex, include, exclude, word, max_size, min_size,
-                          full_path)
-
-    if file:
-        count_results += search_class.search('file').echo('Files', 'file')
-    if directory and not ext:
-        count_results += search_class.search('directory').echo('Directories', 'directory')
-    if content:
-        count_results += search_class.search('content').echo('Contents', 'content')
-
-    message = f'\nTotal results: {count_results}' if count_results else 'No results found'
-    click.echo(click.style(message, fg='red'))  # Display total of results
-
-
-if __name__ == "__main__":
-    search()

pseek-2.0.0/pseek/searcher.py

@@ -1,146 +0,0 @@
-import re
-import sys
-import click
-from pathlib import Path
-from concurrent.futures import ThreadPoolExecutor
-
-
-class Search:
-    def __init__(self, base_path, query, case_sensitive, ext, regex, include, exclude, whole_word,
-                 max_size, min_size, full_path):
-        self.base_path = base_path
-        self.query = query
-        self.case_sensitive = case_sensitive
-        self.ext = ext
-        self.regex = regex
-        self.include = include
-        self.exclude = exclude
-        self.whole_word = whole_word
-        self.max_size = max_size
-        self.min_size = min_size
-        self.full_path = full_path
-
-        self.result = []
-
-    def conditions(self, p_resolved: Path, search_type: str) -> bool:
-        """Check the correctness of path based on data"""
-
-        try:
-            p_size_mb = p_resolved.stat().st_size / 1_048_576  # Convert to MB
-        except OSError:
-            return True  # if path cannot be accessible
-
-        # Convert include and exclude paths to `Path`
-        include_paths = {Path(p).resolve() for p in self.include}
-        exclude_paths = {Path(p).resolve() for p in self.exclude}
-
-        if (
-                # Filter by include/exclude directories and files
-                (self.include and not any(p_resolved.is_relative_to(inc) for inc in include_paths))
-                or (self.exclude and any(p_resolved.is_relative_to(exc) for exc in exclude_paths))
-                # Filter by extension
-                or (self.ext and p_resolved.suffix[1:] not in self.ext)
-                # Filter by file size
-                or (self.max_size and p_size_mb > self.max_size)
-                or (self.min_size and p_size_mb < self.min_size)
-                # Filter by path type
-                or ((search_type == 'file' or search_type == 'content') and not p_resolved.is_file())
-                or (search_type == 'directory' and not p_resolved.is_dir())
-        ):
-            return True
-
-        return False
-
-    def search(self, search_type: str):
-        """Search for paths based on the query"""
-
-        base_path = Path(self.base_path)
-        query = self.query
-
-        if not self.regex:
-            query = re.escape(query)  # If regex is disabled, convert query to plain text
-        else:
-            try:
-                re.compile(query)  # Ensure valid regex
-            except re.error:
-                click.echo(click.style('Invalid regex pattern: ', fg='red') + query)
-                sys.exit(1)  # Exit the program with error code
-
-        if self.whole_word:
-            query = rf'\b{query}\b'  # Ensure search for whole words
-
-        flags = 0 if self.case_sensitive else re.IGNORECASE  # Adjust case sensitivity
-
-        if search_type == 'file' or search_type == 'directory':
-            matches = []
-            for p in base_path.rglob('*'):
-                p_resolved = p.resolve()  # Actual file or folder path
-                if self.conditions(p_resolved, search_type) or (not re.search(query, p.name, flags)):
-                    continue
-
-                # Specify the found part
-                highlighted_name = re.sub(query, lambda m: click.style(m.group(), fg='green'), p.name, flags=flags)
-                # Get full path if full_path is True
-                p_parent = p_resolved.parent if self.full_path else p.parent
-
-                matches.append(f'{p_parent}\\{highlighted_name}')
-        else:
-            matches = dict()
-            def process_file(file_path):
-                """Processes a single file and searches for the query inside its content."""
-                p_resolved = file_path.resolve()
-                line_matches = []
-
-                try:
-                    for num, line in enumerate(p_resolved.read_text(encoding='utf-8', errors='ignore').splitlines(), 1):
-                        line = line.strip()
-                        if re.search(query, line, flags):
-                            # Count query in each line
-                            count_query = len(list(re.finditer(query, line, flags)))
-                            highlighted_name = re.sub(query, lambda m: click.style(m.group(), fg='green'), line,
-                                                      flags=flags)
-                            count_query = f'- Repeated {count_query} times' if count_query >= 3 else ''
-
-                            line_matches.append(
-                                click.style(f'Line {num}{count_query}: ', fg='magenta')
-                                + highlighted_name
-                            )
-                except Exception:
-                    return  # Ignore unreadable files
-
-                if line_matches:
-                    file_path = p_resolved if self.full_path else file_path
-                    matches.update({click.style(file_path, fg='cyan'): line_matches})
-
-            # Use multi-threading for faster processing
-            with ThreadPoolExecutor() as executor:
-                executor.map(
-                    process_file,
-                    (file for file in base_path.rglob('*') if not self.conditions(file, 'content'))
-                )
-
-        self.result = matches
-        return self
-
-    def echo(self, title: str, result_name: str) -> int:
-        """Display search results"""
-        count_result = 0
-
-        if self.result:
-            click.echo(click.style(f'\n{title}:\n', fg='yellow'))
-
-            if isinstance(self.result, dict):
-                # Display for content results
-                for key, value in self.result.items():
-                    click.echo(key)
-                    click.echo('\n'.join(value) + '\n')
-                    count_result += len(value)
-            else:
-                # Display for directory and file results
-                count_result = len(self.result)
-                click.echo('\n'.join(self.result))
-
-            if count_result >= 3:
-                click.echo(click.style(f'\n{count_result} results found for {result_name}', fg='blue'))
-
-        return count_result