pseek 1.0.2__tar.gz → 2.1.0__tar.gz

{pseek-1.0.2 → pseek-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pseek
-Version: 1.0.2
+Version: 2.1.0
 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-1.0.2 → pseek-2.1.0}/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.0/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.0/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).resolve()
+        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-1.0.2 → pseek-2.1.0}/pseek.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pseek
-Version: 1.0.2
+Version: 2.1.0
 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-1.0.2 → pseek-2.1.0}/pseek.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ setup.py
 pseek/__init__.py
 pseek/cli.py
 pseek/searcher.py
-pseek/utils.py
 pseek.egg-info/PKG-INFO
 pseek.egg-info/SOURCES.txt
 pseek.egg-info/dependency_links.txt

{pseek-1.0.2 → pseek-2.1.0}/setup.py

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

pseek-1.0.2/pseek/cli.py

@@ -1,65 +0,0 @@
-import re
-import click
-
-from .utils import display_results
-from .searcher import search_in_names, search_in_file_contents
-
-
-@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."""
-
-    if regex:
-        try:
-            re.compile(query)  # Ensure valid regex
-        except re.error:
-            click.echo(click.style('Invalid regex pattern: ', fg='red') + query)
-            return
-
-    # Enable all search types if none are explicitly selected
-    if not any([file, directory, content]):
-        file = directory = content = True
-
-    results = []
-
-    if file:
-        filename_results = search_in_names(path, query, case_sensitive, regex, include, exclude, word, max_size,
-                                           min_size, full_path, ext)
-        display_results(filename_results, 'Files', 'file')
-        results.extend(filename_results)
-    if directory and not ext:
-        dir_results = search_in_names(path, query, case_sensitive, regex, include, exclude, word, max_size, min_size,
-                                      full_path, is_file=False)
-        display_results(dir_results, 'Directories', 'directory')
-        results.extend(dir_results)
-    if content:
-        content_results = search_in_file_contents(path, query, case_sensitive, ext, regex, include, exclude, word,
-                                                  max_size, min_size, full_path)
-        display_results(content_results, 'Contents', 'content')
-        results.extend(content_results)
-
-    message = f'\nTotal results: {len(results)}' if results else 'No results found'
-    click.echo(click.style(message, fg='red'))  # Display total of results
-
-
-if __name__ == "__main__":
-    search()

pseek-1.0.2/pseek/searcher.py

@@ -1,109 +0,0 @@
-import re
-import click
-from pathlib import Path
-from concurrent.futures import ThreadPoolExecutor
-
-from .utils import highlight_matches, safe_is_file
-
-
-def search_in_names(base_path, query, case_sensitive, regex, include, exclude, whole_word, max_size, min_size,
-                    full_path, ext=tuple(), is_file=True):
-    """Search for file and folder names"""
-    base_path = Path(base_path)
-    matches = []
-
-    if not regex:
-        query = re.escape(query)  # If regex is disabled, convert query to plain text
-
-    if whole_word:
-        query = rf'\b{query}\b'  # Ensure search for whole words
-
-    flags = 0 if case_sensitive else re.IGNORECASE  # Adjust case sensitivity
-
-    # Convert include and exclude paths to `Path`
-    include_paths = {Path(p).resolve() for p in include}
-    exclude_paths = {Path(p).resolve() for p in exclude}
-
-    for p in base_path.rglob('*'):
-        p_resolved = p.resolve()  # Actual file or folder path
-        try:
-            p_size_mb = p_resolved.stat().st_size / 1_048_576  # Convert to MB
-        except OSError:
-            continue  # if path cannot be accessible
-
-        if (
-                # If include is given, at least one of them must be present in the name
-                (include and not any(p_resolved.is_relative_to(inc) for inc in include_paths))
-                # If exclude is given, none should be in the name
-                or (exclude and any(p_resolved.is_relative_to(exc) for exc in exclude_paths))
-                # Prevent unnecessary continuation in case of type mismatch
-                or (is_file and ext and p.suffix[1:] not in ext)
-                # Check file or directory size
-                or (max_size and p_size_mb > max_size)
-                or (min_size and p_size_mb < min_size)
-        ):
-            continue
-
-        if re.search(query, p.name, flags) and ((is_file and p.is_file()) or (not is_file and p.is_dir())):
-            # Specify the found part
-            highlighted_name = re.sub(query, lambda m: click.style(m.group(), fg='green'), p.name, flags=flags)
-            p_parent = p_resolved.parent if full_path else p.parent  # Get full path if full_path is True
-            matches.append(f'{p_parent}\\{highlighted_name}')
-
-    return matches
-
-
-def search_in_file_contents(base_path, query, case_sensitive, ext, regex, include, exclude, whole_word,
-                            max_size, min_size, full_path):
-    """Search inside file contents"""
-    base_path = Path(base_path)
-    matches = []
-
-    if not regex:
-        query = re.escape(query)
-
-    if whole_word:
-        query = rf'\b{query}\b'
-
-    flags = 0 if case_sensitive else re.IGNORECASE
-
-    include_paths = {Path(p).resolve() for p in include}
-    exclude_paths = {Path(p).resolve() for p in exclude}
-
-    def process_file(file_path):
-        """Processes a single file and searches for the query inside its content."""
-        p_resolved = file_path.resolve()
-        p_size_mb = p_resolved.stat().st_size / 1_048_576
-
-        if (
-                # Filter by include/exclude directories
-                (include and not any(p_resolved.is_relative_to(inc) for inc in include_paths))
-                or (exclude and any(p_resolved.is_relative_to(exc) for exc in exclude_paths))
-                # Filter by extension
-                or (ext and p_resolved.suffix[1:] not in ext)
-                # Filter by file size
-                or (max_size and p_size_mb > max_size)
-                or (min_size and p_size_mb < min_size)
-        ):
-            return
-
-        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):
-                    highlighted_snippet, count_query = highlight_matches(line, query, case_sensitive, regex, whole_word)
-                    file_path = p_resolved if full_path else file_path
-                    matches.append(
-                        click.style(file_path, fg='cyan')
-                        + click.style(f' (Line {num}) (Repeated {count_query} time(s)): ', fg='magenta')
-                        + highlighted_snippet
-                    )
-        except Exception:
-            return  # Ignore unreadable files
-
-    # Use multi-threading for faster processing
-    with ThreadPoolExecutor() as executor:
-        executor.map(process_file, (file for file in base_path.rglob('*') if safe_is_file(file)))
-
-    return matches

pseek-1.0.2/pseek/utils.py

@@ -1,66 +0,0 @@
-import re
-import click
-
-
-def highlight_matches(line, query, case_sensitive, regex, whole_word, context=20):
-    """Highlight matches and truncate long lines with proper handling"""
-
-    flags = 0 if case_sensitive else re.IGNORECASE
-
-    if not regex and not whole_word:
-        query = re.escape(query)  # If regex is disabled, use escape to search for regular text
-
-    # Find all matches
-    matches = list(re.finditer(query, line, flags))
-
-    if not matches:
-        return None  # If there is no match, return None
-
-    start_positions = [max(0, m.start() - context) for m in matches]  # 20 characters before
-    end_positions = [min(len(line), m.end() + context) for m in matches]  # 20 characters after
-
-    # Combine sections close together to avoid repetition
-    merged_snippets = []
-    current_start, current_end = start_positions[0], end_positions[0]
-
-    for i in range(1, len(matches)):
-        if start_positions[i] <= current_end:  # If the next section is close, combine them
-            current_end = max(current_end, end_positions[i])
-        else:
-            merged_snippets.append((current_start, current_end))
-            current_start, current_end = start_positions[i], end_positions[i]
-
-    merged_snippets.append((current_start, current_end))  # Add the last section
-
-    result = []
-    for start, end in merged_snippets:
-        snippet = line[start:end]
-        snippet = re.sub(query, lambda m: click.style(m.group(), fg='green'), snippet, flags=flags)
-        result.append(snippet)
-
-    final_output = ' ... '.join(result)  # If there are multiple results, put `...` between them
-
-    # Add `...` at the beginning and end if needed
-    if merged_snippets[0][0] > 0:
-        final_output = '...' + final_output
-    if merged_snippets[-1][1] < len(line):
-        final_output += '...'
-
-    return final_output, len(matches)  # Count the number of repetitions
-
-
-def safe_is_file(file):
-    """Check if a file is accessible and return True/False."""
-    try:
-        return file.is_file()
-    except OSError:
-        return False  # Ignore files that cannot be accessed
-
-
-def display_results(results, title, result_name):
-    """Display search results"""
-    if results:
-        click.echo(click.style(f'\n{title}:\n', fg='yellow'))
-        for result in results:
-            click.echo(result)
-        click.echo(click.style(f'\n{len(results)} result(s) found for {result_name}', fg='blue'))