webscout 2025.10.19.2__tar.gz → 2025.10.19.3__tar.gz

{webscout-2025.10.19.2/webscout.egg-info → webscout-2025.10.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 2025.10.19.2
+Version: 2025.10.19.3
 Summary: Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author-email: OEvortex <helpingai5@gmail.com>
 License: HelpingAI

{webscout-2025.10.19.2 → webscout-2025.10.19.3}/webscout/Provider/OPENAI/DeepAI.py

@@ -1,45 +1,36 @@
-"""
-DeepAI Chat Provider for webscout
-
-This provider implements the DeepAI chat API discovered through reverse engineering.
-The API uses a POST endpoint with multipart/form-data containing chat history and parameters.
-
-API Details:
-- Endpoint: https://api.deepai.org/hacking_is_a_serious_crime
-- Method: POST
-- Authentication: api-key header (trial key provided)
-- Content-Type: multipart/form-data
-- Response: Plain text AI response
-
-Features:
-- Streaming and non-streaming support
-- Conversation history management
-- Error handling and retries
-- Configurable model and chat style
-"""
 
+from curl_cffi.requests import Session, RequestsError
 from typing import List, Dict, Optional, Union, Generator, Any
 
-# Import requests for HTTP requests
-import requests
+# Import base classes and utility structures
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage, format_prompt, count_tokens
+)
 
 # Standard library imports
 import json
 import time
 import uuid
 
-# Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
-    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage
-)
-
 # Attempt to import LitAgent, fallback if not available
 try:
     from webscout.litagent import LitAgent
 except ImportError:
-    LitAgent = None
+    # Define a dummy LitAgent if webscout is not installed or accessible
+    class LitAgent:
+        def generate_fingerprint(self, browser: str = "chrome") -> Dict[str, Any]:
+            # Return minimal default headers if LitAgent is unavailable
+            print("Warning: LitAgent not found. Using default minimal headers.")
+            return {
+                "accept": "*/*",
+                "accept_language": "en-US,en;q=0.9",
+                "platform": "Windows",
+                "sec_ch_ua": '"Not/A)Brand";v="99", "Google Chrome";v="127", "Chromium";v="127"',
+                "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
+                "browser_type": browser,
+            }
 
 # --- DeepAI Client ---
 
@@ -91,20 +82,27 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, payload)
+            return self._create_stream(request_id, created_time, model, payload, timeout=timeout, proxies=proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, payload)
+            return self._create_non_stream(request_id, created_time, model, payload, timeout=timeout, proxies=proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any],
+        timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         # DeepAI doesn't actually support streaming, but we'll implement it for compatibility
         # For now, just yield the non-stream response as a single chunk
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        else:
+            self._client.session.proxies = {}
         try:
+            timeout_val = timeout if timeout is not None else self._client.timeout
             response = self._client.session.post(
                 "https://api.deepai.org/hacking_is_a_serious_crime",
                 data=payload,
-                timeout=self._client.timeout
+                timeout=timeout_val
             )
 
             if response.status_code != 200:
@@ -113,6 +111,11 @@ class Completions(BaseCompletions):
             # Get response text
             content = response.text.strip()
 
+            # Estimate token usage
+            prompt_tokens = count_tokens(payload.get("chatHistory", ""))
+            completion_tokens = count_tokens(content)
+            total_tokens = prompt_tokens + completion_tokens
+
             # Create the delta object
             delta = ChoiceDelta(
                 content=content,
@@ -137,28 +140,40 @@ class Completions(BaseCompletions):
                 system_fingerprint=None
             )
 
-            # Set usage directly on the chunk object (estimated)
+            # Set usage directly on the chunk object
             chunk.usage = {
-                "prompt_tokens": len(json.dumps(payload.get("chatHistory", []))),
-                "completion_tokens": len(content),
-                "total_tokens": len(json.dumps(payload.get("chatHistory", []))) + len(content),
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
                 "estimated_cost": None
             }
 
             yield chunk
 
-        except Exception as e:
+        except RequestsError as e:
             print(f"Error during DeepAI stream request: {e}")
             raise IOError(f"DeepAI request failed: {e}") from e
+        except Exception as e:
+            print(f"Unexpected error during DeepAI stream request: {e}")
+            raise IOError(f"DeepAI request failed: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any],
+        timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
+        original_proxies = self._client.session.proxies
+        if proxies is not None:
+            self._client.session.proxies = proxies
+        else:
+            self._client.session.proxies = {}
         try:
+            timeout_val = timeout if timeout is not None else self._client.timeout
             response = self._client.session.post(
                 "https://api.deepai.org/hacking_is_a_serious_crime",
                 data=payload,
-                timeout=self._client.timeout
+                timeout=timeout_val
             )
 
             if response.status_code != 200:
@@ -167,6 +182,11 @@ class Completions(BaseCompletions):
             # Get response text
             content = response.text.strip()
 
+            # Estimate token usage
+            prompt_tokens = count_tokens(payload.get("chatHistory", ""))
+            completion_tokens = count_tokens(content)
+            total_tokens = prompt_tokens + completion_tokens
+
             # Create the message object
             message = ChatCompletionMessage(
                 role="assistant",
@@ -180,11 +200,11 @@ class Completions(BaseCompletions):
                 finish_reason="stop"
             )
 
-            # Create the usage object (estimated)
+            # Create the usage object
             usage = CompletionUsage(
-                prompt_tokens=len(json.dumps(payload.get("chatHistory", []))),
-                completion_tokens=len(content),
-                total_tokens=len(json.dumps(payload.get("chatHistory", []))) + len(content)
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=total_tokens
             )
 
             # Create the completion object
@@ -197,15 +217,31 @@ class Completions(BaseCompletions):
             )
             return completion
 
-        except Exception as e:
+        except RequestsError as e:
             print(f"Error during DeepAI non-stream request: {e}")
             raise IOError(f"DeepAI request failed: {e}") from e
+        except Exception as e:
+            print(f"Unexpected error during DeepAI non-stream request: {e}")
+            raise IOError(f"DeepAI request failed: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
 class Chat(BaseChat):
     def __init__(self, client: 'DeepAI'):
         self.completions = Completions(client)
 
 class DeepAI(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible client for DeepAI API.
+
+    Usage:
+        client = DeepAI()
+        response = client.chat.completions.create(
+            model="standard",
+            messages=[{"role": "user", "content": "Hello!"}]
+        )
+    """
+
     AVAILABLE_MODELS = [
         "standard", 
         "genius", 
@@ -233,7 +269,6 @@ class DeepAI(OpenAICompatibleProvider):
         "gemini-2.5-pro",
         "grok-code-fast-1",
         "gpt-4.1",
-
     ]
 
     def __init__(
@@ -244,31 +279,84 @@ class DeepAI(OpenAICompatibleProvider):
         model: str = "standard",
         chat_style: str = "chat",
         enabled_tools: Optional[List[str]] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs
     ):
+        """
+        Initialize the DeepAI client.
+
+        Args:
+            api_key: DeepAI API key
+            timeout: Request timeout in seconds
+            browser: Browser type for fingerprinting
+            model: Default model to use
+            chat_style: Chat style parameter
+            enabled_tools: List of enabled tools
+            proxies: Optional proxy configuration
+        """
+        super().__init__(proxies=proxies)
         self.timeout = timeout
         self.api_key = api_key
         self.model = model
         self.chat_style = chat_style
         self.enabled_tools = enabled_tools or ["image_generator"]
 
-        # Initialize requests Session
-        self.session = requests.Session()
-        
-        # Set up headers with API key
+        # Use LitAgent for fingerprint if available, else fallback
+        agent = LitAgent()
+        self.fingerprint = agent.generate_fingerprint(browser)
+
+        # Use the fingerprint for headers
         self.headers = {
             "Content-Type": "application/x-www-form-urlencoded",
             "api-key": self.api_key,
-            "Accept": "text/plain, */*",
-            "Accept-Encoding": "gzip, deflate, br",
-            "Accept-Language": "en-US,en;q=0.9",
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Accept": self.fingerprint["accept"],
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": self.fingerprint["accept_language"],
+            "User-Agent": self.fingerprint["user_agent"],
+            "DNT": "1",
+            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or '"Not/A)Brand";v="99", "Google Chrome";v="127", "Chromium";v="127"',
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
         }
-        
-        # Update session headers
-        self.session.headers.update(self.headers)        # Initialize chat interface
+
+        # Create session cookies with unique identifiers
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
+
+        # Set consistent headers for the scraper session
+        self.session = Session()
+        for header, value in self.headers.items():
+            self.session.headers.update({header: value})
+
+        # Set cookies
+        self.session.cookies.update(self.cookies)
+
+        # Initialize the chat interface
         self.chat = Chat(self)
 
+    def refresh_identity(self, browser: str = None, impersonate: str = "chrome120"):
+        """Refreshes the browser identity fingerprint and curl_cffi session."""
+        browser = browser or self.fingerprint.get("browser_type", "chrome")
+        self.fingerprint = LitAgent().generate_fingerprint(browser)
+        self.session = Session(impersonate=impersonate)
+        # Update headers with new fingerprint
+        self.headers.update({
+            "Accept": self.fingerprint["accept"],
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or self.headers["Sec-CH-UA"],
+            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
+            "User-Agent": self.fingerprint["user_agent"],
+        })
+
+        # Update session headers
+        for header, value in self.headers.items():
+            self.session.headers.update({header: value})
+
+        # Generate new cookies
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
+        self.session.cookies.update(self.cookies)
+
+        return self.fingerprint
+
     @classmethod
     def get_models(cls, api_key: str = None):
         """Fetch available models from DeepAI API.

webscout-2025.10.19.3/webscout/version.py

@@ -0,0 +1,2 @@
+__version__ = "2025.10.19.3"
+__prog__ = "webscout"

{webscout-2025.10.19.2 → webscout-2025.10.19.3/webscout.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 2025.10.19.2
+Version: 2025.10.19.3
 Summary: Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author-email: OEvortex <helpingai5@gmail.com>
 License: HelpingAI

webscout-2025.10.19.2/webscout/version.py.bak

@@ -1,2 +0,0 @@
-__version__ = "2025.10.19.1"
-__prog__ = "webscout"