webscout 8.3.2__py3-none-any.whl → 8.3.4__py3-none-any.whl

webscout/AIutel.py

@@ -1,5 +1,6 @@
 import codecs
 import json
+import re
 from typing import (
     Any,
     AsyncGenerator,
@@ -11,6 +12,7 @@ from typing import (
     List,
     Literal,
     Optional,
+    Pattern,
     Union,
 )
 
@@ -19,6 +21,36 @@ EncodingType = Literal['utf-8', 'utf-16', 'utf-32', 'ascii', 'latin1', 'cp1252',
                         'iso-8859-2', 'windows-1250', 'windows-1251', 'windows-1252', 'gbk', 'big5',
                         'shift_jis', 'euc-jp', 'euc-kr']
 
+def _compile_regexes(patterns: Optional[List[Union[str, Pattern[str]]]]) -> Optional[List[Pattern[str]]]:
+    """
+    Compile regex patterns from strings or return compiled patterns as-is.
+    
+    Args:
+        patterns: List of regex patterns as strings or compiled Pattern objects.
+        
+    Returns:
+        List of compiled Pattern objects, or None if input is None.
+        
+    Raises:
+        ValueError: If any pattern is invalid.
+    """
+    if not patterns:
+        return None
+    
+    compiled_patterns = []
+    for i, pattern in enumerate(patterns):
+        try:
+            if isinstance(pattern, str):
+                compiled_patterns.append(re.compile(pattern))
+            elif isinstance(pattern, Pattern):
+                compiled_patterns.append(pattern)
+            else:
+                raise ValueError(f"Pattern at index {i} must be a string or compiled regex pattern, got {type(pattern)}")
+        except re.error as e:
+            raise ValueError(f"Invalid regex pattern at index {i}: '{pattern}' - {str(e)}")
+    
+    return compiled_patterns
+
 def _process_chunk(
     chunk: str,
     intro_value: str,
@@ -27,6 +59,8 @@ def _process_chunk(
     strip_chars: Optional[str],
     yield_raw_on_error: bool,
     error_handler: Optional[Callable[[Exception, str], Optional[Any]]] = None,
+    skip_regexes: Optional[List[Pattern[str]]] = None,
+    extract_regexes: Optional[List[Pattern[str]]] = None,
 ) -> Union[str, Dict[str, Any], None]:
     """
     Sanitizes and potentially parses a single chunk of text.
@@ -35,6 +69,8 @@ def _process_chunk(
     - Removes a specified prefix (`intro_value`).
     - Strips leading/trailing characters (`strip_chars`).
     - Skips chunks matching specific markers (`skip_markers`).
+    - Skips chunks matching regex patterns (`skip_regexes`).
+    - Extracts content using regex capturing groups (`extract_regexes`).
     - Optionally parses the chunk as JSON (`to_json`).
     - Handles JSON parsing errors with an optional callback (`error_handler`).
 
@@ -47,18 +83,9 @@ def _process_chunk(
         yield_raw_on_error (bool): If True, returns the raw chunk when JSON parsing fails; otherwise, returns None.
         error_handler (Optional[Callable[[Exception, str], Optional[Any]]]): An optional callback function that is called when JSON parsing fails.
             It receives the exception and the sanitized chunk as arguments.  It should return a value to yield instead of the raw chunk, or None to ignore.
+        skip_regexes (Optional[List[Pattern[str]]]): A list of compiled regex patterns; chunks matching any of these are skipped.
+        extract_regexes (Optional[List[Pattern[str]]]): A list of compiled regex patterns for extracting content using capturing groups.
 
-
-    Args:
-        chunk: Chunk of text to process.
-        intro_value: Prefix to remove from the chunk.
-        to_json: Parse the chunk as JSON if True.
-        skip_markers: List of markers to skip.
-        strip_chars: Characters to strip from the chunk.
-        yield_raw_on_error: Whether to return the raw chunk on parse errors.
-        error_handler: Optional callback ``Callable[[Exception, str], Optional[Any]]``
-            invoked when JSON parsing fails. The callback should return a value to
-            yield instead of the raw chunk, or ``None`` to ignore.
     """
     if not isinstance(chunk, str):
         return None
@@ -83,6 +110,28 @@ def _process_chunk(
     if not sanitized_chunk or any(marker == sanitized_chunk for marker in skip_markers):
         return None
 
+    # Apply regex-based extraction first (if provided)
+    if extract_regexes:
+        for regex in extract_regexes:
+            match = regex.search(sanitized_chunk)
+            if match:
+                # If there are capturing groups, return the first group or all groups as a tuple
+                if match.groups():
+                    if len(match.groups()) == 1:
+                        sanitized_chunk = match.group(1)
+                    else:
+                        # Multiple groups - return as tuple converted to string for JSON compatibility
+                        sanitized_chunk = str(match.groups())
+                else:
+                    # No capturing groups, return the full match
+                    sanitized_chunk = match.group(0)
+                break  # Use first matching extraction regex
+
+    # Apply regex-based skipping (after extraction)
+    if skip_regexes:
+        if any(regex.search(sanitized_chunk) for regex in skip_regexes):
+            return None
+
     # JSON parsing with optimized error handling
     if to_json:
         try:
@@ -128,11 +177,6 @@ def _decode_byte_stream(
             Defaults to 'replace'.
         buffer_size (int): The size of the internal buffer used for decoding.
 
-    Args:
-        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:
@@ -241,18 +285,20 @@ def _sanitize_stream_sync(
     buffer_size: int = 8192,
     line_delimiter: Optional[str] = None,
     error_handler: Optional[Callable[[Exception, str], Optional[Any]]] = None,
+    skip_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
+    extract_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
 ) -> Generator[Any, None, None]:
     """
     Processes a stream of data (strings or bytes) in real-time, applying various transformations and filtering.
 
     This function is designed to handle streaming data, allowing for operations such as
-    prefix removal, JSON parsing, skipping lines based on markers, and extracting specific content.
-    It also supports custom error handling for JSON parsing failures.
+    prefix removal, JSON parsing, skipping lines based on markers, regex-based filtering,
+    and extracting specific content. It also supports custom error handling for JSON parsing failures.
 
     Args:
         data: String, iterable of strings, or iterable of bytes to process.
         intro_value: Prefix indicating the start of meaningful data.
-        to_json: Parse JSON content if ``True``.
+        to_json: Parse the chunk as JSON if True.
         skip_markers: Lines containing any of these markers are skipped.
         strip_chars: Characters to strip from each line.
         start_marker: Begin processing only after this marker is found.
@@ -266,14 +312,21 @@ def _sanitize_stream_sync(
             uses ``str.splitlines()``.
         error_handler: Callback invoked with ``(Exception, str)`` when JSON
             parsing fails. If the callback returns a value, it is yielded instead of the raw line.
+        skip_regexes: List of regex patterns (strings or compiled) for skipping lines that match.
+        extract_regexes: List of regex patterns (strings or compiled) for extracting content using capturing groups.
 
     Yields:
         Any: Processed data, which can be a string, a dictionary (if `to_json` is True), or the result of `content_extractor`.
 
     Raises:
         TypeError: If the input `data` is not a string or an iterable.
+        ValueError: If any regex pattern is invalid.
     """
     effective_skip_markers = skip_markers or []
+    # Compile regex patterns
+    compiled_skip_regexes = _compile_regexes(skip_regexes)
+    compiled_extract_regexes = _compile_regexes(extract_regexes)
+    
     processing_active = start_marker is None
     buffer = ""
     found_start = False if start_marker else True
@@ -358,6 +411,8 @@ def _sanitize_stream_sync(
                                 strip_chars,
                                 yield_raw_on_error,
                                 error_handler,
+                                compiled_skip_regexes,
+                                compiled_extract_regexes,
                             )
                             if result is None:
                                 continue
@@ -388,6 +443,8 @@ def _sanitize_stream_sync(
                                 strip_chars,
                                 yield_raw_on_error,
                                 error_handler,
+                                compiled_skip_regexes,
+                                compiled_extract_regexes,
                             )
                             if result is None:
                                 continue
@@ -423,14 +480,16 @@ async def _sanitize_stream_async(
     buffer_size: int = 8192,
     line_delimiter: Optional[str] = None,
     error_handler: Optional[Callable[[Exception, str], Optional[Any]]] = None,
+    skip_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
+    extract_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
 ) -> AsyncGenerator[Any, None]:
     """
     Asynchronously processes a stream of data (strings or bytes), applying transformations and filtering.
 
     This function is the asynchronous counterpart to `_sanitize_stream_sync`. It handles
     streaming data, allowing for operations such as prefix removal, JSON parsing,
-    skipping lines based on markers, and extracting specific content. It also supports
-    custom error handling for JSON parsing failures.
+    skipping lines based on markers, regex-based filtering, and extracting specific content. 
+    It also supports custom error handling for JSON parsing failures.
 
     Args:
         data: String, iterable of strings, or iterable of bytes to process.
@@ -447,6 +506,8 @@ async def _sanitize_stream_async(
         buffer_size: Buffer size for byte decoding.
         line_delimiter: Delimiter used to split incoming text into lines. ``None`` uses ``str.splitlines()``.
         error_handler: Callback invoked with ``(Exception, str)`` when JSON parsing fails. If the callback returns a value, it is yielded in place of the raw line.
+        skip_regexes: List of regex patterns (strings or compiled) for skipping lines that match.
+        extract_regexes: List of regex patterns (strings or compiled) for extracting content using capturing groups.
     """
     if isinstance(data, str):
         for item in _sanitize_stream_sync(
@@ -464,6 +525,8 @@ async def _sanitize_stream_async(
             buffer_size=buffer_size,
             line_delimiter=line_delimiter,
             error_handler=error_handler,
+            skip_regexes=skip_regexes,
+            extract_regexes=extract_regexes,
         ):
             yield item
         return
@@ -485,11 +548,17 @@ async def _sanitize_stream_async(
             buffer_size=buffer_size,
             line_delimiter=line_delimiter,
             error_handler=error_handler,
+            skip_regexes=skip_regexes,
+            extract_regexes=extract_regexes,
         ):
             yield item
         return
 
     effective_skip_markers = skip_markers or []
+    # Compile regex patterns
+    compiled_skip_regexes = _compile_regexes(skip_regexes)
+    compiled_extract_regexes = _compile_regexes(extract_regexes)
+    
     processing_active = start_marker is None
     buffer = ""
     found_start = False if start_marker else True
@@ -558,6 +627,8 @@ async def _sanitize_stream_async(
                             strip_chars,
                             yield_raw_on_error,
                             error_handler,
+                            compiled_skip_regexes,
+                            compiled_extract_regexes,
                         )
                         if result is None:
                             continue
@@ -591,6 +662,8 @@ async def _sanitize_stream_async(
                             strip_chars,
                             yield_raw_on_error,
                             error_handler,
+                            compiled_skip_regexes,
+                            compiled_extract_regexes,
                         )
                         if result is None:
                             continue
@@ -611,10 +684,17 @@ async def _sanitize_stream_async(
 def sanitize_stream(
     data: Union[
         str,
+        bytes,
         Iterable[str],
         Iterable[bytes],
         AsyncIterable[str],
         AsyncIterable[bytes],
+        dict,
+        list,
+        int,
+        float,
+        bool,
+        None,
     ],
     intro_value: str = "data:",
     to_json: bool = True,
@@ -629,19 +709,19 @@ def sanitize_stream(
     buffer_size: int = 8192,
     line_delimiter: Optional[str] = None,
     error_handler: Optional[Callable[[Exception, str], Optional[Any]]] = None,
+    skip_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
+    extract_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
+    object_mode: Literal["as_is", "json", "str"] = "json",
+    raw: bool = False,
 ) -> Union[Generator[Any, None, None], AsyncGenerator[Any, None]]:
     """
     Processes streaming data (strings or bytes) in either synchronous or asynchronous mode.
-
-    This function acts as a unified interface for handling both synchronous and
-    asynchronous data streams. It automatically detects the type of input data and
-    dispatches it to the appropriate processing function (`_sanitize_stream_sync` or
-    `_sanitize_stream_async`).
+    Now supports non-iterable and miscellaneous input types (dict, list, int, float, bool, None).
+    Includes regex-based content filtering and extraction capabilities.
 
     Args:
-        data (Union[str, Iterable[str], Iterable[bytes], AsyncIterable[str], AsyncIterable[bytes]]):
-            The data to be processed. Can be a string, a synchronous iterable of strings or bytes,
-            or an asynchronous iterable of strings or bytes.
+        data: The data to be processed. Can be a string, bytes, a synchronous iterable of strings or bytes,
+            an asynchronous iterable of strings or bytes, or a single object (dict, list, int, float, bool, None).
         intro_value (str): Prefix indicating the start of meaningful data. Defaults to "data:".
         to_json (bool): Parse JSON content if ``True``. Defaults to True.
         skip_markers (Optional[List[str]]): Lines containing any of these markers are skipped. Defaults to None.
@@ -659,37 +739,283 @@ def sanitize_stream(
         error_handler (Optional[Callable[[Exception, str], Optional[Any]]]):
             Callback invoked with ``(Exception, str)`` when JSON parsing fails.
             If the callback returns a value, it is yielded in place of the raw line. Defaults to None.
+        skip_regexes (Optional[List[Union[str, Pattern[str]]]]): List of regex patterns (strings or compiled) 
+            for skipping lines that match any pattern. Defaults to None.
+        extract_regexes (Optional[List[Union[str, Pattern[str]]]]): List of regex patterns (strings or compiled) 
+            for extracting content using capturing groups. If multiple groups are captured, they are returned as a tuple string. Defaults to None.
+        object_mode (Literal["as_is", "json", "str"]): How to handle non-string, non-iterable objects.
+            "json" (default) yields as JSON string, "str" yields as str(obj), "as_is" yields the object as-is.
+        raw (bool): If True, yields the raw response as returned by the API, chunk by chunk (no splitting or joining).
 
     Returns:
         Union[Generator[Any, None, None], AsyncGenerator[Any, None]]:
-            A generator or an asynchronous generator yielding the processed data.
-    """
-    # Determine the actual data payload to process
-    payload: Any  # The type of payload can change based on data's attributes
+            A generator or an asynchronous generator yielding the processed data, or raw data if raw=True.
+            
+    Raises:
+        ValueError: If any regex pattern is invalid.
+    """    # --- RAW MODE: yield each chunk exactly as returned by the API ---
+    if raw:
+        def _raw_passthrough_sync(source_iter):
+            for chunk in source_iter:
+                if isinstance(chunk, (bytes, bytearray)):
+                    # Decode bytes preserving all whitespace and newlines
+                    yield chunk.decode(encoding, encoding_errors)
+                elif chunk is not None:
+                    # Yield string chunks as-is, preserving all formatting
+                    yield chunk
+                # Skip None chunks entirely
+        async def _raw_passthrough_async(source_aiter):
+            async for chunk in source_aiter:
+                if isinstance(chunk, (bytes, bytearray)):
+                    # Decode bytes preserving all whitespace and newlines
+                    yield chunk.decode(encoding, encoding_errors)
+                elif chunk is not None:
+                    # Yield string chunks as-is, preserving all formatting
+                    yield chunk
+                # Skip None chunks entirely
+        # Sync iterable (but not str/bytes)
+        if hasattr(data, "__iter__") and not isinstance(data, (str, bytes)):
+            return _raw_passthrough_sync(data)
+        # Async iterable
+        if hasattr(data, "__aiter__"):
+            return _raw_passthrough_async(data)
+        # Single string or bytes
+        if isinstance(data, (bytes, bytearray)):
+            def _yield_single():
+                yield data.decode(encoding, encoding_errors)
+            return _yield_single()
+        else:
+            def _yield_single():
+                if data is not None:
+                    yield data
+            return _yield_single()
+    # --- END RAW MODE ---
 
     text_attr = getattr(data, "text", None)
     content_attr = getattr(data, "content", None)
 
+    # Handle None
+    if data is None:
+        def _empty_gen():
+            if False:
+                yield None
+        return _empty_gen()
+
+    # Handle bytes directly
+    if isinstance(data, bytes):
+        try:
+            payload = data.decode(encoding, encoding_errors)
+        except Exception:
+            payload = str(data)
+        return _sanitize_stream_sync(
+            payload, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            skip_regexes, extract_regexes,
+        )
+
+    # Handle string directly
+    if isinstance(data, str):
+        return _sanitize_stream_sync(
+            data, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            skip_regexes, extract_regexes,
+        )
+
+    # Handle dict, list, int, float, bool (non-iterable, non-string/bytes)
+    if isinstance(data, (dict, list, int, float, bool)):
+        if object_mode == "as_is":
+            def _as_is_gen():
+                yield data
+            return _as_is_gen()
+        elif object_mode == "str":
+            return _sanitize_stream_sync(
+                str(data), intro_value, to_json, skip_markers, strip_chars,
+                start_marker, end_marker, content_extractor, yield_raw_on_error,
+                encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+                skip_regexes, extract_regexes,
+            )
+        else:  # "json"
+            try:
+                json_str = json.dumps(data)
+            except Exception:
+                json_str = str(data)
+            return _sanitize_stream_sync(
+                json_str, intro_value, to_json, skip_markers, strip_chars,
+                start_marker, end_marker, content_extractor, yield_raw_on_error,
+                encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+                skip_regexes, extract_regexes,
+            )
+
+    # Handle file-like objects (optional, treat as string if .read exists)
+    if hasattr(data, "read") and callable(data.read):
+        try:
+            file_content = data.read()
+            if isinstance(file_content, bytes):
+                file_content = file_content.decode(encoding, encoding_errors)
+            return _sanitize_stream_sync(
+                file_content, intro_value, to_json, skip_markers, strip_chars,
+                start_marker, end_marker, content_extractor, yield_raw_on_error,
+                encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+                skip_regexes, extract_regexes,
+            )
+        except Exception:
+            pass  # fallback to next
+
+    # Handle .text or .content attributes
     if isinstance(text_attr, str):
         payload = text_attr
+        return _sanitize_stream_sync(
+            payload, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            skip_regexes, extract_regexes,
+        )
     elif isinstance(content_attr, bytes):
-        payload = content_attr.decode(encoding, encoding_errors)
-    else:
-        # Use the original data if .text or .content are not applicable or not found
-        payload = data
+        try:
+            payload = content_attr.decode(encoding, encoding_errors)
+        except Exception:
+            payload = str(content_attr)
+        return _sanitize_stream_sync(
+            payload, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            skip_regexes, extract_regexes,
+        )
 
-    # Dispatch to sync or async worker based on the nature of the 'payload'
-    if hasattr(payload, "__aiter__"):
+    # Handle async iterables
+    if hasattr(data, "__aiter__"):
         return _sanitize_stream_async(
-            payload, intro_value, to_json, skip_markers, strip_chars,
+            data, intro_value, to_json, skip_markers, strip_chars,
+            start_marker, end_marker, content_extractor, yield_raw_on_error,
+            encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            skip_regexes, extract_regexes,
+        )
+    # Handle sync iterables (but not strings/bytes)
+    if hasattr(data, "__iter__"):
+        return _sanitize_stream_sync(
+            data, intro_value, to_json, skip_markers, strip_chars,
             start_marker, end_marker, content_extractor, yield_raw_on_error,
             encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+            skip_regexes, extract_regexes,
         )
+    # Fallback: treat as string
     return _sanitize_stream_sync(
-        payload, intro_value, to_json, skip_markers, strip_chars,
+        str(data), intro_value, to_json, skip_markers, strip_chars,
         start_marker, end_marker, content_extractor, yield_raw_on_error,
         encoding, encoding_errors, buffer_size, line_delimiter, error_handler,
+        skip_regexes, extract_regexes,
     )
+
+# --- Decorator version of sanitize_stream ---
+import functools
+from typing import overload
+
+def _sanitize_stream_decorator(
+    _func=None,
+    *,
+    intro_value: str = "data:",
+    to_json: bool = True,
+    skip_markers: Optional[List[str]] = None,
+    strip_chars: Optional[str] = None,
+    start_marker: Optional[str] = None,
+    end_marker: Optional[str] = None,
+    content_extractor: Optional[Callable[[Union[str, Dict[str, Any]]], Optional[Any]]] = None,
+    yield_raw_on_error: bool = True,
+    encoding: EncodingType = "utf-8",
+    encoding_errors: str = "replace",
+    buffer_size: int = 8192,
+    line_delimiter: Optional[str] = None,
+    error_handler: Optional[Callable[[Exception, str], Optional[Any]]] = None,
+    skip_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
+    extract_regexes: Optional[List[Union[str, Pattern[str]]]] = None,
+    object_mode: Literal["as_is", "json", "str"] = "json",
+    raw: bool = False,
+):
+    """
+    Decorator for sanitize_stream. Can be used as @sanitize_stream or @sanitize_stream(...).
+    All arguments are the same as sanitize_stream().
+    """
+    def decorator(func):
+        if asyncio.iscoroutinefunction(func):
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                result = await func(*args, **kwargs)
+                return sanitize_stream(
+                    result,
+                    intro_value=intro_value,
+                    to_json=to_json,
+                    skip_markers=skip_markers,
+                    strip_chars=strip_chars,
+                    start_marker=start_marker,
+                    end_marker=end_marker,
+                    content_extractor=content_extractor,
+                    yield_raw_on_error=yield_raw_on_error,
+                    encoding=encoding,
+                    encoding_errors=encoding_errors,
+                    buffer_size=buffer_size,
+                    line_delimiter=line_delimiter,
+                    error_handler=error_handler,
+                    skip_regexes=skip_regexes,
+                    extract_regexes=extract_regexes,
+                    object_mode=object_mode,
+                    raw=raw,
+                )
+            return async_wrapper
+        else:
+            @functools.wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                result = func(*args, **kwargs)
+                return sanitize_stream(
+                    result,
+                    intro_value=intro_value,
+                    to_json=to_json,
+                    skip_markers=skip_markers,
+                    strip_chars=strip_chars,
+                    start_marker=start_marker,
+                    end_marker=end_marker,
+                    content_extractor=content_extractor,
+                    yield_raw_on_error=yield_raw_on_error,
+                    encoding=encoding,
+                    encoding_errors=encoding_errors,
+                    buffer_size=buffer_size,
+                    line_delimiter=line_delimiter,
+                    error_handler=error_handler,
+                    skip_regexes=skip_regexes,
+                    extract_regexes=extract_regexes,
+                    object_mode=object_mode,
+                    raw=raw,
+                )
+            return sync_wrapper
+    if _func is None:
+        return decorator
+    else:
+        return decorator(_func)
+
+# Alias for decorator usage
+LITSTREAM = sanitize_stream
+
+# Decorator aliases
+sanitize_stream_decorator = _sanitize_stream_decorator
+lit_streamer = _sanitize_stream_decorator
+
+# Allow @sanitize_stream and @lit_streamer as decorators
+import asyncio
+sanitize_stream.__decorator__ = _sanitize_stream_decorator
+LITSTREAM.__decorator__ = _sanitize_stream_decorator
+lit_streamer.__decorator__ = _sanitize_stream_decorator
+
+def __getattr__(name):
+    if name == 'sanitize_stream':
+        return sanitize_stream
+    if name == 'LITSTREAM':
+        return LITSTREAM
+    if name == 'sanitize_stream_decorator':
+        return _sanitize_stream_decorator
+    if name == 'lit_streamer':
+        return _sanitize_stream_decorator
+    raise AttributeError(f"module {__name__} has no attribute {name}")
 from .conversation import Conversation  # noqa: E402,F401
 from .Extra.autocoder import AutoCoder  # noqa: E402,F401
 from .optimizers import Optimizers  # noqa: E402,F401

webscout/Bard.py

@@ -81,21 +81,11 @@ class Model(Enum):
         model_header (dict): Additional headers required for the model.
         advanced_only (bool): Whether the model is available only for advanced users.
     """
-    # Updated model definitions based on reference implementation
+    # Only the specified models
     UNSPECIFIED = ("unspecified", {}, False)
-    G_2_0_FLASH = (
-        "gemini-2.0-flash",
-        {"x-goog-ext-525001261-jspb": '[1,null,null,null,"f299729663a2343f"]'},
-        False,
-    )
-    G_2_0_FLASH_THINKING = (
-        "gemini-2.0-flash-thinking",
-        {"x-goog-ext-525001261-jspb": '[null,null,null,null,"7ca48d02d802f20a"]'},
-        False,
-    )
     G_2_5_FLASH = (
         "gemini-2.5-flash",
-        {"x-goog-ext-525001261-jspb": '[1,null,null,null,"35609594dbe934d8"]'},
+        {"x-goog-ext-525001261-jspb": '[1,null,null,null,"71c2d248d3b102ff"]'},
         False,
     )
     G_2_5_PRO = (
@@ -103,16 +93,6 @@ class Model(Enum):
         {"x-goog-ext-525001261-jspb": '[1,null,null,null,"2525e3954d185b3c"]'},
         False,
     )
-    G_2_0_EXP_ADVANCED = (
-        "gemini-2.0-exp-advanced",
-        {"x-goog-ext-525001261-jspb": '[null,null,null,null,"b1e46a6037e6aa9f"]'},
-        True,
-    )
-    G_2_5_EXP_ADVANCED = (
-        "gemini-2.5-exp-advanced",
-        {"x-goog-ext-525001261-jspb": '[null,null,null,null,"203e6bb81620bcfe"]'},
-        True,
-    )
 
     def __init__(self, name, header, advanced_only):
         """

webscout/Bing_search.py

@@ -175,8 +175,7 @@ class BingSearch:
         url = self._first_page(keywords)['url']
         urls_to_fetch = [url]
         while len(fetched_results) < max_results and urls_to_fetch:
-            with self._executor as executor:
-                html_pages = list(executor.map(fetch_page, urls_to_fetch))
+            html_pages = list(self._executor.map(fetch_page, urls_to_fetch))
             urls_to_fetch = []
             for html in html_pages:
                 soup = BeautifulSoup(html, "html.parser")

webscout/Provider/AISEARCH/__init__.py

@@ -1,3 +1,4 @@
+from .stellar_search import *
 from .felo_search import *
 from .DeepFind import *
 from .genspark_search import *