webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/scout/core/search_result.py

@@ -1,96 +1,51 @@
-"""
-Scout Search Result Module
-"""
-
-from typing import List, Union, Callable, Any, Dict, Iterator
-from ..element import Tag
-from .text_analyzer import ScoutTextAnalyzer
-
-
-class ScoutSearchResult:
-    """
-    Represents a search result with advanced querying capabilities.
-    Enhanced with more intelligent filtering and processing.
-    """
-    def __init__(self, results: List[Tag]):
-        """
-        Initialize a search result collection.
-        
-        Args:
-            results (List[Tag]): List of matching tags
-        """
-        self._results = results
-    
-    def __len__(self) -> int:
-        return len(self._results)
-    
-    def __iter__(self) -> Iterator[Tag]:
-        return iter(self._results)
-    
-    def __getitem__(self, index: Union[int, slice]) -> Union[Tag, List[Tag]]:
-        return self._results[index]
-    
-    def texts(self, separator=' ', strip=True) -> List[str]:
-        """
-        Extract texts from all results.
-        
-        Args:
-            separator (str, optional): Text separator
-            strip (bool, optional): Strip whitespace
-        
-        Returns:
-            List[str]: List of extracted texts
-        """
-        return [tag.get_text(separator, strip) for tag in self._results]
-    
-    def attrs(self, attr_name: str) -> List[Any]:
-        """
-        Extract a specific attribute from all results.
-        
-        Args:
-            attr_name (str): Attribute name to extract
-        
-        Returns:
-            List[Any]: List of attribute values
-        """
-        return [tag.get(attr_name) for tag in self._results]
-    
-    def filter(self, predicate: Callable[[Tag], bool]) -> 'ScoutSearchResult':
-        """
-        Filter results using a predicate function.
-        
-        Args:
-            predicate (Callable[[Tag], bool]): Filtering function
-        
-        Returns:
-            ScoutSearchResult: Filtered search results
-        """
-        return ScoutSearchResult([tag for tag in self._results if predicate(tag)])
-    
-    def map(self, transform: Callable[[Tag], Any]) -> List[Any]:
-        """
-        Transform results using a mapping function.
-        
-        Args:
-            transform (Callable[[Tag], Any]): Transformation function
-        
-        Returns:
-            List[Any]: Transformed results
-        """
-        return [transform(tag) for tag in self._results]
-    
-    def analyze_text(self) -> Dict[str, Any]:
-        """
-        Perform text analysis on search results.
-        
-        Returns:
-            Dict[str, Any]: Text analysis results
-        """
-        texts = self.texts(strip=True)
-        full_text = ' '.join(texts)
-        
-        return {
-            'total_results': len(self._results),
-            'word_count': ScoutTextAnalyzer.count_words(full_text),
-            'entities': ScoutTextAnalyzer.extract_entities(full_text)
-        }
+"""
+Scout Search Result Module
+"""
+
+from typing import Any, Callable, Dict, List, Optional
+
+from ..element import Tag
+from .text_analyzer import ScoutTextAnalyzer
+
+
+class ScoutSearchResult(list):
+    """
+    Represents a search result that behaves like a list but with advanced
+    querying capabilities. Highly compatible with BS4 ResultSet.
+    """
+
+    def __init__(self, results: List[Tag]):
+        """
+        Initialize a search result collection.
+
+        Args:
+            results (List[Tag]): List of matching tags
+        """
+        super().__init__(results)
+
+    def texts(self, separator=" ", strip=True) -> List[str]:
+        """Extract texts from all results."""
+        return [tag.get_text(separator, strip) for tag in self]
+
+    def attrs(self, attr_name: str) -> List[Any]:
+        """Extract a specific attribute from all results."""
+        return [tag.get(attr_name) for tag in self]
+
+    def filter(self, predicate: Callable[[Tag], bool]) -> "ScoutSearchResult":
+        """Filter results using a predicate function."""
+        return ScoutSearchResult([tag for tag in self if predicate(tag)])
+
+    def map(self, transform: Callable[[Tag], Any]) -> List[Any]:
+        """Transform results using a mapping function."""
+        return [transform(tag) for tag in self]
+
+    def analyze_text(self) -> Dict[str, Any]:
+        """Perform text analysis on search results."""
+        texts = self.texts(strip=True)
+        full_text = " ".join(texts)
+
+        return {
+            "total_results": len(self),
+            "word_count": ScoutTextAnalyzer.count_words(full_text),
+            "entities": ScoutTextAnalyzer.extract_entities(full_text),
+        }

webscout/scout/core/text_analyzer.py

@@ -1,63 +1,64 @@
-"""
-Scout Text Analyzer Module
-"""
-import re
-from collections import Counter
-from typing import List, Dict, Set
-
-class ScoutTextAnalyzer:
-    """
-    Advanced text analysis and processing utility.
-    """
-    @staticmethod
-    def tokenize(text: str, lowercase=True, remove_punctuation=True) -> List[str]:
-        """
-        Tokenize text into words.
-        
-        Args:
-            text (str): Input text
-            lowercase (bool, optional): Convert to lowercase
-            remove_punctuation (bool, optional): Remove punctuation
-        
-        Returns:
-            List[str]: List of tokens
-        """
-        if lowercase:
-            text = text.lower()
-        
-        if remove_punctuation:
-            text = re.sub(r'[^\w\s]', '', text)
-        
-        return text.split()
-    
-    @staticmethod
-    def count_words(text: str) -> Dict[str, int]:
-        """
-        Count word frequencies.
-        
-        Args:
-            text (str): Input text
-        
-        Returns:
-            Dict[str, int]: Word frequency dictionary
-        """
-        return dict(Counter(ScoutTextAnalyzer.tokenize(text)))
-    
-    @staticmethod
-    def extract_entities(text: str) -> Dict[str, Set[str]]:
-        """
-        Extract named entities from text.
-        
-        Args:
-            text (str): Input text
-        
-        Returns:
-            Dict[str, Set[str]]: Extracted entities
-        """
-        entities = {
-            'emails': set(re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)),
-            'urls': set(re.findall(r'https?://\S+', text)),
-            'phones': set(re.findall(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', text)),
-            'dates': set(re.findall(r'\b\d{1,2}[-/]\d{1,2}[-/]\d{2,4}\b', text))
-        }
-        return entities
+"""
+Scout Text Analyzer Module
+"""
+import re
+from collections import Counter
+from typing import Dict, List, Optional, Set
+
+
+class ScoutTextAnalyzer:
+    """
+    Advanced text analysis and processing utility.
+    """
+    @staticmethod
+    def tokenize(text: str, lowercase=True, remove_punctuation=True) -> List[str]:
+        """
+        Tokenize text into words.
+
+        Args:
+            text (str): Input text
+            lowercase (bool, optional): Convert to lowercase
+            remove_punctuation (bool, optional): Remove punctuation
+
+        Returns:
+            List[str]: List of tokens
+        """
+        if lowercase:
+            text = text.lower()
+
+        if remove_punctuation:
+            text = re.sub(r'[^\w\s]', '', text)
+
+        return text.split()
+
+    @staticmethod
+    def count_words(text: str) -> Dict[str, int]:
+        """
+        Count word frequencies.
+
+        Args:
+            text (str): Input text
+
+        Returns:
+            Dict[str, int]: Word frequency dictionary
+        """
+        return dict(Counter(ScoutTextAnalyzer.tokenize(text)))
+
+    @staticmethod
+    def extract_entities(text: str) -> Dict[str, Set[str]]:
+        """
+        Extract named entities from text.
+
+        Args:
+            text (str): Input text
+
+        Returns:
+            Dict[str, Set[str]]: Extracted entities
+        """
+        entities = {
+            'emails': set(re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)),
+            'urls': set(re.findall(r'https?://\S+', text)),
+            'phones': set(re.findall(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', text)),
+            'dates': set(re.findall(r'\b\d{1,2}[-/]\d{1,2}[-/]\d{2,4}\b', text))
+        }
+        return entities