pseek 1.0.2__tar.gz → 2.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pseek
-Version: 1.0.2
+Version: 2.0.0
 Summary: Pseek is a Python library to search files, folders, and text
 Home-page: https://github.com/ArianN8610/pysearch
 Author: Arian

{pseek-1.0.2 → pseek-2.0.0}/pseek/cli.py

@@ -1,8 +1,5 @@
-import re
 import click
-
-from .utils import display_results
-from .searcher import search_in_names, search_in_file_contents
+from .searcher import Search
 
 
 @click.command()
@@ -28,36 +25,22 @@ def search(query, path, file, directory, content, case_sensitive, ext, regex, in
            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 = []
+    count_results = 0
+    search_class = Search(path, query, case_sensitive, ext, regex, include, exclude, word, max_size, min_size,
+                          full_path)
 
     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)
+        count_results += search_class.search('file').echo('Files', 'file')
     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)
+        count_results += search_class.search('directory').echo('Directories', 'directory')
     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)
+        count_results += search_class.search('content').echo('Contents', 'content')
 
-    message = f'\nTotal results: {len(results)}' if results else 'No results found'
+    message = f'\nTotal results: {count_results}' if count_results else 'No results found'
     click.echo(click.style(message, fg='red'))  # Display total of results
 
 

pseek-2.0.0/pseek/searcher.py

@@ -0,0 +1,146 @@
+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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pseek
-Version: 1.0.2
+Version: 2.0.0
 Summary: Pseek is a Python library to search files, folders, and text
 Home-page: https://github.com/ArianN8610/pysearch
 Author: Arian

{pseek-1.0.2 → pseek-2.0.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.0.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.0.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/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'))