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

webscout/Provider/OPENAI/base.py

@@ -3,12 +3,11 @@ from typing import List, Dict, Optional, Union, Generator, Any, TypedDict, Calla
 import json
 import logging
 from dataclasses import dataclass
-
 logger = logging.getLogger(__name__)
 
 
 # Import the utils for response structures
-from webscout.Provider.OPENAI.utils import ChatCompletion, ChatCompletionChunk, Choice, ChatCompletionMessage, ToolCall, ToolFunction
+from webscout.Provider.OPENAI.utils import ChatCompletion, ChatCompletionChunk
 
 # Define tool-related structures
 class ToolDefinition(TypedDict):
@@ -78,6 +77,8 @@ class BaseCompletions(ABC):
         top_p: Optional[float] = None,
         tools: Optional[List[Union[Tool, Dict[str, Any]]]] = None,  # Support for tool definitions
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,  # Support for tool_choice parameter
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -172,10 +173,93 @@ class BaseChat(ABC):
     completions: BaseCompletions
 
 
+# class ProxyAutoMeta(ABCMeta):
+#     """
+#     Metaclass to ensure all OpenAICompatibleProvider subclasses automatically get proxy support.
+#     This will inject proxies into any requests.Session, httpx.Client, or curl_cffi session attributes found on the instance.
+
+#     To disable automatic proxy injection, set disable_auto_proxy=True in the constructor or
+#     set the class attribute DISABLE_AUTO_PROXY = True.
+#     """
+#     def __call__(cls, *args, **kwargs):
+#         instance = super().__call__(*args, **kwargs)
+
+#         # Check if auto proxy is disabled
+#         disable_auto_proxy = kwargs.get('disable_auto_proxy', False) or getattr(cls, 'DISABLE_AUTO_PROXY', False)
+
+#         proxies = getattr(instance, 'proxies', None) or kwargs.get('proxies', None)
+#         if proxies is None and not disable_auto_proxy:
+#             try:
+#                 proxies = {"http": get_auto_proxy(), "https": get_auto_proxy()}
+#             except Exception as e:
+#                 logger.warning(f"Failed to get auto proxy, disabling proxy support: {e}")
+#                 proxies = {}
+#         elif proxies is None:
+#             proxies = {}
+#         instance.proxies = proxies
+#         # Patch sessions if we have valid proxies
+#         if proxies:
+#             for attr in dir(instance):
+#                 obj = getattr(instance, attr)
+#                 if isinstance(obj, requests.Session):
+#                     obj.proxies.update(proxies)
+#                 if httpx and isinstance(obj, httpx.Client):
+#                     try:
+#                         obj._proxies = proxies
+#                     except Exception:
+#                         pass
+#                 # Patch curl_cffi sessions if present
+#                 if CurlSession and isinstance(obj, CurlSession):
+#                     try:
+#                         obj.proxies.update(proxies)
+#                     except Exception:
+#                         pass
+#                 if CurlAsyncSession and isinstance(obj, CurlAsyncSession):
+#                     try:
+#                         obj.proxies.update(proxies)
+#                     except Exception:
+#                         pass
+#         # Provide helpers for proxied sessions
+#         def get_proxied_session():
+#             s = requests.Session()
+#             s.proxies.update(proxies)
+#             return s
+#         instance.get_proxied_session = get_proxied_session
+
+#         def get_proxied_curl_session(impersonate="chrome120", **kwargs):
+#             """Get a curl_cffi Session with proxies configured"""
+#             if CurlSession:
+#                 return CurlSession(proxies=proxies, impersonate=impersonate, **kwargs)
+#             else:
+#                 raise ImportError("curl_cffi is not installed")
+#         instance.get_proxied_curl_session = get_proxied_curl_session
+
+#         def get_proxied_curl_async_session(impersonate="chrome120", **kwargs):
+#             """Get a curl_cffi AsyncSession with proxies configured"""
+#             if CurlAsyncSession:
+#                 return CurlAsyncSession(proxies=proxies, impersonate=impersonate, **kwargs)
+#             else:
+#                 raise ImportError("curl_cffi is not installed")
+#         instance.get_proxied_curl_async_session = get_proxied_curl_async_session
+
+#         return instance
+# class OPENAICompatibleMeta(ABC, metaclass=ProxyAutoMeta):
 class OpenAICompatibleProvider(ABC):
     """
     Abstract Base Class for providers mimicking the OpenAI Python client structure.
     Requires a nested 'chat.completions' structure with tool support.
+    All subclasses automatically get proxy support via ProxyAutoMeta.
+
+    # Available proxy helpers:
+    # - self.get_proxied_session() - returns a requests.Session with proxies
+    # - self.get_proxied_curl_session() - returns a curl_cffi.Session with proxies
+    # - self.get_proxied_curl_async_session() - returns a curl_cffi.AsyncSession with proxies
+
+    # Proxy support is automatically injected into:
+    # - requests.Session objects
+    # - httpx.Client objects
+    # - curl_cffi.requests.Session objects
+    # - curl_cffi.requests.AsyncSession objects
     """
     chat: BaseChat
     available_tools: Dict[str, Tool] = {}  # Dictionary of available tools
@@ -183,19 +267,14 @@ class OpenAICompatibleProvider(ABC):
     supports_tool_choice: bool = False  # Whether the provider supports tool_choice
 
     @abstractmethod
-    def __init__(self, api_key: Optional[str] = None, tools: Optional[List[Tool]] = None, **kwargs: Any):
-        """
-        Initialize the provider, potentially with an API key and tools.
-        
-        Args:
-            api_key: Optional API key for the provider
-            tools: Optional list of tools to make available to the provider
-            **kwargs: Additional provider-specific parameters
-        """
+    def __init__(self, api_key: Optional[str] = None, tools: Optional[List[Tool]] = None, proxies: Optional[dict] = None, **kwargs: Any):
         self.available_tools = {}
         if tools:
             self.register_tools(tools)
-        raise NotImplementedError
+        # self.proxies is set by ProxyAutoMeta
+        # Subclasses should use self.proxies for all network requests
+        # Optionally, use self.get_proxied_session() for a requests.Session with proxies
+        # raise NotImplementedError  # <-- Commented out for metaclass test
 
     @property
     @abstractmethod

webscout/Provider/OPENAI/c4ai.py

@@ -49,6 +49,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -88,14 +90,21 @@ class Completions(BaseCompletions):
 
         # Pass the formatted conversation prompt
         if stream:
-            return self._create_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt)
+            return self._create_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt, timeout=timeout, proxies=proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt)
+            return self._create_non_stream(request_id, created_time, model, conversation_id, conversation_prompt, system_prompt, timeout=timeout, proxies=proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, conversation_id: str, prompt: str, system_prompt: str
+        self, request_id: str, created_time: int, model: str, conversation_id: str, prompt: str, system_prompt: str,
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
+        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
             message_id = self._client._conversation_data[model]["messageId"]
             url = f"{self._client.url}/api/chat/message"
             payload = {
@@ -117,7 +126,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout_val,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -160,11 +170,20 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"Error during C4AI stream request: {e}")
             raise IOError(f"C4AI 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, conversation_id: str, prompt: str, system_prompt: str
+        self, request_id: str, created_time: int, model: str, conversation_id: str, prompt: str, system_prompt: str,
+        timeout: Optional[int] = None, proxies: Optional[dict] = 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
             message_id = self._client._conversation_data[model]["messageId"]
             url = f"{self._client.url}/api/chat/message"
             payload = {
@@ -185,7 +204,8 @@ class Completions(BaseCompletions):
                 url,
                 headers=self._client.headers,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout_val,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
 
@@ -213,6 +233,8 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"Error during C4AI non-stream request: {e}")
             raise IOError(f"C4AI request failed: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
 class Chat(BaseChat):
     def __init__(self, client: 'C4AI'):
@@ -242,19 +264,18 @@ class C4AI(OpenAICompatibleProvider):
 
     def __init__(
         self,
-        timeout: Optional[int] = None,
         browser: str = "chrome"
     ):
         """
         Initialize the C4AI client.
 
         Args:
-            timeout: Request timeout in seconds.
             browser: Browser name for LitAgent to generate User-Agent.
         """
-        self.timeout = timeout
+        self.timeout = 30
         self.url = "https://cohereforai-c4ai-command.hf.space"
         self.session = requests.Session()
+        self.session.proxies = {}
         self.max_tokens_to_sample = 2000
 
         agent = LitAgent()
@@ -370,4 +391,4 @@ class C4AI(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()

webscout/Provider/OPENAI/chatgpt.py

@@ -9,8 +9,8 @@ from datetime import datetime, timedelta
 from typing import List, Dict, Optional, Union, Generator, Any
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage, count_tokens
 )
@@ -21,13 +21,37 @@ RED = "\033[91m"
 RESET = "\033[0m"
 
 class ChatGPTReversed:
+    AVAILABLE_MODELS = [
+        "auto", 
+        "gpt-4o-mini", 
+        "gpt-4o", 
+        "o4-mini",
+        "gpt-4-1",
+        "gpt-4-1-mini",
+        "o3",
+        "o4-mini-high"
+
+
+
+    ]
     csrf_token = None
     initialized = False
-    AVAILABLE_MODELS = ["auto", "gpt-4o-mini", "gpt-4o", "o4-mini"]
+
+    _instance = None
+
+    def __new__(cls, model="auto"):
+        if cls._instance is None:
+            cls._instance = super(ChatGPTReversed, cls).__new__(cls)
+            cls._instance.initialized = False
+        return cls._instance
 
     def __init__(self, model="auto"):
-        if ChatGPTReversed.initialized:
-            raise Exception("ChatGPTReversed has already been initialized.")
+        if self.initialized:
+            # Already initialized, just update model if needed
+            if model not in self.AVAILABLE_MODELS:
+                raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+            self.model = model
+            return
 
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
@@ -332,6 +356,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -362,6 +388,8 @@ class Completions(BaseCompletions):
                 max_tokens=max_tokens,
                 temperature=temperature,
                 top_p=top_p,
+                timeout=timeout,
+                proxies=proxies,
                 **kwargs
             )
         
@@ -372,6 +400,8 @@ class Completions(BaseCompletions):
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
+            timeout=timeout,
+            proxies=proxies,
             **kwargs
         )
 
@@ -383,6 +413,8 @@ class Completions(BaseCompletions):
         max_tokens: Optional[int] = None,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Implementation for streaming chat completions."""
@@ -448,6 +480,8 @@ class Completions(BaseCompletions):
         max_tokens: Optional[int] = None,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> ChatCompletion:
         """Implementation for non-streaming chat completions."""
@@ -523,34 +557,32 @@ class ChatGPT(OpenAICompatibleProvider):
         print(response.choices[0].message.content)
     """
 
-    AVAILABLE_MODELS = [
-        "auto", 
-        "gpt-4o-mini", 
-        "gpt-4o", 
-        "o4-mini"
-    ]
-
     def __init__(
-        self,
-        timeout: int = 60,
-        proxies: dict = {}
+        self
     ):
         """
         Initialize the ChatGPT client.
-
-        Args:
-            timeout: Request timeout in seconds
-            proxies: Optional proxy configuration
         """
-        self.timeout = timeout
-        self.proxies = proxies
-        
         # Initialize chat interface
         self.chat = Chat(self)
 
+    @property
+    def AVAILABLE_MODELS(self):
+        return ChatGPTReversed.AVAILABLE_MODELS
+
     @property
     def models(self):
         class _ModelList:
             def list(inner_self):
-                return type(self).AVAILABLE_MODELS
-        return _ModelList()
+                return ChatGPTReversed.AVAILABLE_MODELS
+        return _ModelList()
+
+if __name__ == "__main__":
+    # Example usage
+    client = ChatGPT()
+    response = client.chat.completions.create(
+        model="o4-mini-high",
+        messages=[{"role": "user", "content": "How manr r in strawberry"}]
+    )
+    print(response.choices[0].message.content)
+    print()

webscout/Provider/OPENAI/chatgptclone.py

@@ -7,8 +7,8 @@ import re
 from typing import List, Dict, Optional, Union, Generator, Any
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage, count_tokens
 )
@@ -46,6 +46,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -75,21 +77,28 @@ 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] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
+        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(
                 f"{self._client.url}/api/chat",
                 headers=self._client.headers,
                 cookies=self._client.cookies,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout_val
             )
 
             # Handle non-200 responses
@@ -104,7 +113,7 @@ class Completions(BaseCompletions):
                         cookies=self._client.cookies,
                         json=payload,
                         stream=True,
-                        timeout=self._client.timeout
+                        timeout=timeout_val
                     )
                     if not response.ok:
                         raise IOError(
@@ -230,11 +239,20 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"Error during ChatGPTClone stream request: {e}")
             raise IOError(f"ChatGPTClone 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] = 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
             # For non-streaming, we still use streaming internally to collect the full response
             response = self._client.session.post(
                 f"{self._client.url}/api/chat",
@@ -242,7 +260,7 @@ class Completions(BaseCompletions):
                 cookies=self._client.cookies,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout_val
             )
 
             # Handle non-200 responses
@@ -257,7 +275,7 @@ class Completions(BaseCompletions):
                         cookies=self._client.cookies,
                         json=payload,
                         stream=True,
-                        timeout=self._client.timeout
+                        timeout=timeout_val
                     )
                     if not response.ok:
                         raise IOError(
@@ -330,6 +348,8 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"Error during ChatGPTClone non-stream request: {e}")
             raise IOError(f"ChatGPTClone request failed: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
 class Chat(BaseChat):
     def __init__(self, client: 'ChatGPTClone'):
@@ -352,7 +372,6 @@ class ChatGPTClone(OpenAICompatibleProvider):
 
     def __init__(
         self,
-        timeout: Optional[int] = None,
         browser: str = "chrome",
         impersonate: str = "chrome120"
     ):
@@ -360,16 +379,16 @@ class ChatGPTClone(OpenAICompatibleProvider):
         Initialize the ChatGPTClone client.
 
         Args:
-            timeout: Request timeout in seconds (None for no timeout)
             browser: Browser to emulate in user agent (for LitAgent fallback)
             impersonate: Browser impersonation for curl_cffi (default: chrome120)
         """
-        self.timeout = timeout
+        self.timeout = 30
         self.temperature = 0.6  # Default temperature
         self.top_p = 0.7  # Default top_p
 
         # Use curl_cffi for Cloudflare bypass and browser impersonation
-        self.session = Session(impersonate=impersonate, timeout=timeout)
+        self.session = Session(impersonate=impersonate)
+        self.session.proxies = {}
 
         # Use LitAgent for fingerprint if available, else fallback
         agent = LitAgent()
@@ -405,7 +424,7 @@ class ChatGPTClone(OpenAICompatibleProvider):
         browser = browser or self.fingerprint.get("browser_type", "chrome")
         impersonate = impersonate or "chrome120"
         self.fingerprint = LitAgent().generate_fingerprint(browser)
-        self.session = Session(impersonate=impersonate, timeout=self.timeout)
+        self.session = Session(impersonate=impersonate)
         # Update headers with new fingerprint
         self.headers.update({
             "Accept": self.fingerprint["accept"],
@@ -491,4 +510,15 @@ class ChatGPTClone(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()
+if __name__ == "__main__":
+    # Example usage
+    client = ChatGPTClone()
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.choices[0].message.content)
+    print()
+    print("Proxies on instance:", client.proxies)
+    print("Proxies on session:", client.session.proxies)

webscout/Provider/OPENAI/chatsandbox.py

@@ -33,6 +33,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -70,13 +72,15 @@ class Completions(BaseCompletions):
         }
         session = requests.Session()
         session.headers.update(headers)
+        session.proxies = proxies if proxies is not None else {}
+        
         def for_stream():
             try:
                 response = session.post(
                     url,
                     json=payload,
                     stream=True,
-                    timeout=30
+                    timeout=timeout if timeout is not None else 30
                 )
                 response.raise_for_status()
                 streaming_text = ""
@@ -116,7 +120,7 @@ class Completions(BaseCompletions):
                 response = session.post(
                     url,
                     json=payload,
-                    timeout=30
+                    timeout=timeout if timeout is not None else 30
                 )
                 response.raise_for_status()
                 text = response.text
@@ -152,7 +156,7 @@ class Chat(BaseChat):
         self.completions = Completions(client)
 
 class ChatSandbox(OpenAICompatibleProvider):
-    AVAILABLE_MODELS = ["openai", "deepseek", "llama", "gemini", "mistral-large"]
+    AVAILABLE_MODELS = ["openai", "deepseek", "llama", "gemini", "mistral-large", "deepseek-r1", "deepseek-r1-full", "gemini-thinking", "openai-o1-mini", "llama", "mistral", "gemma-3"]
     chat: Chat
     def __init__(self):
         self.chat = Chat(self)