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

webscout/swiftcli/utils/parsing.py

@@ -0,0 +1,267 @@
+"""Utility functions for parsing and validating command-line arguments."""
+
+import os
+import json
+import yaml
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union, Type
+
+from ..exceptions import BadParameter, UsageError
+
+def parse_args(args: List[str]) -> Dict[str, Any]:
+    """
+    Parse command line arguments into a dictionary.
+    
+    Args:
+        args: List of command line arguments
+        
+    Returns:
+        Dictionary of parsed arguments
+        
+    Example:
+        >>> parse_args(['--name', 'test', '--flag', '-n', '42'])
+        {'name': 'test', 'flag': True, 'n': '42'}
+    """
+    parsed = {}
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        
+        # Handle flags/options
+        if arg.startswith('-'):
+            key = arg.lstrip('-').replace('-', '_')
+            
+            # Check if next arg is a value or another flag
+            if i + 1 >= len(args) or args[i + 1].startswith('-'):
+                parsed[key] = True  # Flag without value
+            else:
+                parsed[key] = args[i + 1]
+                i += 1
+        else:
+            # Positional argument
+            parsed[f'arg{len([k for k in parsed.keys() if k.startswith("arg")])}'] = arg
+        
+        i += 1
+    
+    return parsed
+
+def validate_required(
+    params: Dict[str, Any],
+    required: List[str]
+) -> None:
+    """
+    Validate required parameters are present.
+    
+    Args:
+        params: Parameter dictionary
+        required: List of required parameter names
+        
+    Raises:
+        UsageError: If required parameter is missing
+    """
+    missing = [p for p in required if p not in params]
+    if missing:
+        raise UsageError(f"Missing required parameters: {', '.join(missing)}")
+
+def convert_type(
+    value: str,
+    type_: Type,
+    param_name: str
+) -> Any:
+    """
+    Convert string value to specified type.
+    
+    Args:
+        value: String value to convert
+        type_: Target type
+        param_name: Parameter name for error messages
+        
+    Returns:
+        Converted value
+        
+    Raises:
+        BadParameter: If conversion fails
+    """
+    try:
+        if type_ == bool:
+            return value.lower() in ('true', 't', 'yes', 'y', '1')
+        return type_(value)
+    except (ValueError, TypeError):
+        raise BadParameter(
+            f"Invalid value for {param_name}: {value} (expected {type_.__name__})"
+        )
+
+def validate_choice(
+    value: Any,
+    choices: List[Any],
+    param_name: str,
+    case_sensitive: bool = True
+) -> None:
+    """
+    Validate value is one of allowed choices.
+    
+    Args:
+        value: Value to validate
+        choices: List of allowed choices
+        param_name: Parameter name for error messages
+        case_sensitive: Whether to do case-sensitive comparison
+        
+    Raises:
+        BadParameter: If value not in choices
+    """
+    if not case_sensitive and isinstance(value, str):
+        if value.lower() not in [str(c).lower() for c in choices]:
+            raise BadParameter(
+                f"Invalid choice for {param_name}: {value} "
+                f"(choose from {', '.join(str(c) for c in choices)})"
+            )
+    elif value not in choices:
+        raise BadParameter(
+            f"Invalid choice for {param_name}: {value} "
+            f"(choose from {', '.join(str(c) for c in choices)})"
+        )
+
+def load_config_file(
+    path: Union[str, Path],
+    format: str = 'auto',
+    required: bool = True
+) -> Dict[str, Any]:
+    """
+    Load configuration from file.
+    
+    Args:
+        path: Path to config file
+        format: File format (json, yaml, or auto)
+        required: Whether file is required
+        
+    Returns:
+        Configuration dictionary
+        
+    Raises:
+        UsageError: If required file not found or invalid format
+    """
+    path = Path(os.path.expanduser(path))
+    
+    if not path.exists():
+        if required:
+            raise UsageError(f"Config file not found: {path}")
+        return {}
+    
+    # Auto-detect format from extension
+    if format == 'auto':
+        format = path.suffix.lstrip('.').lower()
+        if format not in ('json', 'yaml', 'yml'):
+            raise UsageError(f"Unsupported config format: {format}")
+    
+    try:
+        with open(path) as f:
+            if format == 'json':
+                return json.load(f)
+            elif format in ('yaml', 'yml'):
+                return yaml.safe_load(f)
+            else:
+                raise UsageError(f"Unsupported config format: {format}")
+    except Exception as e:
+        raise UsageError(f"Error loading config file: {str(e)}")
+
+def parse_key_value(
+    value: str,
+    separator: str = '='
+) -> tuple:
+    """
+    Parse key-value string.
+    
+    Args:
+        value: String in format "key=value"
+        separator: Key-value separator
+        
+    Returns:
+        Tuple of (key, value)
+        
+    Raises:
+        BadParameter: If string not in key=value format
+    """
+    try:
+        key, value = value.split(separator, 1)
+        return key.strip(), value.strip()
+    except ValueError:
+        raise BadParameter(
+            f"Invalid key-value pair: {value} (expected format: key{separator}value)"
+        )
+
+def parse_list(
+    value: str,
+    separator: str = ','
+) -> List[str]:
+    """
+    Parse comma-separated list.
+    
+    Args:
+        value: Comma-separated string
+        separator: List item separator
+        
+    Returns:
+        List of strings
+    """
+    return [x.strip() for x in value.split(separator) if x.strip()]
+
+def parse_dict(
+    value: str,
+    item_separator: str = ',',
+    key_value_separator: str = '='
+) -> Dict[str, str]:
+    """
+    Parse dictionary string.
+    
+    Args:
+        value: String in format "key1=value1,key2=value2"
+        item_separator: Separator between items
+        key_value_separator: Separator between keys and values
+        
+    Returns:
+        Dictionary of key-value pairs
+        
+    Example:
+        >>> parse_dict("name=test,count=42")
+        {'name': 'test', 'count': '42'}
+    """
+    result = {}
+    if not value:
+        return result
+        
+    items = parse_list(value, item_separator)
+    for item in items:
+        key, value = parse_key_value(item, key_value_separator)
+        result[key] = value
+    
+    return result
+
+def get_env_var(
+    name: str,
+    type_: Type = str,
+    required: bool = False,
+    default: Any = None
+) -> Any:
+    """
+    Get and validate environment variable.
+    
+    Args:
+        name: Environment variable name
+        type_: Expected type
+        required: Whether variable is required
+        default: Default value if not set
+        
+    Returns:
+        Environment variable value
+        
+    Raises:
+        UsageError: If required variable not set
+    """
+    value = os.environ.get(name)
+    
+    if value is None:
+        if required:
+            raise UsageError(f"Required environment variable not set: {name}")
+        return default
+    
+    return convert_type(value, type_, name)

webscout/version.py

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

webscout/webscout_search.py

@@ -56,13 +56,7 @@ class WEBS:
         "firefox133", "firefox135",
     )  # fmt: skip
     _impersonates_os = ("android", "ios", "linux", "macos", "windows")
-    _chat_models = {
-        "gpt-4o-mini": "gpt-4o-mini",
-        "llama-3.3-70b": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-        "claude-3-haiku": "claude-3-haiku-20240307",
-        "o3-mini": "o3-mini",
-        "mistral-small-3": "mistralai/Mistral-Small-24B-Instruct-2501",
-    }
+
 
     def __init__(
         self,
@@ -119,11 +113,6 @@ class WEBS:
         self.sleep_timestamp = 0.0
 
         self._exception_event = Event()
-        self._chat_messages: list[dict[str, str]] = []
-        self._chat_tokens_count = 0
-        self._chat_vqd: str = ""
-        self._chat_vqd_hash: str = ""
-        self._chat_xfe: str = ""
 
     def __enter__(self) -> WEBS:
         return self
@@ -203,176 +192,7 @@ class WEBS:
         resp_content = self._get_url("GET", "https://duckduckgo.com", params={"q": keywords}).content
         return _extract_vqd(resp_content, keywords)
 
-    def chat_yield(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> Iterator[str]:
-        """Initiates a chat session with webscout AI.
 
-        Args:
-            keywords (str): The initial message or question to send to the AI.
-            model (str): The model to use: "gpt-4o-mini", "llama-3.3-70b", "claude-3-haiku",
-                "o3-mini", "mistral-small-3". Defaults to "gpt-4o-mini".
-            timeout (int): Timeout value for the HTTP client. Defaults to 30.
-            max_retries (int): Maximum number of retry attempts for rate limited requests. Defaults to 3.
-
-        Yields:
-            str: Chunks of the response from the AI.
-        """
-        # Get Cloudflare Turnstile token
-        def get_turnstile_token():
-            try:
-                # Visit the DuckDuckGo chat page to get the Turnstile token
-                resp_content = self._get_url(
-                    method="GET",
-                    url="https://duckduckgo.com/?q=DuckDuckGo+AI+Chat&ia=chat&duckai=1",
-                ).content
-
-                # Extract the Turnstile token if available
-                if b'cf-turnstile-response' in resp_content:
-                    token = resp_content.split(b'cf-turnstile-response="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                    return token
-                return ""
-            except Exception:
-                return ""
-
-        # x-fe-version
-        if not self._chat_xfe:
-            resp_content = self._get_url(
-                method="GET",
-                url="https://duckduckgo.com/?q=DuckDuckGo+AI+Chat&ia=chat&duckai=1",
-            ).content
-            try:
-                xfe1 = resp_content.split(b'__DDG_BE_VERSION__="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                xfe2 = resp_content.split(b'__DDG_FE_CHAT_HASH__="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                self._chat_xfe = f"{xfe1}-{xfe2}"
-            except Exception as ex:
-                raise WebscoutE(
-                    f"chat_yield() Error to get _chat_xfe: {type(ex).__name__}: {ex}"
-                ) from ex
-        # vqd
-        if not self._chat_vqd:
-            resp = self._get_url(
-                method="GET", url="https://duckduckgo.com/duckchat/v1/status", headers={"x-vqd-accept": "1"}
-            )
-            self._chat_vqd = resp.headers.get("x-vqd-4", "")
-            self._chat_vqd_hash = resp.headers.get("x-vqd-hash-1", "")
-
-        self._chat_messages.append({"role": "user", "content": keywords})
-        self._chat_tokens_count += max(len(keywords) // 4, 1)  # approximate number of tokens
-        if model not in self._chat_models:
-            warnings.warn(f"{model=} is unavailable. Using 'gpt-4o-mini'", stacklevel=1)
-            model = "gpt-4o-mini"
-
-        # Get Cloudflare Turnstile token
-        turnstile_token = get_turnstile_token()
-
-        json_data = {
-            "model": self._chat_models[model],
-            "messages": self._chat_messages,
-        }
-
-        # Add Turnstile token if available
-        if turnstile_token:
-            json_data["cf-turnstile-response"] = turnstile_token
-
-        # Enhanced headers to better mimic a real browser
-        chat_headers = {
-            "x-fe-version": self._chat_xfe,
-            "x-vqd-4": self._chat_vqd,
-            "x-vqd-hash-1": "",
-            "Accept": "text/event-stream",
-            "Accept-Language": "en-US,en;q=0.9",
-            "Cache-Control": "no-cache",
-            "Content-Type": "application/json",
-            "DNT": "1",
-            "Origin": "https://duckduckgo.com",
-            "Referer": "https://duckduckgo.com/",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "User-Agent": self.client.headers.get("User-Agent", "")
-        }
-
-        # Retry logic for rate limited requests
-        retry_count = 0
-        while retry_count <= max_retries:
-            try:
-                resp = self._get_url(
-                    method="POST",
-                    url="https://duckduckgo.com/duckchat/v1/chat",
-                    headers=chat_headers,
-                    json=json_data,
-                    timeout=timeout,
-                )
-
-                self._chat_vqd = resp.headers.get("x-vqd-4", "")
-                self._chat_vqd_hash = resp.headers.get("x-vqd-hash-1", "")
-                chunks = []
-
-                # curl_cffi uses iter_content instead of stream
-                for chunk in resp.iter_content(chunk_size=1024):
-                    lines = chunk.split(b"data:")
-                    for line in lines:
-                        if line := line.strip():
-                            if line == b"[DONE]":
-                                break
-                            if line == b"[DONE][LIMIT_CONVERSATION]":
-                                raise ConversationLimitException("ERR_CONVERSATION_LIMIT")
-                            try:
-                                x = json_loads(line)
-                                if isinstance(x, dict):
-                                    if x.get("action") == "error":
-                                        err_message = x.get("type", "")
-                                        if x.get("status") == 429:
-                                            raise (
-                                                ConversationLimitException(err_message)
-                                                if err_message == "ERR_CONVERSATION_LIMIT"
-                                                else RatelimitE(err_message)
-                                            )
-                                        raise WebscoutE(err_message)
-                                    elif message := x.get("message"):
-                                        chunks.append(message)
-                                        yield message
-                            except Exception as e:
-                                # Skip invalid JSON data
-                                continue
-
-                # If we get here, the request was successful
-                result = "".join(chunks)
-                self._chat_messages.append({"role": "assistant", "content": result})
-                self._chat_tokens_count += len(result)
-                return
-
-            except RatelimitE as ex:
-                retry_count += 1
-                if retry_count > max_retries:
-                    raise WebscoutE(f"chat_yield() Rate limit exceeded after {max_retries} retries: {ex}") from ex
-
-                # Get a fresh Turnstile token for the retry
-                turnstile_token = get_turnstile_token()
-                if turnstile_token:
-                    json_data["cf-turnstile-response"] = turnstile_token
-
-                # Exponential backoff
-                sleep_time = 2 ** retry_count
-                sleep(sleep_time)
-
-            except Exception as ex:
-                raise WebscoutE(f"chat_yield() {type(ex).__name__}: {ex}") from ex
-
-    def chat(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> str:
-        """Initiates a chat session with webscout AI.
-
-        Args:
-            keywords (str): The initial message or question to send to the AI.
-            model (str): The model to use: "gpt-4o-mini", "llama-3.3-70b", "claude-3-haiku",
-                "o3-mini", "mistral-small-3". Defaults to "gpt-4o-mini".
-            timeout (int): Timeout value for the HTTP client. Defaults to 30.
-            max_retries (int): Maximum number of retry attempts for rate limited requests. Defaults to 3.
-
-        Returns:
-            str: The response from the AI.
-        """
-        answer_generator = self.chat_yield(keywords, model, timeout, max_retries)
-        return "".join(answer_generator)
 
     def text(
         self,
@@ -1361,4 +1181,4 @@ class WEBS:
                     "visibility_m": hour.get("visibility"),
                 })
 
-        return formatted_data
+        return formatted_data

webscout/webscout_search_async.py

@@ -103,11 +103,6 @@ class AsyncWEBS:
         self.sleep_timestamp = 0.0
 
         self._exception_event = asyncio.Event()
-        self._chat_messages: List[Dict[str, str]] = []
-        self._chat_tokens_count = 0
-        self._chat_vqd: str = ""
-        self._chat_vqd_hash: str = ""
-        self._chat_xfe: str = ""
 
     async def __aenter__(self) -> AsyncWEBS:
         return self
@@ -189,179 +184,6 @@ class AsyncWEBS:
         resp_content = (await self._get_url("GET", "https://duckduckgo.com", params={"q": keywords})).content
         return _extract_vqd(resp_content, keywords)
 
-    async def achat_yield(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> AsyncIterator[str]:
-        """Initiates an async chat session with webscout AI.
-
-        Args:
-            keywords (str): The initial message or question to send to the AI.
-            model (str): The model to use: "gpt-4o-mini", "llama-3.3-70b", "claude-3-haiku",
-                "o3-mini", "mistral-small-3". Defaults to "gpt-4o-mini".
-            timeout (int): Timeout value for the HTTP client. Defaults to 30.
-            max_retries (int): Maximum number of retry attempts for rate limited requests. Defaults to 3.
-
-        Yields:
-            str: Chunks of the response from the AI.
-        """
-        # Get Cloudflare Turnstile token
-        async def get_turnstile_token():
-            try:
-                # Visit the DuckDuckGo chat page to get the Turnstile token
-                resp_content = (await self._get_url(
-                    method="GET",
-                    url="https://duckduckgo.com/?q=DuckDuckGo+AI+Chat&ia=chat&duckai=1",
-                )).content
-
-                # Extract the Turnstile token if available
-                if b'cf-turnstile-response' in resp_content:
-                    token = resp_content.split(b'cf-turnstile-response="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                    return token
-                return ""
-            except Exception:
-                return ""
-
-        # x-fe-version
-        if not self._chat_xfe:
-            resp_content = (await self._get_url(
-                method="GET",
-                url="https://duckduckgo.com/?q=DuckDuckGo+AI+Chat&ia=chat&duckai=1",
-            )).content
-            try:
-                xfe1 = resp_content.split(b'__DDG_BE_VERSION__="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                xfe2 = resp_content.split(b'__DDG_FE_CHAT_HASH__="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                self._chat_xfe = f"{xfe1}-{xfe2}"
-            except Exception as ex:
-                raise WebscoutE(
-                    f"achat_yield() Error to get _chat_xfe: {type(ex).__name__}: {ex}"
-                ) from ex
-        # vqd
-        if not self._chat_vqd:
-            resp = await self._get_url(
-                method="GET", url="https://duckduckgo.com/duckchat/v1/status", headers={"x-vqd-accept": "1"}
-            )
-            self._chat_vqd = resp.headers.get("x-vqd-4", "")
-            self._chat_vqd_hash = resp.headers.get("x-vqd-hash-1", "")
-
-        self._chat_messages.append({"role": "user", "content": keywords})
-        self._chat_tokens_count += max(len(keywords) // 4, 1)  # approximate number of tokens
-        if model not in self._chat_models:
-            warnings.warn(f"{model=} is unavailable. Using 'gpt-4o-mini'", stacklevel=1)
-            model = "gpt-4o-mini"
-
-        # Get Cloudflare Turnstile token
-        turnstile_token = await get_turnstile_token()
-
-        json_data = {
-            "model": self._chat_models[model],
-            "messages": self._chat_messages,
-        }
-
-        # Add Turnstile token if available
-        if turnstile_token:
-            json_data["cf-turnstile-response"] = turnstile_token
-
-        # Enhanced headers to better mimic a real browser
-        chat_headers = {
-            "x-fe-version": self._chat_xfe,
-            "x-vqd-4": self._chat_vqd,
-            "x-vqd-hash-1": "",
-            "Accept": "text/event-stream",
-            "Accept-Language": "en-US,en;q=0.9",
-            "Cache-Control": "no-cache",
-            "Content-Type": "application/json",
-            "DNT": "1",
-            "Origin": "https://duckduckgo.com",
-            "Referer": "https://duckduckgo.com/",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "User-Agent": self.client.headers.get("User-Agent", "")
-        }
-
-        # Retry logic for rate limited requests
-        retry_count = 0
-        while retry_count <= max_retries:
-            try:
-                resp = await self._get_url(
-                    method="POST",
-                    url="https://duckduckgo.com/duckchat/v1/chat",
-                    headers=chat_headers,
-                    json=json_data,
-                    timeout=timeout,
-                )
-
-                self._chat_vqd = resp.headers.get("x-vqd-4", "")
-                self._chat_vqd_hash = resp.headers.get("x-vqd-hash-1", "")
-                chunks = []
-
-                # curl_cffi uses aiter_content instead of aiter_bytes
-                async for chunk in resp.aiter_content(chunk_size=1024):
-                    lines = chunk.split(b"data:")
-                    for line in lines:
-                        if line := line.strip():
-                            if line == b"[DONE]":
-                                break
-                            if line == b"[DONE][LIMIT_CONVERSATION]":
-                                raise ConversationLimitException("ERR_CONVERSATION_LIMIT")
-                            try:
-                                x = json_loads(line)
-                                if isinstance(x, dict):
-                                    if x.get("action") == "error":
-                                        err_message = x.get("type", "")
-                                        if x.get("status") == 429:
-                                            raise (
-                                                ConversationLimitException(err_message)
-                                                if err_message == "ERR_CONVERSATION_LIMIT"
-                                                else RatelimitE(err_message)
-                                            )
-                                        raise WebscoutE(err_message)
-                                    elif message := x.get("message"):
-                                        chunks.append(message)
-                                        yield message
-                            except Exception:
-                                # Skip invalid JSON data
-                                continue
-
-                # If we get here, the request was successful
-                result = "".join(chunks)
-                self._chat_messages.append({"role": "assistant", "content": result})
-                self._chat_tokens_count += len(result)
-                return
-
-            except RatelimitE as ex:
-                retry_count += 1
-                if retry_count > max_retries:
-                    raise WebscoutE(f"achat_yield() Rate limit exceeded after {max_retries} retries: {ex}") from ex
-
-                # Get a fresh Turnstile token for the retry
-                turnstile_token = await get_turnstile_token()
-                if turnstile_token:
-                    json_data["cf-turnstile-response"] = turnstile_token
-
-                # Exponential backoff
-                sleep_time = 2 ** retry_count
-                await asyncio.sleep(sleep_time)
-
-            except Exception as ex:
-                raise WebscoutE(f"achat_yield() {type(ex).__name__}: {ex}") from ex
-
-    async def achat(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> str:
-        """Initiates an async chat session with webscout AI.
-
-        Args:
-            keywords (str): The initial message or question to send to the AI.
-            model (str): The model to use: "gpt-4o-mini", "llama-3.3-70b", "claude-3-haiku",
-                "o3-mini", "mistral-small-3". Defaults to "gpt-4o-mini".
-            timeout (int): Timeout value for the HTTP client. Defaults to 30.
-            max_retries (int): Maximum number of retry attempts for rate limited requests. Defaults to 3.
-
-        Returns:
-            str: The response from the AI.
-        """
-        chunks = []
-        async for chunk in self.achat_yield(keywords, model, timeout, max_retries):
-            chunks.append(chunk)
-        return "".join(chunks)
-
     async def atext(
         self,
         keywords: str,
@@ -829,4 +651,4 @@ class AsyncWEBS:
             TimeoutE: Inherits from WebscoutE, raised for API request timeouts.
         """
         # These methods are not implemented in the async version yet
-        raise NotImplementedError("aweather method is not implemented yet")
+        raise NotImplementedError("aweather method is not implemented yet")