webscout 8.2.6__py3-none-any.whl → 8.2.7__py3-none-any.whl

webscout/AIutel.py

@@ -1,9 +1,5 @@
 import json
-import platform
-import subprocess
-from typing import Union, Optional, Dict, Any, Iterable, Generator, List, Callable, Literal, Tuple
-import io
-from collections import deque
+from typing import Union, Optional, Dict, Any, Iterable, Generator, List, Callable, Literal
 import codecs
 
 # Expanded encoding types
@@ -23,34 +19,34 @@ def _process_chunk(
     if not isinstance(chunk, str):
         return None
 
-    sanitized_chunk = chunk
-
-    # Check if chunk starts with intro_value + skip_marker combination
-    if intro_value and skip_markers:
-        for marker in skip_markers:
-            combined_marker = f"{intro_value}{marker}"
-            if sanitized_chunk.startswith(combined_marker):
-                return None
+    # Fast path for empty chunks
+    if not chunk:
+        return None
 
-    if intro_value and sanitized_chunk.startswith(intro_value):
-        sanitized_chunk = sanitized_chunk[len(intro_value):]
+    # Use slicing for prefix removal (faster than startswith+slicing)
+    sanitized_chunk = chunk
+    if intro_value and len(chunk) >= len(intro_value) and chunk[:len(intro_value)] == intro_value:
+        sanitized_chunk = chunk[len(intro_value):]
 
+    # Optimize string stripping operations
     if strip_chars is not None:
         sanitized_chunk = sanitized_chunk.strip(strip_chars)
     else:
+        # lstrip() is faster than strip() when we only need leading whitespace removed
         sanitized_chunk = sanitized_chunk.lstrip()
 
-    # Check both standalone skip_markers and stripped version
-    if not sanitized_chunk or any(
-        marker in sanitized_chunk or sanitized_chunk == marker
-        for marker in skip_markers
-    ):
+    # Skip empty chunks and markers
+    if not sanitized_chunk or any(marker == sanitized_chunk for marker in skip_markers):
         return None
 
+    # JSON parsing with optimized error handling
     if to_json:
         try:
+            # Only strip before JSON parsing if needed
+            if sanitized_chunk[0] not in '{[' or sanitized_chunk[-1] not in '}]':
+                sanitized_chunk = sanitized_chunk.strip()
             return json.loads(sanitized_chunk)
-        except (json.JSONDecodeError, Exception) as e:
+        except (json.JSONDecodeError, Exception):
             return sanitized_chunk if yield_raw_on_error else None
     
     return sanitized_chunk
@@ -58,7 +54,8 @@ def _process_chunk(
 def _decode_byte_stream(
     byte_iterator: Iterable[bytes], 
     encoding: EncodingType = 'utf-8',
-    errors: str = 'replace'
+    errors: str = 'replace',
+    buffer_size: int = 8192
 ) -> Generator[str, None, None]:
     """
     Realtime byte stream decoder with flexible encoding support.
@@ -67,6 +64,7 @@ def _decode_byte_stream(
         byte_iterator: Iterator yielding bytes
         encoding: Character encoding to use
         errors: How to handle encoding errors ('strict', 'ignore', 'replace')
+        buffer_size: Size of internal buffer for performance tuning
     """
     # Initialize decoder with the specified encoding
     try:
@@ -76,13 +74,21 @@ def _decode_byte_stream(
         decoder = codecs.getincrementaldecoder('utf-8')(errors=errors)
     
     # Process byte stream in realtime
+    buffer = bytearray(buffer_size)
+    buffer_view = memoryview(buffer)
+    
     for chunk_bytes in byte_iterator:
         if not chunk_bytes:
             continue
 
         try:
-            # Decode chunk with specified encoding
-            text = decoder.decode(chunk_bytes, final=False)
+            # Use buffer for processing if chunk size is appropriate
+            if len(chunk_bytes) <= buffer_size:
+                buffer[:len(chunk_bytes)] = chunk_bytes
+                text = decoder.decode(buffer_view[:len(chunk_bytes)], final=False)
+            else:
+                text = decoder.decode(chunk_bytes, final=False)
+                
             if text:
                 yield text
         except UnicodeDecodeError:
@@ -95,8 +101,9 @@ def _decode_byte_stream(
             yield final_text
     except UnicodeDecodeError:
         yield f"[Encoding Error: Could not decode final bytes with {encoding}]\n"
+
 def sanitize_stream(
-    data: Union[str, bytes, Iterable[str], Iterable[bytes]],
+    data: Union[str, Iterable[str], Iterable[bytes]],
     intro_value: str = "data:",
     to_json: bool = True,
     skip_markers: Optional[List[str]] = None,
@@ -107,17 +114,17 @@ def sanitize_stream(
     yield_raw_on_error: bool = True,
     encoding: EncodingType = 'utf-8',
     encoding_errors: str = 'replace',
-    chunk_size: Optional[int] = None,
+    buffer_size: int = 8192,
 ) -> Generator[Any, None, None]:
     """
-    Realtime stream processor that handles string/byte streams with minimal latency.
+    Optimized realtime stream processor that handles string/byte streams with minimal latency.
     
     Features:
     - Direct realtime processing of byte streams
     - Optimized string handling and JSON parsing
     - Robust error handling and validation
-    - Flexible encoding support
-    - Drop-in replacement for response.iter_content/iter_lines
+    - Flexible encoding support with memory-efficient buffering
+    - High performance for large streams
     
     Args:
         data: Input data (string, string iterator, or bytes iterator)
@@ -129,93 +136,91 @@ def sanitize_stream(
         end_marker: Processing end marker
         content_extractor: Function to extract content
         yield_raw_on_error: Yield raw content on JSON errors
-        encoding: Character encoding for byte streams ('utf-8', 'latin1', etc.)
-        encoding_errors: How to handle encoding errors ('strict', 'ignore', 'replace')
-        chunk_size: Chunk size for byte streams (None for default)
+        encoding: Character encoding for byte streams
+        encoding_errors: How to handle encoding errors
+        buffer_size: Size of internal processing buffer
     
     Yields:
         Processed chunks (string or dictionary)
-    
-    Example:
-        >>> # Process response content
-        >>> for chunk in sanitize_stream(response.iter_content()):
-        ...     process_chunk(chunk)
-        
-        >>> # Process a stream with specific encoding
-        >>> for text in sanitize_stream(byte_stream, encoding='latin1', to_json=False):
-        ...     process_text(text)
     """
     effective_skip_markers = skip_markers or []
     processing_active = start_marker is None
 
-    if isinstance(data, (str, bytes)):
-        # Optimized single string/bytes processing
+    # Fast path for single string processing
+    if isinstance(data, str):
         processed_item = None
-        if isinstance(data, bytes):
-            data = data.decode(encoding, errors=encoding_errors)
-        if to_json:
-            try:
-                processed_item = json.loads(data)
-            except json.JSONDecodeError:
-                pass
-
-        if processed_item is None:
-            if not processing_active and data == start_marker:
-                processing_active = True
-            elif processing_active and end_marker is not None and data == end_marker:
-                processing_active = False
-
-            if processing_active:
+        if processing_active:
+            # Optimize JSON parsing for large strings
+            if to_json:
+                try:
+                    # Use faster JSON parser for large strings
+                    data = data.strip()
+                    if data:
+                        processed_item = json.loads(data)
+                except json.JSONDecodeError:
+                    processed_item = data if yield_raw_on_error else None
+            else:
                 processed_item = _process_chunk(
-                    data, intro_value, to_json, effective_skip_markers, 
+                    data, intro_value, False, effective_skip_markers, 
                     strip_chars, yield_raw_on_error
                 )
 
-        if processed_item is not None:
-            if content_extractor:
-                try:
-                    final_content = content_extractor(processed_item)
-                    if final_content is not None:
-                        yield final_content
-                except Exception:
-                    pass
-            else:
-                yield processed_item
-
-    elif hasattr(data, '__iter__') or hasattr(data, 'iter_content'):
-        # Efficient stream processing
-        try:
-            if hasattr(data, 'iter_content'):
-                data = data.iter_content(chunk_size=chunk_size)
-            first_item = next(iter(data))
-        except StopIteration:
+            if processed_item is not None:
+                if content_extractor:
+                    try:
+                        final_content = content_extractor(processed_item)
+                        if final_content is not None:
+                            yield final_content
+                    except Exception:
+                        pass
+                else:
+                    yield processed_item
+        return
+
+    # Stream processing path
+    if not hasattr(data, '__iter__'):
+        raise TypeError(f"Input must be a string or an iterable, not {type(data).__name__}")
+    
+    try:
+        iterator = iter(data)
+        first_item = next(iterator, None)
+        if first_item is None:
             return
-
+            
+        # Efficient streaming with itertools
         from itertools import chain
-        stream = chain([first_item], data)
+        stream = chain([first_item], iterator)
 
-        # Choose processing path based on type
+        # Determine if we're dealing with bytes or strings
         if isinstance(first_item, bytes):
             line_iterator = _decode_byte_stream(
                 stream, 
                 encoding=encoding,
-                errors=encoding_errors
+                errors=encoding_errors,
+                buffer_size=buffer_size
             )
         elif isinstance(first_item, str):
             line_iterator = stream
         else:
             raise TypeError(f"Stream must yield strings or bytes, not {type(first_item).__name__}")
 
-        # Process stream efficiently
+        # Process stream with minimal allocations
         for line in line_iterator:
-            if not processing_active and start_marker is not None and line == start_marker:
-                processing_active = True
+            if not line:
+                continue
+                
+            # Handle markers efficiently
+            if not processing_active and start_marker is not None:
+                if line.strip() == start_marker:
+                    processing_active = True
                 continue
-            if processing_active and end_marker is not None and line == end_marker:
+                
+            if processing_active and end_marker is not None and line.strip() == end_marker:
                 processing_active = False
                 continue
             
             if processing_active:
+                # Process chunk with optimized function
                 processed = _process_chunk(
                     line, intro_value, to_json, effective_skip_markers,
                     strip_chars, yield_raw_on_error
@@ -228,11 +233,16 @@ def sanitize_stream(
                             if final_content is not None:
                                 yield final_content
                         except Exception:
+                            # Continue on extraction errors
                             pass
                     else:
                         yield processed
-    else:
-        raise TypeError(f"Input must be a string or an iterable, not {type(data).__name__}")
+                        
+    except Exception as e:
+        # Log error but don't crash on stream processing exceptions
+        import sys
+        print(f"Stream processing error: {str(e)}", file=sys.stderr)
+
 
 from .conversation import Conversation
 from .optimizers import Optimizers

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "8.2.6"
+__version__ = "8.2.7"
 __prog__ = "webscout"

{webscout-8.2.6.dist-info → webscout-8.2.7.dist-info}/METADATA

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 8.2.6
+Version: 8.2.7
 Summary: Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
-Author: OEvortex
-Author-email: helpingai5@gmail.com
+Author-email: OEvortex <helpingai5@gmail.com>
 License: HelpingAI
 Project-URL: Source, https://github.com/OE-LUCIFER/Webscout
 Project-URL: Tracker, https://github.com/OE-LUCIFER/Webscout/issues
@@ -68,19 +67,7 @@ Requires-Dist: aiohttp
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.6; extra == "dev"
 Requires-Dist: pytest>=7.4.2; extra == "dev"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: keywords
-Dynamic: license
 Dynamic: license-file
-Dynamic: project-url
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 <div align="center">
   <a href="https://github.com/OEvortex/Webscout">

webscout-8.2.7.dist-info/RECORD

@@ -0,0 +1,26 @@
+webscout/AIauto.py,sha256=SvOhkz1irK67s-SHKUnGp6NHirejr51xV4qg5ZNdQMY,9276
+webscout/AIbase.py,sha256=ejzsyXAK82eo-2Cg8epljxlxrcHnQeeLt6SKurePOVY,9272
+webscout/AIutel.py,sha256=qbvLy52BhrF0G2TPT4oPkYR7tW-CqOxlUnqZ21Zcq5A,9339
+webscout/Bard.py,sha256=T4X1aQczWU8XyvWqVLvp_JxnHHz5GTbdrM9RRK9Bq5Y,41046
+webscout/DWEBS.py,sha256=OnoKtIkrlNtYlGL_CCPsLet8cj2wKxqquFB8RdBxXfk,18621
+webscout/__init__.py,sha256=vOmNYCYC0bJ2mSMCIqrFl3E7gwMudGj0kELPcTwZz7M,1033
+webscout/__main__.py,sha256=qtkMZK5jzQ79ZkFAuZBxMgayuhmw3aRDj1F8Pt06NW4,108
+webscout/cli.py,sha256=kn-HoPlgzyWns0cCCMXncB1UsqChE0DYSQgWcJPysHw,21300
+webscout/conversation.py,sha256=8pKCbU5bObVrzGCFhSnFnFOpNFzyjeD-oWk4ON3621A,16881
+webscout/exceptions.py,sha256=cj0BDCZhB46g_vJ0r2PH0U_T35dqZro-rWu6tvtIZ3c,12833
+webscout/models.py,sha256=C7QY-KDkqFCI698t9pvTHQ27rYadPIvwaYHJ3-AOCJI,6566
+webscout/optimizers.py,sha256=NlnxWCav7cTyjfeLHuq2pUCgqgW1pljWbMTklHYMGwo,9954
+webscout/prompt_manager.py,sha256=j4MLYx3SpeeTxzsbgUGAHWLtJ1HAF6eaWOzJCAiGND4,10090
+webscout/tempid.py,sha256=lqTTOjVSwDMmC0UoThdyshFyIAxTikVaN613-6K3g_s,4968
+webscout/update_checker.py,sha256=5FCr6p1zLVASXcXkxKEgR7bFvICbpzJdgRTr3teKFCs,4217
+webscout/utils.py,sha256=o2hU3qaVPk25sog3e4cyVZO3l8xwaZpYRziZPotEzNo,3075
+webscout/version.py,sha256=UCzUXtD1UABNyj0mB_wplcbyHX8vDgyo3Gz8ZXpiZUM,46
+webscout/webscout_search.py,sha256=aEv6_wcwFWomfUGUm-udHdMKULcMbv6SR3Gxhx8ycdQ,56691
+webscout/webscout_search_async.py,sha256=SS6hLvlMRQT_KNuqZUfSuL7Tz-KTEDIXCn97yXSsNeI,35870
+webscout/yep_search.py,sha256=gCXleUK_1Gy6B6fMPZ8MurwboPiMmbft3bhk1qISCdQ,12295
+webscout-8.2.7.dist-info/licenses/LICENSE.md,sha256=hyfFlVn7pWcrvuvs-piB8k4J8DlXdOsYje9RyPxc6Ik,7543
+webscout-8.2.7.dist-info/METADATA,sha256=CNFfzkf_Ckt1GW6WLALOfxKxX1xIRA200OEOEZxywUc,29334
+webscout-8.2.7.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+webscout-8.2.7.dist-info/entry_points.txt,sha256=O_97lvOdImKPfdf3k_pT63sRXGyqooR8DytlD03ZCY4,72
+webscout-8.2.7.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
+webscout-8.2.7.dist-info/RECORD,,

{webscout-8.2.6.dist-info → webscout-8.2.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

webscout-8.2.7.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+WEBS = webscout.cli:main
+webscout = webscout.cli:main

webscout-8.2.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+webscout

webscout/Extra/GitToolkit/__init__.py

@@ -1,10 +0,0 @@
-from .gitapi import *
-
-__all__ = [
-    'Repository',
-    'User',
-    'GitError',
-    'RateLimitError', 
-    'NotFoundError',
-    'RequestError'
-]

webscout/Extra/GitToolkit/gitapi/__init__.py

@@ -1,12 +0,0 @@
-from .repository import Repository
-from .user import User
-from .utils import GitError, RateLimitError, NotFoundError, RequestError
-
-__all__ = [
-    'Repository',
-    'User',
-    'GitError',
-    'RateLimitError', 
-    'NotFoundError',
-    'RequestError'
-]

webscout/Extra/GitToolkit/gitapi/repository.py

@@ -1,195 +0,0 @@
-from typing import List, Dict, Any, Optional
-from .utils import request
-from urllib.parse import quote
-
-class Repository:
-    """Class for interacting with GitHub repositories"""
-    
-    def __init__(self, owner: str, repo: str):
-        """
-        Initialize repository client
-        
-        Args:
-            owner: Repository owner
-            repo: Repository name
-        """
-        self.owner = owner
-        self.repo = repo
-        self.base_url = f"https://api.github.com/repos/{owner}/{repo}"
-
-    def get_info(self) -> Dict[str, Any]:
-        """Get basic repository information"""
-        return request(self.base_url)
-
-    def get_commits(self, page: int = 1, per_page: int = 30, sha: str = None) -> List[Dict[str, Any]]:
-        """
-        Get repository commits
-        
-        Args:
-            page: Page number
-            per_page: Items per page
-            sha: SHA or branch name to start listing commits from
-        """
-        url = f"{self.base_url}/commits?page={page}&per_page={per_page}"
-        if sha:
-            url += f"&sha={sha}"
-        return request(url)
-
-    def get_commit(self, sha: str) -> Dict[str, Any]:
-        """Get a specific commit details"""
-        url = f"{self.base_url}/commits/{sha}"
-        return request(url)
-
-    def get_pull_requests(self, state: str = "all", page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """
-        Get repository pull requests
-        
-        Args:
-            state: State of PRs to return (open/closed/all)
-            page: Page number
-            per_page: Items per page
-        """
-        url = f"{self.base_url}/pulls?state={state}&page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_pull_request(self, pr_number: int) -> Dict[str, Any]:
-        """Get specific pull request details"""
-        url = f"{self.base_url}/pulls/{pr_number}"
-        return request(url)
-
-    def get_pull_request_commits(self, pr_number: int) -> List[Dict[str, Any]]:
-        """Get commits in a specific pull request"""
-        url = f"{self.base_url}/pulls/{pr_number}/commits"
-        return request(url)
-
-    def get_pull_request_files(self, pr_number: int) -> List[Dict[str, Any]]:
-        """Get files changed in a specific pull request"""
-        url = f"{self.base_url}/pulls/{pr_number}/files"
-        return request(url)
-
-    def get_issues(self, state: str = "all", page: int = 1, per_page: int = 30, labels: str = None) -> List[Dict[str, Any]]:
-        """
-        Get repository issues
-        
-        Args:
-            state: State of issues to return (open/closed/all)
-            page: Page number
-            per_page: Items per page
-            labels: Comma-separated list of label names
-        """
-        url = f"{self.base_url}/issues?state={state}&page={page}&per_page={per_page}"
-        if labels:
-            url += f"&labels={labels}"
-        return request(url)
-
-    def get_issue(self, issue_number: int) -> Dict[str, Any]:
-        """Get specific issue details"""
-        url = f"{self.base_url}/issues/{issue_number}"
-        return request(url)
-
-    def get_issue_comments(self, issue_number: int) -> List[Dict[str, Any]]:
-        """Get comments on a specific issue"""
-        url = f"{self.base_url}/issues/{issue_number}/comments"
-        return request(url)
-
-    def get_labels(self) -> List[Dict[str, Any]]:
-        """Get repository labels"""
-        url = f"{self.base_url}/labels"
-        return request(url)
-
-    def get_milestones(self, state: str = "all") -> List[Dict[str, Any]]:
-        """Get repository milestones"""
-        url = f"{self.base_url}/milestones?state={state}"
-        return request(url)
-
-    def get_contributors(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get repository contributors"""
-        url = f"{self.base_url}/contributors?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_languages(self) -> Dict[str, int]:
-        """Get repository language breakdown"""
-        url = f"{self.base_url}/languages"
-        return request(url)
-
-    def get_teams(self) -> List[Dict[str, Any]]:
-        """Get teams with access to repository"""
-        url = f"{self.base_url}/teams"
-        return request(url)
-
-    def get_tags(self) -> List[Dict[str, Any]]:
-        """Get repository tags"""
-        url = f"{self.base_url}/tags"
-        return request(url)
-
-    def get_releases(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get repository releases"""
-        url = f"{self.base_url}/releases?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_release(self, release_id: str) -> Dict[str, Any]:
-        """Get specific release details"""
-        url = f"{self.base_url}/releases/{release_id}"
-        return request(url)
-
-    def get_latest_release(self) -> Dict[str, Any]:
-        """Get latest release"""
-        url = f"{self.base_url}/releases/latest"
-        return request(url)
-
-    def get_branches(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get repository branches"""
-        url = f"{self.base_url}/branches?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_branch(self, branch: str) -> Dict[str, Any]:
-        """Get specific branch details"""
-        url = f"{self.base_url}/branches/{branch}"
-        return request(url)
-
-    def get_contents(self, path: str = "", ref: Optional[str] = None) -> Dict[str, Any]:
-        """Get contents of file or directory"""
-        url = f"{self.base_url}/contents/{quote(path)}"
-        if ref:
-            url += f"?ref={ref}"
-        return request(url)
-
-    def get_collaborators(self) -> List[Dict[str, Any]]:
-        """Get repository collaborators"""
-        url = f"{self.base_url}/collaborators"
-        return request(url)
-
-    def get_workflows(self) -> List[Dict[str, Any]]:
-        """Get repository GitHub Actions workflows"""
-        url = f"{self.base_url}/actions/workflows"
-        return request(url)
-
-    def get_workflow_runs(self, workflow_id: str) -> List[Dict[str, Any]]:
-        """Get workflow runs for a specific workflow"""
-        url = f"{self.base_url}/actions/workflows/{workflow_id}/runs"
-        return request(url)
-
-    def get_deployments(self) -> List[Dict[str, Any]]:
-        """Get repository deployments"""
-        url = f"{self.base_url}/deployments"
-        return request(url)
-
-    def get_traffic(self) -> Dict[str, Any]:
-        """Get repository traffic data"""
-        url = f"{self.base_url}/traffic/views"
-        return request(url)
-
-    def get_code_frequency(self) -> List[List[int]]:
-        """Get weekly commit activity"""
-        url = f"{self.base_url}/stats/code_frequency"
-        return request(url)
-
-    def get_commit_activity(self) -> List[Dict[str, Any]]:
-        """Get last year of commit activity"""
-        url = f"{self.base_url}/stats/commit_activity"
-        return request(url)
-
-    def get_community_profile(self) -> Dict[str, Any]:
-        """Get community profile metrics"""
-        url = f"{self.base_url}/community/profile"
-        return request(url)