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

webscout/Provider/OPENAI/writecream.py

@@ -1,163 +1,166 @@
-import time
-import uuid
-import requests
-import json
-from typing import List, Dict, Optional, Union, Generator, Any
-
-# 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:
-    print("Warning: LitAgent not found. Using default user agent.")
-
-class Completions(BaseCompletions):
-    def __init__(self, client: 'Writecream'):
-        self._client = client
-
-    def create(
-        *,
-        self,
-        model: str = None,  # Not used by Writecream, for compatibility
-        messages: List[Dict[str, str]],
-        max_tokens: Optional[int] = None,  # Not used by Writecream
-        stream: bool = False,
-        temperature: Optional[float] = None,  # Not used by Writecream
-        top_p: Optional[float] = None,  # Not used by Writecream
-        **kwargs: Any
-    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
-        """
-        Creates a model response for the given chat conversation.
-        Mimics openai.chat.completions.create
-        """
-        payload = messages
-        request_id = f"chatcmpl-{uuid.uuid4()}"
-        created_time = int(time.time())
-        if stream:
-            return self._create_stream(request_id, created_time, payload)
-        else:
-            return self._create_non_stream(request_id, created_time, payload)
-
-    def _create_stream(
-        self, request_id: str, created_time: int, payload: List[Dict[str, str]]
-    ) -> Generator[ChatCompletionChunk, None, None]:
-        # Writecream does not support streaming, so yield the full response as a single chunk
-        completion = self._create_non_stream(request_id, created_time, payload)
-        content = completion.choices[0].message.content
-        # Yield as a single chunk
-        delta = ChoiceDelta(content=content)
-        choice = Choice(index=0, delta=delta, finish_reason=None)
-        chunk = ChatCompletionChunk(
-            id=request_id,
-            choices=[choice],
-            created=created_time,
-            model="writecream",
-        )
-        yield chunk
-        # Final chunk with finish_reason
-        delta = ChoiceDelta(content=None)
-        choice = Choice(index=0, delta=delta, finish_reason="stop")
-        chunk = ChatCompletionChunk(
-            id=request_id,
-            choices=[choice],
-            created=created_time,
-            model="writecream",
-        )
-        yield chunk
-
-    def _create_non_stream(
-        self, request_id: str, created_time: int, payload: List[Dict[str, str]]
-    ) -> ChatCompletion:
-        try:
-            params = {
-                "query": json.dumps(payload),
-                "link": "writecream.com"
-            }
-            response = self._client.session.get(
-                self._client.base_url,
-                params=params,
-                headers=self._client.headers,
-                timeout=self._client.timeout
-            )
-            response.raise_for_status()
-            data = response.json()
-            # Extract the response content according to the new API format
-            content = data.get("response_content", "")
-            # Estimate tokens
-            prompt_tokens = sum(len(m.get("content", "").split()) for m in payload)
-            completion_tokens = len(content.split())
-            usage = CompletionUsage(
-                prompt_tokens=prompt_tokens,
-                completion_tokens=completion_tokens,
-                total_tokens=prompt_tokens + completion_tokens
-            )
-            message = ChatCompletionMessage(role="assistant", content=content)
-            choice = Choice(index=0, message=message, finish_reason="stop")
-            completion = ChatCompletion(
-                id=request_id,
-                choices=[choice],
-                created=created_time,
-                model="writecream",
-                usage=usage
-            )
-            return completion
-        except Exception as e:
-            print(f"Error during Writecream request: {e}")
-            raise IOError(f"Writecream request failed: {e}") from e
-
-class Chat(BaseChat):
-    def __init__(self, client: 'Writecream'):
-        self.completions = Completions(client)
-
-class Writecream(OpenAICompatibleProvider):
-    """
-    OpenAI-compatible client for Writecream API.
-
-    Usage:
-        client = Writecream()
-        response = client.chat.completions.create(
-            messages=[{"role": "system", "content": "You are a helpful assistant."},
-                      {"role": "user", "content": "What is the capital of France?"}]
-        )
-        print(response.choices[0].message.content)
-    """
-    AVAILABLE_MODELS = ["writecream"]
-
-    def __init__(self, timeout: Optional[int] = 30, browser: str = "chrome"):
-        self.timeout = timeout
-        self.base_url = "https://8pe3nv3qha.execute-api.us-east-1.amazonaws.com/default/llm_chat"
-        self.session = requests.Session()
-        agent = LitAgent()
-        self.headers = {
-            "User-Agent": agent.random(),
-            "Referer": "https://www.writecream.com/chatgpt-chat/"
-        }
-        self.session.headers.update(self.headers)
-        self.chat = Chat(self)
-
-    def convert_model_name(self, model: str) -> str:
-        return "writecream"
-
-    @property
-    def models(self):
-        class _ModelList:
-            def list(inner_self):
-                return Writecream.AVAILABLE_MODELS
-        return _ModelList()
-
-# Simple test if run directly
-if __name__ == "__main__":
-    client = Writecream()
-    response = client.chat.completions.create(
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": "What is the capital of France?"}
-        ]
-    )
-    print(response.choices[0].message.content)
+import time
+import uuid
+import requests
+import json
+from typing import List, Dict, Optional, Union, Generator, Any
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage, count_tokens
+)
+
+# Attempt to import LitAgent, fallback if not available
+try:
+    from webscout.litagent import LitAgent
+except ImportError:
+    print("Warning: LitAgent not found. Using default user agent.")
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'Writecream'):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str = None,  # Not used by Writecream, for compatibility
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = None,  # Not used by Writecream
+        stream: bool = False,
+        temperature: Optional[float] = None,  # Not used by Writecream
+        top_p: Optional[float] = None,  # Not used by Writecream
+        timeout: Optional[int] = None,
+        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 = messages
+        request_id = f"chatcmpl-{uuid.uuid4()}"
+        created_time = int(time.time())
+        if stream:
+            return self._create_stream(request_id, created_time, payload, timeout, proxies)
+        else:
+            return self._create_non_stream(request_id, created_time, payload, timeout, proxies)
+
+    def _create_stream(
+        self, request_id: str, created_time: int, payload: List[Dict[str, str]], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        # Writecream does not support streaming, so yield the full response as a single chunk
+        completion = self._create_non_stream(request_id, created_time, payload, timeout, proxies)
+        content = completion.choices[0].message.content
+        # Yield as a single chunk
+        delta = ChoiceDelta(content=content)
+        choice = Choice(index=0, delta=delta, finish_reason=None)
+        chunk = ChatCompletionChunk(
+            id=request_id,
+            choices=[choice],
+            created=created_time,
+            model="writecream",
+        )
+        yield chunk
+        # Final chunk with finish_reason
+        delta = ChoiceDelta(content=None)
+        choice = Choice(index=0, delta=delta, finish_reason="stop")
+        chunk = ChatCompletionChunk(
+            id=request_id,
+            choices=[choice],
+            created=created_time,
+            model="writecream",
+        )
+        yield chunk
+
+    def _create_non_stream(
+        self, request_id: str, created_time: int, payload: List[Dict[str, str]], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
+    ) -> ChatCompletion:
+        try:
+            params = {
+                "query": json.dumps(payload),
+                "link": "writecream.com"
+            }
+            response = self._client.session.get(
+                self._client.base_url,
+                params=params,
+                headers=self._client.headers,
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
+            )
+            response.raise_for_status()
+            data = response.json()
+            # Extract the response content according to the new API format
+            content = data.get("response_content", "")
+            # Estimate tokens
+            prompt_tokens = sum(count_tokens(m.get("content", "")) for m in payload)
+            completion_tokens = count_tokens(content)
+            usage = CompletionUsage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=prompt_tokens + completion_tokens
+            )
+            message = ChatCompletionMessage(role="assistant", content=content)
+            choice = Choice(index=0, message=message, finish_reason="stop")
+            completion = ChatCompletion(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model="writecream",
+                usage=usage
+            )
+            return completion
+        except Exception as e:
+            print(f"Error during Writecream request: {e}")
+            raise IOError(f"Writecream request failed: {e}") from e
+
+class Chat(BaseChat):
+    def __init__(self, client: 'Writecream'):
+        self.completions = Completions(client)
+
+class Writecream(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible client for Writecream API.
+
+    Usage:
+        client = Writecream()
+        response = client.chat.completions.create(
+            messages=[{"role": "system", "content": "You are a helpful assistant."},
+                      {"role": "user", "content": "What is the capital of France?"}]
+        )
+        print(response.choices[0].message.content)
+    """
+    AVAILABLE_MODELS = ["writecream"]
+
+    def __init__(self, browser: str = "chrome"):
+        self.timeout = None
+        self.base_url = "https://8pe3nv3qha.execute-api.us-east-1.amazonaws.com/default/llm_chat"
+        self.session = requests.Session()
+        agent = LitAgent()
+        self.headers = {
+            "User-Agent": agent.random(),
+            "Referer": "https://www.writecream.com/chatgpt-chat/"
+        }
+        self.session.headers.update(self.headers)
+        self.chat = Chat(self)
+
+    def convert_model_name(self, model: str) -> str:
+        return "writecream"
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return Writecream.AVAILABLE_MODELS
+        return _ModelList()
+
+# Simple test if run directly
+if __name__ == "__main__":
+    client = Writecream()
+    response = client.chat.completions.create(
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "What is the capital of France?"}
+        ]
+    )
+    print(response.choices[0].message.content)

webscout/Provider/OPENAI/x0gpt.py

@@ -9,7 +9,7 @@ from typing import List, Dict, Optional, Union, Generator, Any
 from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
 from .utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage
+    ChatCompletionMessage, CompletionUsage, count_tokens
 )
 
 # Import LitAgent
@@ -30,6 +30,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -60,12 +62,12 @@ 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, 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, 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]:
         try:
             response = self._client.session.post(
@@ -73,7 +75,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Handle non-200 responses
@@ -82,15 +85,11 @@ class Completions(BaseCompletions):
                     f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 )
 
-            # Track token usage across chunks
-            prompt_tokens = 0
+            # Use count_tokens for prompt tokens
+            prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("messages", [])])
             completion_tokens = 0
             total_tokens = 0
 
-            # Estimate prompt tokens based on message length
-            for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
-
             for line in response.iter_lines():
                 if line:
                     decoded_line = line.decode('utf-8').strip()
@@ -103,8 +102,8 @@ class Completions(BaseCompletions):
                         # Format the content (replace escaped newlines)
                         content = self._client.format_text(content)
 
-                        # Update token counts
-                        completion_tokens += 1
+                        # Update token counts using count_tokens
+                        completion_tokens += count_tokens(content)
                         total_tokens = prompt_tokens + completion_tokens
 
                         # Create the delta object
@@ -131,20 +130,15 @@ class Completions(BaseCompletions):
                             system_fingerprint=None
                         )
 
-                        # Convert to dict for proper formatting
-                        chunk_dict = chunk.to_dict()
-
-                        # Add usage information to match OpenAI format
-                        usage_dict = {
+                        # Set usage directly on the chunk object
+                        chunk.usage = {
                             "prompt_tokens": prompt_tokens,
                             "completion_tokens": completion_tokens,
                             "total_tokens": total_tokens,
                             "estimated_cost": None
                         }
 
-                        chunk_dict["usage"] = usage_dict
-
-                        # Return the chunk object for internal processing
+                        # Return the chunk object with usage information
                         yield chunk
 
             # Final chunk with finish_reason="stop"
@@ -169,8 +163,8 @@ class Completions(BaseCompletions):
                 system_fingerprint=None
             )
 
-            chunk_dict = chunk.to_dict()
-            chunk_dict["usage"] = {
+            # Set usage directly on the chunk object
+            chunk.usage = {
                 "prompt_tokens": prompt_tokens,
                 "completion_tokens": completion_tokens,
                 "total_tokens": total_tokens,
@@ -184,16 +178,16 @@ class Completions(BaseCompletions):
             raise IOError(f"X0GPT request failed: {e}") from e
 
     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:
         try:
-            # For non-streaming, we still use streaming internally to collect the full response
             response = self._client.session.post(
                 self._client.api_endpoint,
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             # Handle non-200 responses
@@ -214,12 +208,9 @@ class Completions(BaseCompletions):
             # Format the text (replace escaped newlines)
             full_text = self._client.format_text(full_text)
 
-            # Estimate token counts
-            prompt_tokens = 0
-            for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
-
-            completion_tokens = len(full_text.split())
+            # Use count_tokens for accurate token counts
+            prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("messages", [])])
+            completion_tokens = count_tokens(full_text)
             total_tokens = prompt_tokens + completion_tokens
 
             # Create the message object
@@ -268,26 +259,24 @@ class X0GPT(OpenAICompatibleProvider):
     Usage:
         client = X0GPT()
         response = client.chat.completions.create(
-            model="gpt-4",
+            model="X0GPT",
             messages=[{"role": "user", "content": "Hello!"}]
         )
     """
 
-    AVAILABLE_MODELS = ["gpt-4", "gpt-3.5-turbo"]
+    AVAILABLE_MODELS = ["X0GPT"]
 
     def __init__(
         self,
-        timeout: Optional[int] = None,
         browser: str = "chrome"
     ):
         """
         Initialize the X0GPT client.
 
         Args:
-            timeout: Request timeout in seconds (None for no timeout)
             browser: Browser to emulate in user agent
         """
-        self.timeout = timeout
+        self.timeout = None
         self.api_endpoint = "https://x0-gpt.devwtf.in/api/stream/reply"
         self.session = requests.Session()