webscout 8.3__py3-none-any.whl → 8.3.1__py3-none-any.whl

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/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/Extra/YTToolkit/ytapi/patterns.py

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

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/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/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/Litlogger/formats.py

@@ -1,4 +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/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/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/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/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__(