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

webscout/Provider/OPENAI/FreeGemini.py

@@ -22,7 +22,8 @@ from webscout.Provider.OPENAI.utils import (
     ChoiceDelta,
     CompletionUsage,
     format_prompt,
-    get_system_prompt
+    get_system_prompt,
+    count_tokens
 )
 
 # ANSI escape codes for formatting
@@ -43,6 +44,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]]:
         """
@@ -68,20 +71,27 @@ class Completions(BaseCompletions):
         }
         
         if stream:
-            return self._create_stream(request_id, created_time, model, api_payload)
+            return self._create_stream(request_id, created_time, model, api_payload, timeout=timeout, proxies=proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, api_payload)
+            return self._create_non_stream(request_id, created_time, model, api_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:
+            # Ensure session proxies are reset if no specific proxies are passed for this call
+            self._client.session.proxies = {}
         try:
             response = self._client.session.post(
                 self._client.api_endpoint,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout,
-                impersonate="chrome120" 
+                timeout=timeout if timeout is not None else self._client.timeout,
+                impersonate="chrome120"
             )
             response.raise_for_status()
 
@@ -100,7 +110,7 @@ class Completions(BaseCompletions):
             for text_chunk in processed_stream:
                 if text_chunk and isinstance(text_chunk, str):
                     streaming_text += text_chunk
-                    completion_tokens += len(text_chunk) // 4  # Rough estimate
+                    completion_tokens += count_tokens(text_chunk)
                     
                     delta = ChoiceDelta(content=text_chunk, role="assistant")
                     choice = Choice(index=0, delta=delta, finish_reason=None)
@@ -126,18 +136,26 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"{RED}Error during FreeGemini stream request: {e}{RESET}")
             raise IOError(f"FreeGemini stream 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:
             # For non-streaming, we'll still use streaming since the API returns data in chunks
             response = self._client.session.post(
                 self._client.api_endpoint,
                 json=payload,
                 stream=True,  # API always returns streaming format
-                timeout=self._client.timeout,
-                impersonate="chrome120" 
+                timeout=timeout if timeout is not None else self._client.timeout,
+                impersonate="chrome120"
             )
             response.raise_for_status()
             
@@ -160,9 +178,9 @@ class Completions(BaseCompletions):
                             # Skip invalid JSON
                             pass
             
-            # Create usage statistics (rough estimate)
-            prompt_tokens = len(str(payload)) // 4
-            completion_tokens = len(full_text_response) // 4
+            # Create usage statistics using count_tokens
+            prompt_tokens = count_tokens(str(payload))
+            completion_tokens = count_tokens(full_text_response)
             total_tokens = prompt_tokens + completion_tokens
             
             usage = CompletionUsage(
@@ -196,6 +214,8 @@ class Completions(BaseCompletions):
         except Exception as e:
             print(f"{RED}Error during FreeGemini non-stream request: {e}{RESET}")
             raise IOError(f"FreeGemini request failed: {e}") from e
+        finally:
+            self._client.session.proxies = original_proxies
 
     @staticmethod
     def _gemini_extractor(data: Dict) -> Optional[str]:
@@ -233,20 +253,17 @@ class FreeGemini(OpenAICompatibleProvider):
 
     def __init__(
         self,
-        timeout: int = 30,
     ):
         """
         Initialize the FreeGemini client.
-
-        Args:
-            timeout: Request timeout in seconds
         """
-        self.timeout = timeout
+        self.timeout = 30
         # Update the API endpoint to match the working implementation
         self.api_endpoint = "https://free-gemini.vercel.app/api/google/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse"
         
         # Initialize session with curl_cffi for better Cloudflare handling
         self.session = Session()
+        self.session.proxies = {}
         
         # Use LitAgent for fingerprinting
         self.agent = LitAgent()

webscout/Provider/OPENAI/NEMOTRON.py

@@ -9,7 +9,7 @@ from typing import List, Dict, Optional, Union, Generator, Any
 from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
 from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage, format_prompt
+    ChatCompletionMessage, CompletionUsage, format_prompt, count_tokens
 )
 try:
     from webscout.litagent import LitAgent
@@ -34,6 +34,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
     ) -> ChatCompletion:
         nemotron_model_name = self._client.convert_model_name(model)
@@ -48,13 +50,14 @@ class Completions(BaseCompletions):
         request_id = f"chatcmpl-{uuid.uuid4()}"
         created_time = int(time.time())
         # Always use non-stream mode, ignore 'stream' argument
-        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_name: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model_name: str, payload: Dict[str, Any],
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
-            response_generator = self._client._internal_make_request(payload, stream=True)
+            response_generator = self._client._internal_make_request(payload, stream=True, request_timeout=timeout, request_proxies=proxies)
             for text_chunk in response_generator:
                 if text_chunk:
                     delta = ChoiceDelta(content=text_chunk, role="assistant")
@@ -79,18 +82,19 @@ class Completions(BaseCompletions):
             raise IOError(f"NEMOTRON request failed: {e}") from e
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model_name: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model_name: str, payload: Dict[str, Any],
+        timeout: Optional[int] = None, proxies: Optional[dict] = None
     ) -> ChatCompletion:
         full_response_content = ""
         try:
-            response_generator = self._client._internal_make_request(payload, stream=False)
+            response_generator = self._client._internal_make_request(payload, stream=False, request_timeout=timeout, request_proxies=proxies)
             full_response_content = next(response_generator, "")
         except Exception as e:
             pass
         message = ChatCompletionMessage(role="assistant", content=full_response_content)
         choice = Choice(index=0, message=message, finish_reason="stop")
-        prompt_tokens = len(payload.get("content", "")) // 4 
-        completion_tokens = len(full_response_content) // 4
+        prompt_tokens = count_tokens(payload.get("content", ""))
+        completion_tokens = count_tokens(full_response_content)
         usage = CompletionUsage(
             prompt_tokens=prompt_tokens,
             completion_tokens=completion_tokens,
@@ -111,24 +115,17 @@ class Chat(BaseChat):
 
 class NEMOTRON(OpenAICompatibleProvider):
     AVAILABLE_MODELS = [
-        "NEMOTRON/gpt4o",
-        "NEMOTRON/nemotron70b",
+        "gpt4o",
+        "nemotron70b",
     ]
     
-    # Model mapping for payload
-    MODEL_PAYLOAD_MAPPING = {
-        "NEMOTRON/gpt4o": "gpt4o",
-        "NEMOTRON/nemotron70b": "nemotron70b",
-    }
-    
     API_BASE_URL = "https://nemotron.one/api/chat"
     def __init__(
-        self,
-        timeout: int = 30,
-        proxies: dict = {}
+        self
     ):
         self.session = requests.Session()
-        self.timeout = timeout
+        self.timeout = 30
+        self.session.proxies = {}
         agent = LitAgent()
         user_agent = agent.random()
         self.base_headers = {
@@ -143,8 +140,6 @@ class NEMOTRON(OpenAICompatibleProvider):
             "user-agent": user_agent
         }
         self.session.headers.update(self.base_headers)
-        if proxies:
-            self.session.proxies.update(proxies)
         self.chat = Chat(self)
 
     def _generate_random_email(self) -> str:
@@ -183,18 +178,12 @@ class NEMOTRON(OpenAICompatibleProvider):
         Returns:
             NEMOTRON model name for API payload
         """
-        # Handle NEMOTRON/ prefix aliases for payload
-        if model_alias.startswith("NEMOTRON/"):
-            base_model = model_alias.split("/")[1]
-            if base_model in ["gpt4o", "nemotron70b"]:
-                return base_model
-        
-        # Handle direct model names
-        if model_alias in ["gpt4o", "nemotron70b"]:
+        # Accept only direct model names
+        if model_alias in self.AVAILABLE_MODELS:
             return model_alias
         
         # Case-insensitive matching
-        for m in ["gpt4o", "nemotron70b"]:
+        for m in self.AVAILABLE_MODELS:
             if m.lower() == model_alias.lower():
                 return m
         
@@ -205,10 +194,19 @@ class NEMOTRON(OpenAICompatibleProvider):
     def _internal_make_request(
         self,
         payload: Dict[str, Any],
-        stream: bool = False
+        stream: bool = False,
+        request_timeout: Optional[int] = None,
+        request_proxies: Optional[dict] = None
     ) -> Generator[str, None, None]:
         request_headers = self.base_headers.copy()
         request_headers["referer"] = f"https://nemotron.one/chat/{payload['model']}"
+        original_proxies = self.session.proxies.copy()
+        if request_proxies is not None:
+            self.session.proxies.update(request_proxies)
+        elif not self.session.proxies:
+            pass
+        else:
+            self.session.proxies = {}
         try:
             if stream:
                 with self.session.post(
@@ -216,7 +214,7 @@ class NEMOTRON(OpenAICompatibleProvider):
                     headers=request_headers,
                     json=payload,
                     stream=True,
-                    timeout=self.timeout
+                    timeout=request_timeout if request_timeout is not None else self.timeout
                 ) as response:
                     response.raise_for_status()
                     yield from sanitize_stream(
@@ -228,7 +226,7 @@ class NEMOTRON(OpenAICompatibleProvider):
                     self.API_BASE_URL,
                     headers=request_headers,
                     json=payload,
-                    timeout=self.timeout
+                    timeout=request_timeout if request_timeout is not None else self.timeout
                 )
                 response.raise_for_status()
                 yield response.text
@@ -236,6 +234,8 @@ class NEMOTRON(OpenAICompatibleProvider):
             raise exceptions.ProviderConnectionError(f"NEMOTRON API Connection error: {str(e)}")
         except Exception as e:
             raise RuntimeError(f"NEMOTRON API request unexpected error: {str(e)}")
+        finally:
+            self.session.proxies = original_proxies
     @property
     def models(self):
         class _ModelList: