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

webscout/scout/element.py

@@ -151,7 +151,7 @@ class Tag:
         """
         return hash((self.name, frozenset(self.attrs.items()), str(self)))
 
-    def find(self, name=None, attrs={}, recursive=True, text=None, **kwargs) -> Optional['Tag']:
+    def find(self, name=None, attrs={}, recursive=True, text=None, limit=None, class_=None, **kwargs) -> Optional['Tag']:
         """
         Find the first matching child element.
         Enhanced with more flexible matching.
@@ -165,10 +165,26 @@ class Tag:
         Returns:
             Tag or None: First matching element
         """
+        # Merge class_ with attrs['class'] if both are present
+        attrs = dict(attrs) if attrs else {}
+        if class_ is not None:
+            if 'class' in attrs:
+                # Merge both
+                if isinstance(attrs['class'], list):
+                    class_list = attrs['class']
+                else:
+                    class_list = [cls.strip() for cls in re.split(r'[ ,]+', str(attrs['class'])) if cls.strip()]
+                if isinstance(class_, list):
+                    class_list += class_
+                else:
+                    class_list += [cls.strip() for cls in re.split(r'[ ,]+', str(class_)) if cls.strip()]
+                attrs['class'] = class_list
+            else:
+                attrs['class'] = class_
         results = self.find_all(name, attrs, recursive, text, limit=1, **kwargs)
         return results[0] if results else None
 
-    def find_all(self, name=None, attrs={}, recursive=True, text=None, limit=None, **kwargs) -> List['Tag']:
+    def find_all(self, name=None, attrs={}, recursive=True, text=None, limit=None, class_=None, **kwargs) -> List['Tag']:
         """
         Find all matching child elements.
         Enhanced with more flexible matching and BeautifulSoup-like features.
@@ -197,12 +213,17 @@ class Tag:
 
             # Check attributes with more flexible matching
             for k, v in attrs.items():
-                # Handle special attribute matching
                 if k == 'class':
                     tag_classes = tag.get('class', [])
-                    if isinstance(v, str) and v not in tag_classes:
-                        return False
-                    elif isinstance(v, list) and not all(cls in tag_classes for cls in v):
+                    # Support multiple classes separated by space or comma
+                    if isinstance(v, str):
+                        v_classes = [cls.strip() for cls in re.split(r'[ ,]+', v) if cls.strip()]
+                        if not all(cls in tag_classes for cls in v_classes):
+                            return False
+                    elif isinstance(v, list):
+                        if not all(cls in tag_classes for cls in v):
+                            return False
+                    else:
                         return False
                 elif k == 'id':
                     if tag.get('id') != v:
@@ -412,31 +433,131 @@ class Tag:
         """Remove all contents of the tag."""
         self.contents.clear()
 
+    @property
+    def string(self):
+        """
+        Get the string content of the tag.
+        Returns the combined text of the tag's contents.
+        """
+        return self.get_text()
+
+    @string.setter
+    def string(self, value):
+        """
+        Set the string content of the tag.
+        Clears existing contents and sets new string value.
+
+        Args:
+            value (str): New string content
+        """
+        self.clear()
+        if value is not None:
+            self.append(value)
+
     def append(self, new_child: Union['Tag', NavigableString, str]) -> None:
-        """Append a new child to this tag."""
+        """Append a new child to this tag with error handling."""
         if isinstance(new_child, str):
             new_child = NavigableString(new_child)
-        new_child.parent = self
+        if hasattr(new_child, 'parent'):
+            new_child.parent = self
         self.contents.append(new_child)
 
     def insert(self, index: int, new_child: Union['Tag', NavigableString, str]) -> None:
-        """Insert a new child at the given index."""
+        """Insert a new child at the given index with error handling."""
         if isinstance(new_child, str):
             new_child = NavigableString(new_child)
-        new_child.parent = self
+        if hasattr(new_child, 'parent'):
+            new_child.parent = self
         self.contents.insert(index, new_child)
 
     def replace_with(self, new_tag: 'Tag') -> None:
-        """
-        Replace this tag with another tag.
+        """Replace this tag with another tag with error handling."""
+        if self.parent:
+            try:
+                index = self.parent.contents.index(self)
+                self.parent.contents[index] = new_tag
+                new_tag.parent = self.parent
+            except ValueError:
+                pass
+
+    def wrap(self, wrapper_tag: 'Tag') -> 'Tag':
+        """Wrap this tag in another tag."""
+        if self.parent:
+            idx = self.parent.contents.index(self)
+            self.parent.contents[idx] = wrapper_tag
+            wrapper_tag.parent = self.parent
+        else:
+            wrapper_tag.parent = None
+        wrapper_tag.contents.append(self)
+        self.parent = wrapper_tag
+        return wrapper_tag
+
+    def unwrap(self) -> None:
+        """Remove this tag but keep its contents in the parent."""
+        if self.parent:
+            idx = self.parent.contents.index(self)
+            for child in reversed(self.contents):
+                child.parent = self.parent
+                self.parent.contents.insert(idx, child)
+            self.parent.contents.remove(self)
+            self.parent = None
+            self.contents = []
 
-        Args:
-            new_tag (Tag): Tag to replace the current tag
-        """
+    def insert_before(self, new_element: 'Tag') -> None:
+        """Insert a tag or string immediately before this tag."""
+        if self.parent:
+            idx = self.parent.contents.index(self)
+            new_element.parent = self.parent
+            self.parent.contents.insert(idx, new_element)
+
+    def insert_after(self, new_element: 'Tag') -> None:
+        """Insert a tag or string immediately after this tag."""
         if self.parent:
-            index = self.parent.contents.index(self)
-            self.parent.contents[index] = new_tag
-            new_tag.parent = self.parent
+            idx = self.parent.contents.index(self)
+            new_element.parent = self.parent
+            self.parent.contents.insert(idx + 1, new_element)
+
+    @property
+    def descendants(self):
+        """Yield all descendants in document order."""
+        for child in self.contents:
+            yield child
+            if isinstance(child, Tag):
+                yield from child.descendants
+
+    @property
+    def parents(self):
+        """Yield all parents up the tree."""
+        current = self.parent
+        while current:
+            yield current
+            current = current.parent
+
+    @property
+    def next_element(self):
+        """Return the next element in document order."""
+        if self.contents:
+            return self.contents[0]
+        current = self
+        while current.parent:
+            idx = current.parent.contents.index(current)
+            if idx + 1 < len(current.parent.contents):
+                return current.parent.contents[idx + 1]
+            current = current.parent
+        return None
+
+    @property
+    def previous_element(self):
+        """Return the previous element in document order."""
+        if not self.parent:
+            return None
+        idx = self.parent.contents.index(self)
+        if idx > 0:
+            prev = self.parent.contents[idx - 1]
+            while isinstance(prev, Tag) and prev.contents:
+                prev = prev.contents[-1]
+            return prev
+        return self.parent
 
     def decode_contents(self, eventual_encoding='utf-8') -> str:
         """

webscout/swiftcli/core/cli.py

@@ -223,9 +223,20 @@ class CLI:
         # Handle options
         if hasattr(func, '_options'):
             for opt in func._options:
-                name = opt['param_decls'][0].lstrip('-').replace('-', '_')
-                if name in parsed_args:
-                    value = parsed_args[name]
+                # Use the longest parameter name (usually the --long-form) for the parameter name
+                param_names = [p.lstrip('-').replace('-', '_') for p in opt['param_decls']]
+                name = max(param_names, key=len)  # Use the longest name
+
+                # Check all possible parameter names in parsed args
+                value = None
+                found = False
+                for param_name in param_names:
+                    if param_name in parsed_args:
+                        value = parsed_args[param_name]
+                        found = True
+                        break
+
+                if found:
                     if 'type' in opt:
                         value = convert_type(value, opt['type'], name)
                     if 'choices' in opt and opt['choices']:

webscout/swiftcli/decorators/output.py

@@ -5,16 +5,62 @@ from typing import Any, Callable, List, Optional, Union
 
 from rich.console import Console
 from rich.table import Table
-from rich.progress import (
-    Progress,
-    SpinnerColumn,
-    TextColumn,
-    BarColumn,
-    TaskProgressColumn,
-    TimeRemainingColumn
-)
 from rich.panel import Panel
 
+# Handle different versions of rich
+try:
+    from rich.progress import (
+        Progress,
+        SpinnerColumn,
+        TextColumn,
+        BarColumn,
+        TaskProgressColumn,
+        TimeRemainingColumn
+    )
+except ImportError:
+    # Fallback for older versions of rich
+    try:
+        from rich.progress import (
+            Progress,
+            SpinnerColumn,
+            TextColumn,
+            BarColumn,
+            TimeRemainingColumn
+        )
+        # Create a simple TaskProgressColumn replacement for older versions
+        class TaskProgressColumn:
+            def __init__(self):
+                pass
+
+            def __call__(self, task):
+                return f"{task.percentage:.1f}%"
+
+    except ImportError:
+        # If rich is too old, create minimal fallbacks
+        class Progress:
+            def __init__(self, *args, **kwargs):
+                pass
+            def __enter__(self):
+                return self
+            def __exit__(self, *args):
+                pass
+            def add_task(self, description, total=None):
+                return 0
+            def update(self, task_id, **kwargs):
+                pass
+
+        class SpinnerColumn:
+            pass
+        class TextColumn:
+            def __init__(self, text):
+                pass
+        class BarColumn:
+            pass
+        class TaskProgressColumn:
+            pass
+        class TimeRemainingColumn:
+            pass
+
 console = Console()
 
 def table_output(
@@ -111,7 +157,11 @@ def progress(
             if show_bar:
                 columns.append(BarColumn())
             if show_percentage:
-                columns.append(TaskProgressColumn())
+                try:
+                    columns.append(TaskProgressColumn())
+                except:
+                    # Fallback for older rich versions
+                    columns.append(TextColumn("[progress.percentage]{task.percentage:>3.0f}%"))
             if show_time:
                 columns.append(TimeRemainingColumn())
             

webscout/update_checker.py

@@ -1,21 +1,11 @@
-from pkg_resources import get_distribution, DistributionNotFound as PackageNotFoundError
-def get_package_version(package_name: str) -> str:
-    return get_distribution(package_name).version
-"""
-Webscout Update Checker
->>> from webscout import check_for_updates
->>> result = check_for_updates()
->>> print(result)
-'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
-"""
-
+import importlib.metadata
 from typing import Optional, Dict, Any, Literal
-
 import requests
 from packaging import version
 
 # Constants
 PYPI_URL = "https://pypi.org/pypi/webscout/json"
+YOUTUBE_URL = "https://youtube.com/@OEvortex"
 
 # Create a session for HTTP requests
 session = requests.Session()
@@ -23,6 +13,13 @@ session = requests.Session()
 # Version comparison result type
 VersionCompareResult = Literal[-1, 0, 1]
 
+def get_package_version(package_name: str) -> Optional[str]:
+    """Get the installed version of a package by name."""
+    try:
+        return importlib.metadata.version(package_name)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
 def get_installed_version() -> Optional[str]:
     """Get the currently installed version of webscout.
 
@@ -34,10 +31,7 @@ def get_installed_version() -> Optional[str]:
         >>> print(version)
         '1.2.3'
     """
-    try:
-        return get_package_version('webscout')
-    except PackageNotFoundError:
-        return None
+    return get_package_version('webscout')
 
 def get_pypi_version() -> Optional[str]:
     """Get the latest version available on PyPI.
@@ -54,19 +48,15 @@ def get_pypi_version() -> Optional[str]:
         response = session.get(PYPI_URL, timeout=10)
         response.raise_for_status()
         data: Dict[str, Any] = response.json()
-        return data['info']['version']
+        return data.get('info', {}).get('version')
     except (requests.RequestException, KeyError, ValueError):
         return None
 
 def version_compare(v1: str, v2: str) -> VersionCompareResult:
     """Compare two version strings.
 
-    Args:
-        v1: First version string
-        v2: Second version string to compare with
-
     Returns:
-        VersionCompareResult: -1 if v1 < v2, 1 if v1 > v2, 0 if equal
+        -1 if v1 < v2, 1 if v1 > v2, 0 if equal or invalid
 
     Examples:
         >>> version_compare('1.0.0', '2.0.0')
@@ -80,48 +70,40 @@ def version_compare(v1: str, v2: str) -> VersionCompareResult:
         if version1 > version2:
             return 1
         return 0
-    except version.InvalidVersion:
+    except Exception:
         return 0
 
-def get_update_message(installed: str, latest: str) -> Optional[str]:
-    """Generate appropriate update message based on version comparison.
-
-    Args:
-        installed: Currently installed version
-        latest: Latest available version
-
-    Returns:
-        Optional[str]: Update message if needed, None if already on latest version
-
-    Examples:
-        >>> get_update_message('1.0.0', '2.0.0')
-        'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
-    """
+def get_update_message(installed: str, latest: str) -> str:
+    """Generate appropriate update message based on version comparison."""
     comparison_result = version_compare(installed, latest)
+    youtube_msg = f'\033[1;32mSubscribe to my YouTube Channel: {YOUTUBE_URL}\033[0m'
     if comparison_result < 0:
-        return f"New Webscout version available: {latest} - Update with: pip install --upgrade webscout"
+        # Bold red for update available
+        return (
+            f"\033[1;31mNew Webscout version available: {latest} "
+            f"- Update with: pip install --upgrade webscout\033[0m\n{youtube_msg}"
+        )
     elif comparison_result > 0:
-        return f"You're running a development version ({installed}) ahead of latest release ({latest})"
-    return None  # Already on the latest version
+        # Bold yellow for dev version
+        return (
+            f"\033[1;33mYou're running a development version ({installed}) "
+            f"ahead of latest release ({latest})\033[0m\n{youtube_msg}"
+        )
+    # Bold green for up-to-date
 
 def check_for_updates() -> Optional[str]:
     """Check if a newer version of Webscout is available.
 
     Returns:
         Optional[str]: Update message if newer version exists, None otherwise
-
-    Examples:
-        >>> result = check_for_updates()
-        >>> print(result)
-        'New Webscout version available: 2.0.0 - Update with: pip install --upgrade webscout'
     """
     installed_version = get_installed_version()
     if not installed_version:
-        return None
+        return "\033[1;31mWebscout is not installed.\033[0m"
 
     latest_version = get_pypi_version()
     if not latest_version:
-        return None
+        return "\033[1;31mCould not retrieve latest version from PyPI.\033[0m"
 
     return get_update_message(installed_version, latest_version)
 
@@ -131,6 +113,6 @@ if __name__ == "__main__":
         if update_message:
             print(update_message)
     except KeyboardInterrupt:
-        print("Update check canceled")
+        print("\nUpdate check canceled by user.")
     except Exception as e:
-        print(f"Update check failed: {str(e)}")
+        print(f"\033[1;31mUpdate check failed: {str(e)}\033[0m")

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "8.3"
+__version__ = "8.3.2"
 __prog__ = "webscout"

webscout/webscout_search.py

@@ -16,7 +16,7 @@ from types import TracebackType
 from typing import Any, cast
 import os
 from typing import Literal, Iterator
-
+from webscout.litagent import LitAgent
 import curl_cffi.requests  # type: ignore
 
 try:
@@ -83,17 +83,9 @@ class WEBS:
             self.proxy = proxies.get("http") or proxies.get("https") if isinstance(proxies, dict) else proxies
 
         default_headers = {
-            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-            "Accept-Language": "en-US,en;q=0.5",
-            "Accept-Encoding": "gzip, deflate, br",
-            "DNT": "1",
-            "Connection": "keep-alive",
-            "Upgrade-Insecure-Requests": "1",
-            "Sec-Fetch-Dest": "document",
-            "Sec-Fetch-Mode": "navigate",
-            "Sec-Fetch-Site": "none",
-            "Sec-Fetch-User": "?1",
-            "Referer": "https://duckduckgo.com/",
+            **LitAgent().generate_fingerprint(),
+            "Origin": "https://duckduckgo.com",
+            "Referer": "https://yep.com/",
         }
 
         self.headers = headers if headers else {}

webscout/webscout_search_async.py

@@ -16,6 +16,8 @@ from lxml.etree import _Element
 from lxml.html import HTMLParser as LHTMLParser
 from lxml.html import document_fromstring
 
+from webscout.litagent.agent import LitAgent
+
 from .exceptions import ConversationLimitException, RatelimitE, TimeoutE, WebscoutE
 from .utils import (
     _expand_proxy_tb_alias,
@@ -74,16 +76,7 @@ class AsyncWEBS:
             self.proxy = proxies.get("http") or proxies.get("https") if isinstance(proxies, dict) else proxies
 
         default_headers = {
-            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-            "Accept-Language": "en-US,en;q=0.5",
-            "Accept-Encoding": "gzip, deflate, br",
-            "DNT": "1",
-            "Connection": "keep-alive",
-            "Upgrade-Insecure-Requests": "1",
-            "Sec-Fetch-Dest": "document",
-            "Sec-Fetch-Mode": "navigate",
-            "Sec-Fetch-Site": "none",
-            "Sec-Fetch-User": "?1",
+            **LitAgent().generate_fingerprint(),
             "Referer": "https://duckduckgo.com/",
         }
 

webscout/yep_search.py

@@ -35,20 +35,11 @@ class YepSearch:
             timeout=timeout # Set timeout directly in session
         )
         self.session.headers.update({
-            "Accept": "*/*",
-            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
-            "DNT": "1",
+            **LitAgent().generate_fingerprint(),
             "Origin": "https://yep.com",
             "Referer": "https://yep.com/",
-            # Sec-Ch-Ua headers are often handled by impersonate, but keeping them might be safer
-            "Sec-Ch-Ua": '"Not(A:Brand";v="99", "Microsoft Edge";v="133", "Chromium";v="133"',
-            "Sec-Ch-Ua-Mobile": "?0",
-            "Sec-Ch-Ua-Platform": '"Windows"',
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-site",
-            "User-Agent": LitAgent().random() # Keep custom User-Agent or rely on impersonate
         })
+
         # Proxies and verify are handled by the Session constructor now
 
     def _remove_html_tags(self, text: str) -> str:

{webscout-8.3.dist-info → webscout-8.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 8.3
+Version: 8.3.2
 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
@@ -71,6 +71,8 @@ Requires-Dist: uvicorn[standard]; extra == "api"
 Requires-Dist: pydantic; extra == "api"
 Requires-Dist: python-multipart; extra == "api"
 Requires-Dist: tiktoken; extra == "api"
+Requires-Dist: motor; extra == "api"
+Requires-Dist: jinja2; extra == "api"
 Dynamic: license-file
 
 <div align="center">
@@ -227,14 +229,14 @@ uv add "webscout[api]"
 uv run webscout --help
 
 # Run with API dependencies
-uv run --extra api webscout-server
+uv run webscout --extra api webscout-server
 
 # Install as a UV tool for global access
 uv tool install webscout
 
 # Use UV tool commands
 webscout --help
-webscout-server --help
+webscout-server
 ```
 
 ### 🔧 Development Installation
@@ -308,7 +310,7 @@ uv run --extra api webscout-server
 ```bash
 # Traditional Python module execution
 python -m webscout --help
-python -m webscout.client  # Start API server
+python -m webscout-server
 ```
 
 <details open>
@@ -403,13 +405,19 @@ webscout-server --port 8080
 # Start with API key authentication
 webscout-server --api-key "your-secret-key"
 
+# Start in no-auth mode using command line flag (no API key required)
+webscout-server --no-auth
+
+# Start in no-auth mode using environment variable
+$env:WEBSCOUT_NO_AUTH='true'; webscout-server
+
 # Specify a default provider
 webscout-server --default-provider "Claude"
 
 # Run in debug mode
 webscout-server --debug
 
-# Get help for all options
+# Get help for all options (includes authentication options)
 webscout-server --help
 ```
 
@@ -420,17 +428,36 @@ webscout-server --help
 uv run --extra api webscout-server
 
 # Using Python module
-python -m webscout.client
+python -m webscout.auth.server
+```
+
+#### Environment Variables
+
+Webscout server supports configuration through environment variables:
 
-# Legacy method (still supported)
-python -m webscout.Provider.OPENAI.api
+```bash
+# Start server in no-auth mode (no API key required)
+$env:WEBSCOUT_NO_AUTH='true'; webscout-server
+
+# Disable rate limiting
+$env:WEBSCOUT_NO_RATE_LIMIT='true'; webscout-server
+
+# Start with custom port using environment variable
+$env:WEBSCOUT_PORT='7860'; webscout-server
 ```
 
+For a complete list of supported environment variables and Docker deployment options, see [DOCKER.md](DOCKER.md).
+
+
 #### From Python Code
 
+> **Recommended:**  
+> Use `start_server` from `webscout.client` for the simplest programmatic startup.  
+> For advanced control (custom host, debug, etc.), use `run_api`.
+
 ```python
-# Method 1: Using the helper function
-from webscout.client import start_server  # <--- Now recommended
+# Method 1: Using the helper function (recommended)
+from webscout.client import start_server
 
 # Start with default settings
 start_server()
@@ -438,7 +465,10 @@ start_server()
 # Start with custom settings
 start_server(port=8080, api_key="your-secret-key", default_provider="Claude")
 
-# Method 2: Using the run_api function for more control
+# Start in no-auth mode (no API key required)
+start_server(no_auth=True)
+
+# Method 2: Advanced usage with run_api
 from webscout.client import run_api
 
 run_api(