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

webscout/Provider/OPENAI/base.py

@@ -8,12 +8,11 @@ from webscout.Litlogger import Logger, LogLevel
 
 logger = Logger(name="OpenAIBase", level=LogLevel.INFO)
 
-# Import the ProxyAutoMeta metaclass
+# Import the LitMeta metaclass from Litproxy
 try:
-    from .autoproxy import ProxyAutoMeta
+    from litproxy import LitMeta 
 except ImportError:
-    # Fallback if autoproxy is not available
-    ProxyAutoMeta = type
+    from .autoproxy import ProxyAutoMeta as LitMeta
 
 
 # Import the utils for response structures
@@ -183,81 +182,11 @@ 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 OpenAICompatibleProvider(ABC, metaclass=ProxyAutoMeta):
+class OpenAICompatibleProvider(ABC, metaclass=LitMeta):
     """
     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.
+    All subclasses automatically get proxy support via LitMeta.
 
     # Available proxy helpers:
     # - self.get_proxied_session() - returns a requests.Session with proxies
@@ -269,6 +198,8 @@ class OpenAICompatibleProvider(ABC, metaclass=ProxyAutoMeta):
     # - httpx.Client objects
     # - curl_cffi.requests.Session objects
     # - curl_cffi.requests.AsyncSession objects
+    #
+    # Inbuilt auto-retry is also enabled for all requests.Session and curl_cffi.Session objects.
     """
     chat: BaseChat
     available_tools: Dict[str, Tool] = {}  # Dictionary of available tools

webscout/Provider/OPENAI/deepinfra.py

@@ -2,23 +2,20 @@ import requests
 import json
 import time
 import uuid
+import collections
 from typing import List, Dict, Optional, Union, Generator, Any
 
-# 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
 )
 
-# Attempt to import LitAgent, fallback if not available
 try:
     from webscout.litagent import LitAgent
 except ImportError:
     pass
 
-# --- DeepInfra Client ---
-
 class Completions(BaseCompletions):
     def __init__(self, client: 'DeepInfra'):
         self._client = client
@@ -36,10 +33,6 @@ class Completions(BaseCompletions):
         proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
-        """
-        Creates a model response for the given chat conversation.
-        Mimics openai.chat.completions.create
-        """
         payload = {
             "model": model,
             "messages": messages,
@@ -50,12 +43,9 @@ class Completions(BaseCompletions):
             payload["temperature"] = temperature
         if top_p is not None:
             payload["top_p"] = top_p
-
         payload.update(kwargs)
-
         request_id = f"chatcmpl-{uuid.uuid4()}"
         created_time = int(time.time())
-
         if stream:
             return self._create_stream(request_id, created_time, model, payload, timeout, proxies)
         else:
@@ -75,52 +65,39 @@ class Completions(BaseCompletions):
                 proxies=proxies
             )
             response.raise_for_status()
-
-            # Track token usage across chunks
             prompt_tokens = 0
             completion_tokens = 0
             total_tokens = 0
-
-            for line in response.iter_lines():
+            for line in response.iter_lines(decode_unicode=True):
                 if line:
-                    decoded_line = line.decode('utf-8').strip()
-
-                    if decoded_line.startswith("data: "):
-                        json_str = decoded_line[6:]
+                    if line.startswith("data: "):
+                        json_str = line[6:]
                         if json_str == "[DONE]":
-                            # Format the final [DONE] marker in OpenAI format
-                            # print("data: [DONE]")
                             break
-
                         try:
                             data = json.loads(json_str)
                             choice_data = data.get('choices', [{}])[0]
                             delta_data = choice_data.get('delta', {})
                             finish_reason = choice_data.get('finish_reason')
-
-                            # Update token counts if available
                             usage_data = data.get('usage', {})
                             if usage_data:
                                 prompt_tokens = usage_data.get('prompt_tokens', prompt_tokens)
                                 completion_tokens = usage_data.get('completion_tokens', completion_tokens)
                                 total_tokens = usage_data.get('total_tokens', total_tokens)
-
-                            # Create the delta object
+                            if delta_data.get('content'):
+                                completion_tokens += 1
+                                total_tokens = prompt_tokens + completion_tokens
                             delta = ChoiceDelta(
                                 content=delta_data.get('content'),
                                 role=delta_data.get('role'),
                                 tool_calls=delta_data.get('tool_calls')
                             )
-
-                            # Create the choice object
                             choice = Choice(
                                 index=choice_data.get('index', 0),
                                 delta=delta,
                                 finish_reason=finish_reason,
                                 logprobs=choice_data.get('logprobs')
                             )
-
-                            # Create the chunk object
                             chunk = ChatCompletionChunk(
                                 id=request_id,
                                 choices=[choice],
@@ -128,48 +105,35 @@ class Completions(BaseCompletions):
                                 model=model,
                                 system_fingerprint=data.get('system_fingerprint')
                             )
-
-                            # Convert chunk to dict using Pydantic's API
-                            if hasattr(chunk, "model_dump"):
-                                chunk_dict = chunk.model_dump(exclude_none=True)
-                            else:
-                                chunk_dict = chunk.dict(exclude_none=True)
-
-                            # Add usage information to match OpenAI format
-                            # Even if we don't have real token counts, include estimated usage
-                            # This matches the format in the examples
-                            usage_dict = {
-                                "prompt_tokens": prompt_tokens or 10,
-                                "completion_tokens": completion_tokens or (len(delta_data.get('content', '')) if delta_data.get('content') else 0),
-                                "total_tokens": total_tokens or (10 + (len(delta_data.get('content', '')) if delta_data.get('content') else 0)),
+                            chunk.usage = {
+                                "prompt_tokens": prompt_tokens,
+                                "completion_tokens": completion_tokens,
+                                "total_tokens": total_tokens,
                                 "estimated_cost": None
                             }
-
-                            # Update completion_tokens and total_tokens as we receive more content
-                            if delta_data.get('content'):
-                                completion_tokens += 1
-                                total_tokens = prompt_tokens + completion_tokens
-                                usage_dict["completion_tokens"] = completion_tokens
-                                usage_dict["total_tokens"] = total_tokens
-
-                            chunk_dict["usage"] = usage_dict
-
-                            # Format the response in OpenAI format exactly as requested
-                            # We need to print the raw string and also yield the chunk object
-                            # This ensures both the console output and the returned object are correct
-                            # print(f"data: {json.dumps(chunk_dict)}")
-
-                            # Return the chunk object for internal processing
                             yield chunk
                         except json.JSONDecodeError:
-                            print(f"Warning: Could not decode JSON line: {json_str}")
                             continue
-        except requests.exceptions.RequestException as e:
+            # Final chunk with finish_reason="stop"
+            delta = ChoiceDelta(content=None, role=None, tool_calls=None)
+            choice = Choice(index=0, delta=delta, finish_reason="stop", logprobs=None)
+            chunk = ChatCompletionChunk(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                system_fingerprint=None
+            )
+            chunk.usage = {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+                "estimated_cost": None
+            }
+            yield chunk
+        except Exception as e:
             print(f"Error during DeepInfra stream request: {e}")
             raise IOError(f"DeepInfra request failed: {e}") from e
-        except Exception as e:
-            print(f"Error processing DeepInfra stream: {e}")
-            raise
 
     def _create_non_stream(
         self, request_id: str, created_time: int, model: str, payload: Dict[str, Any],
@@ -185,13 +149,19 @@ class Completions(BaseCompletions):
             )
             response.raise_for_status()
             data = response.json()
-
             choices_data = data.get('choices', [])
             usage_data = data.get('usage', {})
-
             choices = []
             for choice_d in choices_data:
-                message_d = choice_d.get('message', {})
+                message_d = choice_d.get('message')
+                if not message_d and 'delta' in choice_d:
+                    delta = choice_d['delta']
+                    message_d = {
+                        'role': delta.get('role', 'assistant'),
+                        'content': delta.get('content', '')
+                    }
+                if not message_d:
+                    message_d = {'role': 'assistant', 'content': ''}
                 message = ChatCompletionMessage(
                     role=message_d.get('role', 'assistant'),
                     content=message_d.get('content', '')
@@ -202,13 +172,11 @@ class Completions(BaseCompletions):
                     finish_reason=choice_d.get('finish_reason', 'stop')
                 )
                 choices.append(choice)
-
             usage = CompletionUsage(
                 prompt_tokens=usage_data.get('prompt_tokens', 0),
                 completion_tokens=usage_data.get('completion_tokens', 0),
                 total_tokens=usage_data.get('total_tokens', 0)
             )
-
             completion = ChatCompletion(
                 id=request_id,
                 choices=choices,
@@ -217,22 +185,16 @@ class Completions(BaseCompletions):
                 usage=usage,
             )
             return completion
-
-        except requests.exceptions.RequestException as e:
+        except Exception as e:
             print(f"Error during DeepInfra non-stream request: {e}")
             raise IOError(f"DeepInfra request failed: {e}") from e
-        except Exception as e:
-            print(f"Error processing DeepInfra response: {e}")
-            raise
 
 class Chat(BaseChat):
     def __init__(self, client: 'DeepInfra'):
         self.completions = Completions(client)
 
 class DeepInfra(OpenAICompatibleProvider):
-    
     AVAILABLE_MODELS = [
-        # "anthropic/claude-3-7-sonnet-latest",  # >>>> NOT WORKING
         "deepseek-ai/DeepSeek-R1-0528",
         "deepseek-ai/DeepSeek-R1",
         "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
@@ -265,39 +227,13 @@ class DeepInfra(OpenAICompatibleProvider):
         "Qwen/Qwen3-30B-A3B",
         "Qwen/Qwen3-32B",
         "Qwen/Qwen3-235B-A22B",
-        # "google/gemini-1.5-flash",  # >>>> NOT WORKING
-        # "google/gemini-1.5-flash-8b",  # >>>> NOT WORKING
-        # "google/gemini-2.0-flash-001",  # >>>> NOT WORKING
-
-        # "Gryphe/MythoMax-L2-13b",  # >>>> NOT WORKING
-
-        # "meta-llama/Llama-3.2-1B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Llama-3.2-3B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Llama-3.2-90B-Vision-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Llama-3.2-11B-Vision-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3-70B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3-8B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3.1-70B-Instruct",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",  # >>>> NOT WORKING
-        # "meta-llama/Meta-Llama-3.1-405B-Instruct",  # >>>> NOT WORKING
-        # "mistralai/Mixtral-8x7B-Instruct-v0.1",  # >>>> NOT WORKING
-        # "mistralai/Mistral-7B-Instruct-v0.3",  # >>>> NOT WORKING
-        # "mistralai/Mistral-Nemo-Instruct-2407",  # >>>> NOT WORKING
-        # "NousResearch/Hermes-3-Llama-3.1-405B",  # >>>> NOT WORKING
-        # "NovaSky-AI/Sky-T1-32B-Preview",  # >>>> NOT WORKING
-        # "Qwen/Qwen2.5-7B-Instruct",  # >>>> NOT WORKING
-        # "Sao10K/L3.1-70B-Euryale-v2.2",  # >>>> NOT WORKING
-        # "Sao10K/L3.3-70B-Euryale-v2.3",  # >>>> NOT WORKING
     ]
-
     def __init__(self, browser: str = "chrome"):
-        self.timeout = None # Default timeout
+        self.timeout = None
         self.base_url = "https://api.deepinfra.com/v1/openai/chat/completions"
         self.session = requests.Session()
-
         agent = LitAgent()
         fingerprint = agent.generate_fingerprint(browser)
-
         self.headers = {
             "Accept": fingerprint["accept"],
             "Accept-Encoding": "gzip, deflate, br, zstd",
@@ -319,21 +255,19 @@ class DeepInfra(OpenAICompatibleProvider):
         }
         self.session.headers.update(self.headers)
         self.chat = Chat(self)
-
     @property
     def models(self):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
-    
+
 if __name__ == "__main__":
-    # Example usage
     client = DeepInfra()
     response = client.chat.completions.create(
         model="deepseek-ai/DeepSeek-R1-0528",
         messages=[{"role": "user", "content": "Hello, how are you?"}],
-        max_tokens=100,
+        max_tokens=10000,
         stream=False
     )
     print(response)