webscout 8.3__tar.gz → 8.3.1__tar.gz

{webscout-8.3/webscout.egg-info → webscout-8.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 8.3
+Version: 8.3.1
 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-email: OEvortex <helpingai5@gmail.com>
 License: HelpingAI

{webscout-8.3 → webscout-8.3.1}/webscout/AIauto.py

@@ -6,7 +6,7 @@ API keys or cookies.
 
 from webscout.AIbase import Provider
 from webscout.exceptions import AllProvidersFailure
-from typing import Union, Any, Dict, Generator
+from typing import Union, Any, Dict, Generator, Optional
 import importlib
 import pkgutil
 import random
@@ -71,7 +71,7 @@ class AUTO(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        exclude: list[str] = [],
+        exclude: Optional[list[str]] = None,
         print_provider_info: bool = False,
     ):
         """
@@ -90,7 +90,7 @@ class AUTO(Provider):
             proxies (dict): Proxies for requests. Defaults to {}.
             history_offset (int): History character offset limit. Defaults to 10250.
             act (str, optional): Awesome prompt key. Defaults to None.
-            exclude (list[str]): List of provider names (uppercase) to exclude. Defaults to [].
+            exclude (Optional[list[str]]): List of provider names (uppercase) to exclude. Defaults to None.
             print_provider_info (bool): Whether to print the name of the successful provider. Defaults to False.
         """
         self.provider = None  # type: Provider
@@ -104,7 +104,7 @@ class AUTO(Provider):
         self.proxies: dict = proxies
         self.history_offset: int = history_offset
         self.act: str = act
-        self.exclude: list[str] = [e.upper() for e in exclude]
+        self.exclude: list[str] = [e.upper() for e in exclude] if exclude else []
         self.print_provider_info: bool = print_provider_info
 
 

{webscout-8.3 → webscout-8.3.1}/webscout/AIbase.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import AsyncGenerator, Dict, List, Union, Generator, Optional
+from typing import AsyncGenerator, Dict, List, Union, Generator, Optional, Any
 from typing_extensions import TypeAlias
 
 # Type aliases for better readability
@@ -178,6 +178,66 @@ class AsyncTTSProvider(ABC):
         """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
+
+class STTProvider(ABC):
+    """Abstract base class for Speech-to-Text providers."""
+
+    @abstractmethod
+    def transcribe(self, audio_path: Union[str, Path], **kwargs) -> Dict[str, Any]:
+        """Transcribe audio file to text.
+
+        Args:
+            audio_path (Union[str, Path]): Path to the audio file
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            Dict[str, Any]: Transcription result in OpenAI Whisper format
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def transcribe_from_url(self, audio_url: str, **kwargs) -> Dict[str, Any]:
+        """Transcribe audio from URL to text.
+
+        Args:
+            audio_url (str): URL of the audio file
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            Dict[str, Any]: Transcription result in OpenAI Whisper format
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+
+class AsyncSTTProvider(ABC):
+    """Abstract base class for asynchronous Speech-to-Text providers."""
+
+    @abstractmethod
+    async def transcribe(self, audio_path: Union[str, Path], **kwargs) -> Dict[str, Any]:
+        """Transcribe audio file to text asynchronously.
+
+        Args:
+            audio_path (Union[str, Path]): Path to the audio file
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            Dict[str, Any]: Transcription result in OpenAI Whisper format
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def transcribe_from_url(self, audio_url: str, **kwargs) -> Dict[str, Any]:
+        """Transcribe audio from URL to text asynchronously.
+
+        Args:
+            audio_url (str): URL of the audio file
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            Dict[str, Any]: Transcription result in OpenAI Whisper format
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
     async def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
         """Save audio to a specific destination asynchronously.
 

webscout-8.3.1/webscout/Extra/YTToolkit/ytapi/patterns.py

@@ -0,0 +1,61 @@
+import re
+
+
+class _ChannelPatterns:
+    name = re.compile(r'channelMetadataRenderer\":{\"title\":\"(.*?)\"')
+    id = re.compile(r'channelId\":\"(.*?)\"')
+    verified = re.compile(r'"label":"Verified"')
+    check_live = re.compile(r'{"text":"LIVE"}')
+    live = re.compile(r"thumbnailOverlays\":\[(.*?)]")
+    video_id = re.compile(r'videoId\":\"(.*?)\"')
+    uploads = re.compile(r"gridVideoRenderer\":{\"videoId\":\"(.*?)\"")
+    subscribers = re.compile(r"\"subscriberCountText\":{\"accessibility\":(.*?),")
+    views = re.compile(r"viewCountText\":{\"simpleText\":\"(.*?)\"}")
+    creation = re.compile(r"{\"text\":\"Joined \"},{\"text\":\"(.*?)\"}")
+    country = re.compile(r"country\":{\"simpleText\":\"(.*?)\"}")
+    custom_url = re.compile(r"canonicalChannelUrl\":\"(.*?)\"")
+    description = re.compile(r"{\"description\":{\"simpleText\":\"(.*?)\"}")
+    avatar = re.compile(r"height\":88},{\"url\":\"(.*?)\"")
+    banner = re.compile(r"width\":1280,\"height\":351},{\"url\":\"(.*?)\"")
+    playlists = re.compile(r"{\"url\":\"/playlist\?list=(.*?)\"")
+    video_count = re.compile(r"videoCountText\":{\"runs\":\[{\"text\":(.*?)}")
+    socials = re.compile(r"q=https%3A%2F%2F(.*?)\"")
+    upload_ids = re.compile(r"videoId\":\"(.*?)\"")
+    stream_ids = re.compile(r"videoId\":\"(.*?)\"")
+    upload_chunk = re.compile(r"gridVideoRenderer\":{(.*?)\"navigationEndpoint")
+    upload_chunk_fl_1 = re.compile(r"simpleText\":\"Streamed")
+    upload_chunk_fl_2 = re.compile(r"default_live.")
+    upcoming_check = re.compile(r"\"title\":\"Upcoming live streams\"")
+    upcoming = re.compile(r"gridVideoRenderer\":{\"videoId\":\"(.*?)\"")
+
+
+class _VideoPatterns:
+    video_id = re.compile(r'videoId\":\"(.*?)\"')
+    title = re.compile(r"title\":\"(.*?)\"")
+    duration = re.compile(r"approxDurationMs\":\"(.*?)\"")
+    upload_date = re.compile(r"uploadDate\":\"(.*?)\"")
+    author_id = re.compile(r"channelIds\":\[\"(.*?)\"")
+    description = re.compile(r"shortDescription\":\"(.*)\",\"isCrawlable")
+    tags = re.compile(r"<meta name=\"keywords\" content=\"(.*?)\">")
+    is_streamed = re.compile(r"simpleText\":\"Streamed live")
+    is_premiered = re.compile(r"dateText\":{\"simpleText\":\"Premiered")
+    views = re.compile(r"videoViewCountRenderer\":{\"viewCount\":{\"simpleText\":\"(.*?)\"")
+    likes = re.compile(r"toggledText\":{\"accessibility\":{\"accessibilityData\":{\"label\":\"(.*?) ")
+    thumbnail = re.compile(r"playerMicroformatRenderer\":{\"thumbnail\":{\"thumbnails\":\[{\"url\":\"(.*?)\"")
+
+
+class _PlaylistPatterns:
+    name = re.compile(r"{\"title\":\"(.*?)\"")
+    video_count = re.compile(r"stats\":\[{\"runs\":\[{\"text\":\"(.*?)\"")
+    video_id = re.compile(r"videoId\":\"(.*?)\"")
+    thumbnail = re.compile(r"og:image\" content=\"(.*?)\?")
+
+
+class _ExtraPatterns:
+    video_id = re.compile(r"videoId\":\"(.*?)\"")
+
+
+class _QueryPatterns:
+    channel_id = re.compile(r"channelId\":\"(.*?)\"")
+    video_id = re.compile(r"videoId\":\"(.*?)\"")
+    playlist_id = re.compile(r"playlistId\":\"(.*?)\"")

{webscout-8.3 → webscout-8.3.1}/webscout/Extra/YTToolkit/ytapi/stream.py

@@ -11,7 +11,7 @@ class Video:
     _HEAD = 'https://www.youtube.com/watch?v='
 
     def __init__(self, video_id: str):
-        pattern = re.compile('.be/(.*?)$|=(.*?)$|^(\w{11})$')  # noqa
+        pattern = re.compile(r'.be/(.*?)$|=(.*?)$|^(\w{11})$')  # noqa
         self._matched_id = (
                 pattern.search(video_id).group(1)
                 or pattern.search(video_id).group(2)

{webscout-8.3 → webscout-8.3.1}/webscout/Extra/YTToolkit/ytapi/video.py

@@ -17,7 +17,7 @@ class Video:
         video_id : str
             The id or url of the video
         """
-        pattern = re.compile('.be/(.*?)$|=(.*?)$|^(\w{11})$')  # noqa
+        pattern = re.compile(r'.be/(.*?)$|=(.*?)$|^(\w{11})$')  # noqa
         match = pattern.search(video_id)
 
         if not match:
@@ -33,7 +33,7 @@ class Video:
             self._url = self._HEAD + self._matched_id
             self._video_data = video_data(self._matched_id)
             # Extract basic info for fallback
-            title_match = re.search('<title>(.*?) - YouTube</title>', self._video_data)
+            title_match = re.search(r'<title>(.*?) - YouTube</title>', self._video_data)
             self.title = title_match.group(1) if title_match else None
             self.id = self._matched_id
         else:
@@ -55,19 +55,19 @@ class Video:
         """
         # Multiple patterns to try for video details extraction for robustness
         details_patterns = [
-            re.compile('videoDetails\":(.*?)\"isLiveContent\":.*?}'),
-            re.compile('videoDetails\":(.*?),\"playerConfig'),
-            re.compile('videoDetails\":(.*?),\"playabilityStatus')
+            re.compile(r'videoDetails\":(.*?)\"isLiveContent\":.*?}'),
+            re.compile(r'videoDetails\":(.*?),\"playerConfig'),
+            re.compile(r'videoDetails\":(.*?),\"playabilityStatus')
         ]
 
         # Other metadata patterns
-        upload_date_pattern = re.compile("<meta itemprop=\"uploadDate\" content=\"(.*?)\">")
-        genre_pattern = re.compile("<meta itemprop=\"genre\" content=\"(.*?)\">")
+        upload_date_pattern = re.compile(r"<meta itemprop=\"uploadDate\" content=\"(.*?)\">")
+        genre_pattern = re.compile(r"<meta itemprop=\"genre\" content=\"(.*?)\">")
         like_count_patterns = [
-            re.compile("iconType\":\"LIKE\"},\"defaultText\":(.*?)}"),
-            re.compile('\"likeCount\":\"(\\d+)\"')
+            re.compile(r"iconType\":\"LIKE\"},\"defaultText\":(.*?)}"),
+            re.compile(r'\"likeCount\":\"(\d+)\"')
         ]
-        channel_name_pattern = re.compile('"ownerChannelName":"(.*?)"')
+        channel_name_pattern = re.compile(r'"ownerChannelName":"(.*?)"')
 
         # Try each pattern for video details
         raw_details_match = None

{webscout-8.3 → webscout-8.3.1}/webscout/Extra/autocoder/autocoder_utiles.py

@@ -131,7 +131,7 @@ def get_intro_prompt(name: str = "Vortex") -> str:
         - Actively clean up any temporary processes or files you use.
         - When looking through files, use git as available to skip files, and skip hidden files (.env, .git, etc) by default.
         - You can plot anything with matplotlib using Python code.
-        - **IMPORTANT**: ALWAYS Return your SCRIPT inside of a single pair of \`\`\` delimiters. This SCRIPT can be a mix of Python code and `!`-prefixed shell commands. Only the console output from this SCRIPT (Python prints or `!` command stdout/stderr) is visible to the user, so ensure it's complete.
+        - **IMPORTANT**: ALWAYS Return your SCRIPT inside of a single pair of ``` delimiters. This SCRIPT can be a mix of Python code and `!`-prefixed shell commands. Only the console output from this SCRIPT (Python prints or `!` command stdout/stderr) is visible to the user, so ensure it's complete.
     </conventions>
 
     <examples>

webscout-8.3.1/webscout/Litlogger/formats.py

@@ -0,0 +1,13 @@
+DEFAULT_FORMAT = "{time} | {level} | {name} | {message}"
+
+SIMPLE_FORMAT = "{level}: {message}"
+
+DETAILED_FORMAT = "{time} | {level} | {name} | {message} | Thread: {thread} | Process: {process}"
+
+JSON_FORMAT = '{{"time": "{time}", "level": "{level}", "name": "{name}", "message": "{message}"}}'
+
+class LogFormat:
+    DEFAULT = DEFAULT_FORMAT
+    SIMPLE = SIMPLE_FORMAT
+    DETAILED = DETAILED_FORMAT
+    JSON = JSON_FORMAT

{webscout-8.3 → webscout-8.3.1}/webscout/Litlogger/handlers.py

@@ -101,3 +101,21 @@ class TCPHandler(Handler):
             return
         with socket.create_connection((self.host, self.port), timeout=5) as sock:
             sock.sendall(message.encode() + b"\n")
+
+class JSONFileHandler(FileHandler):
+    def __init__(self, path: str, level: LogLevel = LogLevel.DEBUG, max_bytes: int = 0, backups: int = 0):
+        super().__init__(path, level, max_bytes, backups)
+
+    def emit(self, message: str, level: LogLevel):
+        # Expect message to be a JSON string or dict
+        if level < self.level:
+            return
+        import json
+        if isinstance(message, dict):
+            log_entry = json.dumps(message)
+        else:
+            log_entry = message
+        self._file.write(log_entry + "\n")
+        self._file.flush()
+        if self.max_bytes and self._file.tell() >= self.max_bytes:
+            self._rotate()

{webscout-8.3 → webscout-8.3.1}/webscout/Litlogger/logger.py

@@ -16,16 +16,58 @@ class Logger:
         handlers: Optional[List[Handler]] = None,
         fmt: str = LogFormat.DEFAULT,  # <--- use LogFormat.DEFAULT
         async_mode: bool = False,
+        include_context: bool = False,  # New flag to include thread/process info
     ):
+        import threading
+        import multiprocessing
+
         self.name = name
         self.level = level
         self.format = fmt
         self.async_mode = async_mode
+        self.include_context = include_context
         self.handlers = handlers or [ConsoleHandler()]
+        self._thread = threading
+        self._multiprocessing = multiprocessing
 
     def _format(self, level: LogLevel, message: str) -> str:
         now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        return self.format.format(time=now, level=level.name, name=self.name, message=message)
+        if self.include_context:
+            thread_name = self._thread.current_thread().name
+            process_id = self._multiprocessing.current_process().pid
+            # Check if format is JSON format
+            if self.format.strip().startswith('{') and self.format.strip().endswith('}'):
+                # Format as JSON string with extra fields
+                return self.format.format(
+                    time=now,
+                    level=level.name,
+                    name=self.name,
+                    message=message,
+                    thread=thread_name,
+                    process=process_id
+                )
+            else:
+                # For non-JSON formats, add thread and process info if placeholders exist
+                try:
+                    return self.format.format(
+                        time=now,
+                        level=level.name,
+                        name=self.name,
+                        message=message,
+                        thread=thread_name,
+                        process=process_id
+                    )
+                except KeyError:
+                    # If thread/process placeholders not in format, append them manually
+                    base = self.format.format(time=now, level=level.name, name=self.name, message=message)
+                    return f"{base} | Thread: {thread_name} | Process: {process_id}"
+        else:
+            return self.format.format(time=now, level=level.name, name=self.name, message=message)
+
+    def set_format(self, fmt: str, include_context: bool = False):
+        """Dynamically change the log format and context inclusion."""
+        self.format = fmt
+        self.include_context = include_context
 
     def _should_log(self, level: LogLevel) -> bool:
         return level >= self.level

{webscout-8.3 → webscout-8.3.1}/webscout/Provider/AISEARCH/scira_search.py

@@ -45,12 +45,13 @@ class Scira(AISearch):
     AVAILABLE_MODELS = {
         "scira-default": "Grok3-mini", # thinking model
         "scira-grok-3": "Grok3",
-        "scira-anthropic": "Sonnet 3.7 thinking",
+        "scira-anthropic": "Claude 4 Sonnet",
+        "scira-anthropic-thinking": "Claude 4 Sonnet Thinking", # thinking model
         "scira-vision" : "Grok2-Vision", # vision model
         "scira-4o": "GPT4o",
         "scira-qwq": "QWQ-32B",
         "scira-o4-mini": "o4-mini",
-        "scira-google": "gemini 2.5 flash",
+        "scira-google": "gemini 2.5 flash Thinking", # thinking model
         "scira-google-pro": "gemini 2.5 pro",
         "scira-llama-4": "llama 4 Maverick",
     }

{webscout-8.3 → webscout-8.3.1}/webscout/Provider/LambdaChat.py

@@ -23,11 +23,17 @@ class LambdaChat(Provider):
         "deepseek-llama3.3-70b",
         "apriel-5b-instruct",
         "deepseek-r1",
+        "deepseek-v3-0324",
+        "deepseek-r1-0528",
         "hermes-3-llama-3.1-405b-fp8",
         "llama3.1-nemotron-70b-instruct",
         "lfm-40b",
         "llama3.3-70b-instruct-fp8",
-        "qwen25-coder-32b-instruct"
+        "qwen25-coder-32b-instruct",
+        "qwen3-32b-fp8",
+        "llama-4-maverick-70b-128e-instruct-fp8",
+        "llama-4-scout-17b-16e-instruct"
+
     ]
     
     def __init__(