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

webscout/Provider/TogetherAI.py

@@ -0,0 +1,350 @@
+from curl_cffi.requests import Session
+from curl_cffi import CurlError
+from typing import Any, Dict, Optional, Generator, Union
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIbase import Provider
+from webscout import exceptions
+from webscout.litagent import LitAgent
+
+class TogetherAI(Provider):
+    """
+    A class to interact with the TogetherAI API.
+    """
+
+    AVAILABLE_MODELS = [
+        "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
+        "Qwen/QwQ-32B",
+        "Qwen/Qwen2-72B-Instruct",
+        "Qwen/Qwen2-VL-72B-Instruct",
+        "Qwen/Qwen2.5-72B-Instruct-Turbo",
+        "Qwen/Qwen2.5-7B-Instruct-Turbo",
+        "Qwen/Qwen2.5-VL-72B-Instruct",
+        "Qwen/Qwen3-235B-A22B-fp8-tput",
+        "Salesforce/Llama-Rank-V1",
+        "arcee-ai/arcee-blitz",
+        "arcee-ai/caller",
+        "arcee-ai/coder-large",
+        "arcee-ai/maestro-reasoning",
+        "arcee-ai/virtuoso-large",
+        "arcee-ai/virtuoso-medium-v2",
+        "arcee_ai/arcee-spotlight",
+        "blackbox/meta-llama-3-1-8b",
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+        "deepseek-ai/DeepSeek-R1-Distill-Llama-70B-free",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+        "deepseek-ai/DeepSeek-V3",
+        "google/gemma-2-27b-it",
+        "lgai/exaone-3-5-32b-instruct",
+        "lgai/exaone-deep-32b",
+        "marin-community/marin-8b-instruct",
+        "meta-llama-llama-2-70b-hf",
+        "meta-llama/Llama-2-70b-hf",
+        "meta-llama/Llama-3-8b-chat-hf",
+        "meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
+        "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+        "meta-llama/Llama-3.2-90B-Vision-Instruct-Turbo",
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+        "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+        "meta-llama/Llama-Vision-Free",
+        "meta-llama/Meta-Llama-3-70B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3-8B-Instruct-Lite",
+        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        "mistralai/Mistral-7B-Instruct-v0.1",
+        "mistralai/Mistral-7B-Instruct-v0.2",
+        "mistralai/Mistral-7B-Instruct-v0.3",
+        "mistralai/Mistral-Small-24B-Instruct-2501",
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
+        "perplexity-ai/r1-1776",
+        "scb10x/scb10x-llama3-1-typhoon2-70b-instruct",
+        "scb10x/scb10x-typhoon-2-1-gemma3-12b",
+        "togethercomputer/Refuel-Llm-V2-Small",
+    ]
+
+    @staticmethod
+    def _togetherai_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
+        """Extracts content from TogetherAI stream JSON objects."""
+        if isinstance(chunk, dict):
+            return chunk.get("choices", [{}])[0].get("delta", {}).get("content")
+        return None
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2049,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "meta-llama/Llama-3.1-8B-Instruct-Turbo",
+        system_prompt: str = "You are a helpful assistant.",
+        browser: str = "chrome"
+    ):
+        """Initializes the TogetherAI API client."""
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+
+        self.api_endpoint = "https://api.together.xyz/v1/chat/completions"
+        self.activation_endpoint = "https://www.codegeneration.ai/activate-v2"
+
+        # Initialize LitAgent
+        self.agent = LitAgent()
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+
+        # Use the fingerprint for headers
+        self.headers = {
+            "Accept": self.fingerprint["accept"],
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Content-Type": "application/json",
+            "Cache-Control": "no-cache",
+            "Origin": "https://www.codegeneration.ai",
+            "Pragma": "no-cache",
+            "Referer": "https://www.codegeneration.ai/",
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-site",
+            "User-Agent": self.fingerprint["user_agent"],
+        }
+
+        # Initialize curl_cffi Session
+        self.session = Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+        self.system_prompt = system_prompt
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self._api_key_cache = None
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def refresh_identity(self, browser: str = None):
+        """
+        Refreshes the browser identity fingerprint.
+
+        Args:
+            browser: Specific browser to use for the new fingerprint
+        """
+        browser = browser or self.fingerprint.get("browser_type", "chrome")
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+
+        # Update headers with new fingerprint
+        self.headers.update({
+            "Accept": self.fingerprint["accept"],
+            "Accept-Language": self.fingerprint["accept_language"],
+            "User-Agent": self.fingerprint["user_agent"],
+        })
+
+        # Update session headers
+        self.session.headers.update(self.headers)
+
+        return self.fingerprint
+
+    def get_activation_key(self) -> str:
+        """Get API key from activation endpoint"""
+        if self._api_key_cache:
+            return self._api_key_cache
+
+        try:
+            response = self.session.get(
+                self.activation_endpoint,
+                headers={"Accept": "application/json"},
+                timeout=30
+            )
+            response.raise_for_status()
+            activation_data = response.json()
+            self._api_key_cache = activation_data["openAIParams"]["apiKey"]
+            return self._api_key_cache
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Failed to get activation key: {e}")
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        """
+        Sends a prompt to the TogetherAI API and returns the response.
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
+        if not self.headers.get("Authorization"):
+            api_key = self.get_activation_key()
+            self.headers["Authorization"] = f"Bearer {api_key}"
+            self.session.headers.update(self.headers)
+        payload = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": conversation_prompt},
+            ],
+            "stream": stream
+        }
+        def for_stream():
+            streaming_text = ""
+            try:
+                response = self.session.post(
+                    self.api_endpoint,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                    impersonate="chrome110"
+                )
+                response.raise_for_status()
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None),
+                    intro_value="data:",
+                    to_json=True,
+                    skip_markers=["[DONE]"],
+                    content_extractor=self._togetherai_extractor,
+                    yield_raw_on_error=False,
+                    raw=raw
+                )
+                for content_chunk in processed_stream:
+                    if isinstance(content_chunk, bytes):
+                        content_chunk = content_chunk.decode('utf-8', errors='ignore')
+                    if content_chunk is None:
+                        continue
+                    if raw:
+                        yield content_chunk
+                    else:
+                        if content_chunk and isinstance(content_chunk, str):
+                            streaming_text += content_chunk
+                            resp = dict(text=content_chunk)
+                            yield resp
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}") from e
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {str(e)}") from e
+            finally:
+                if streaming_text:
+                    self.last_response = {"text": streaming_text}
+                    self.conversation.update_chat_history(prompt, streaming_text)
+        def for_non_stream():
+            try:
+                response = self.session.post(
+                    self.api_endpoint,
+                    json=payload,
+                    timeout=self.timeout,
+                    impersonate="chrome110"
+                )
+                response.raise_for_status()
+                response_text = response.text
+                processed_stream = sanitize_stream(
+                    data=response_text,
+                    to_json=True,
+                    intro_value=None,
+                    content_extractor=lambda chunk: chunk.get("choices", [{}])[0].get("message", {}).get("content") if isinstance(chunk, dict) else None,
+                    yield_raw_on_error=False,
+                    raw=raw
+                )
+                content = next((c for c in processed_stream if c is not None), None)
+                content = content if isinstance(content, str) else ""
+                self.last_response = {"text": content}
+                self.conversation.update_chat_history(prompt, content)
+                return self.last_response if not raw else content
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
+            except Exception as e:
+                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+                raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {e} - {err_text}") from e
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        raw: bool = False,  # Added raw parameter
+    ) -> Union[str, Generator[str, None, None]]:
+        def for_stream_chat():
+            gen = self.ask(
+                prompt, stream=True, raw=raw,
+                optimizer=optimizer, conversationally=conversationally
+            )
+            for response in gen:
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
+        def for_non_stream_chat():
+            response_data = self.ask(
+                prompt, stream=False, raw=raw,
+                optimizer=optimizer, conversationally=conversationally
+            )
+            if raw:
+                return response_data
+            else:
+                return self.get_message(response_data)
+        return for_stream_chat() if stream else for_non_stream_chat()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response"""
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+
+if __name__ == "__main__":
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+
+    for model in TogetherAI.AVAILABLE_MODELS:
+        try:
+            test_ai = TogetherAI(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            for chunk in response:
+                response_text += chunk
+
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Clean and truncate response
+                clean_text = response_text.strip().encode('utf-8', errors='ignore').decode('utf-8')
+                display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/Venice.py

@@ -20,7 +20,6 @@ class Venice(Provider):
     AVAILABLE_MODELS = [
         "mistral-31-24b",
         "dolphin-3.0-mistral-24b",
-        "llama-3.2-3b-akash",
         "qwen2dot5-coder-32b",
         "deepseek-coder-v2-lite",
 
@@ -128,83 +127,69 @@ class Venice(Provider):
                 )
             else:
                 raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
-
-        # Update Payload construction based on successful request
         payload = {
-            "requestId": str(uuid4())[:7], # Keep generating request ID
+            "requestId": str(uuid4())[:7],
             "modelId": self.model,
             "prompt": [{"content": conversation_prompt, "role": "user"}],
-            "systemPrompt": self.system_prompt, # Use configured system prompt
+            "systemPrompt": self.system_prompt,
             "conversationType": "text",
-            "temperature": self.temperature, # Use configured temperature
-            "webEnabled": True, # Keep webEnabled
-            "topP": self.top_p, # Use configured topP
-            "includeVeniceSystemPrompt": True, # Set to True as per example
-            "isCharacter": False, # Keep as False
-            # Add missing fields from example payload
-            "userId": "user_anon_" + str(random.randint(1000000000, 9999999999)), # Generate anon user ID
-            "isDefault": True, 
+            "temperature": self.temperature,
+            "webEnabled": True,
+            "topP": self.top_p,
+            "includeVeniceSystemPrompt": True,
+            "isCharacter": False,
+            "userId": "user_anon_" + str(random.randint(1000000000, 9999999999)),
+            "isDefault": True,
             "textToSpeech": {"voiceId": "af_sky", "speed": 1},
-            "clientProcessingTime": random.randint(10, 50) # Randomize slightly
+            "clientProcessingTime": random.randint(10, 50)
         }
-
         def for_stream():
             try:
-                # Use curl_cffi session post
                 response = self.session.post(
                     self.api_endpoint, 
                     json=payload, 
                     stream=True, 
                     timeout=self.timeout,
-                    impersonate="edge101" # Match impersonation closer to headers
+                    impersonate="edge101"
                 ) 
-                # Check response status after the call
                 if response.status_code != 200:
-                    # Include response text in error
                     raise exceptions.FailedToGenerateResponseError(
                         f"Request failed with status code {response.status_code} - {response.text}"
                     )
-                    
                 streaming_text = ""
-                # Use sanitize_stream with the custom extractor
                 processed_stream = sanitize_stream(
-                    data=response.iter_content(chunk_size=None), # Pass byte iterator
-                    intro_value=None, # No simple prefix
-                    to_json=True,     # Each line is JSON
-                    content_extractor=self._venice_extractor, # Use the specific extractor
-                    yield_raw_on_error=False # Skip non-JSON lines or lines where extractor fails
+                    data=response.iter_content(chunk_size=None),
+                    intro_value=None,
+                    to_json=True,
+                    content_extractor=self._venice_extractor,
+                    yield_raw_on_error=False,
+                    raw=raw
                 )
-
                 for content_chunk in processed_stream:
-                    # content_chunk is the string extracted by _venice_extractor
-                    if content_chunk and isinstance(content_chunk, str):
-                        streaming_text += content_chunk
-                        yield content_chunk if raw else dict(text=content_chunk)
-                
-                # Update history and last response after stream finishes
+                    # Always yield as string, even in raw mode
+                    if isinstance(content_chunk, bytes):
+                        content_chunk = content_chunk.decode('utf-8', errors='ignore')
+                    if raw:
+                        yield content_chunk
+                    else:
+                        if content_chunk and isinstance(content_chunk, str):
+                            streaming_text += content_chunk
+                            yield dict(text=content_chunk)
                 self.conversation.update_chat_history(prompt, streaming_text)
                 self.last_response = {"text": streaming_text} 
-                    
             except CurlError as e: 
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
-            # Catch requests.exceptions.RequestException if needed, but CurlError is primary for curl_cffi
             except Exception as e: 
                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}")
-
         def for_non_stream():
             full_text = ""
-            # Iterate through the generator provided by for_stream
             for chunk_data in for_stream(): 
-                # Check if chunk_data is a dict (not raw) and has 'text'
                 if isinstance(chunk_data, dict) and "text" in chunk_data:
                     full_text += chunk_data["text"]
-                # If raw=True, chunk_data is the string content itself
                 elif isinstance(chunk_data, str): 
                      full_text += chunk_data
-            # Update last_response after aggregation
             self.last_response = {"text": full_text} 
             return self.last_response 
-
         return for_stream() if stream else for_non_stream()
 
     def chat(
@@ -213,14 +198,20 @@ class Venice(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        raw: bool = False,  # Added raw parameter
     ) -> Union[str, Generator]:
         def for_stream():
-            for response in self.ask(prompt, True, optimizer=optimizer, conversationally=conversationally):
-                yield self.get_message(response)
+            for response in self.ask(prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally):
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
         def for_non_stream():
-            return self.get_message(
-                self.ask(prompt, False, optimizer=optimizer, conversationally=conversationally)
-            )
+            result = self.ask(prompt, False, raw=raw, optimizer=optimizer, conversationally=conversationally)
+            if raw:
+                return result
+            else:
+                return self.get_message(result)
         return for_stream() if stream else for_non_stream()
 
     def get_message(self, response: dict) -> str:

webscout/Provider/VercelAI.py

@@ -141,7 +141,6 @@ class VercelAI(Provider):
                 raise Exception(
                     f"Optimizer is not one of {self.__available_optimizers}"
                 )
-
         payload = {
             "id": "guest",
             "messages": [
@@ -155,7 +154,6 @@ class VercelAI(Provider):
             ],
             "selectedChatModelId": self.model
         }
-
         def for_stream():
             response = self.session.post(
                 self.api_endpoint, headers=self.headers, json=payload, stream=True, timeout=self.timeout
@@ -163,31 +161,32 @@ class VercelAI(Provider):
             if not response.ok:
                 error_msg = f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 raise exceptions.FailedToGenerateResponseError(error_msg)
-
             streaming_text = ""
-            # Use sanitize_stream with the custom extractor
             processed_stream = sanitize_stream(
                 data=response.iter_content(chunk_size=None), # Pass byte iterator
                 intro_value=None, # No simple prefix
                 to_json=False,    # Content is not JSON
-                content_extractor=self._vercelai_extractor # Use the specific extractor
+                content_extractor=self._vercelai_extractor, # Use the specific extractor
+                raw=raw
             )
-
             for content_chunk in processed_stream:
-                if content_chunk and isinstance(content_chunk, str):
-                    streaming_text += content_chunk
-                    yield content_chunk if raw else dict(text=content_chunk)
-
+                # Always yield as string, even in raw mode
+                if isinstance(content_chunk, bytes):
+                    content_chunk = content_chunk.decode('utf-8', errors='ignore')
+                if raw:
+                    yield content_chunk
+                else:
+                    if content_chunk and isinstance(content_chunk, str):
+                        streaming_text += content_chunk
+                        yield dict(text=content_chunk)
             self.last_response.update(dict(text=streaming_text))
             self.conversation.update_chat_history(
                 prompt, self.get_message(self.last_response)
             )
-
         def for_non_stream():
             for _ in for_stream():
                 pass
             return self.last_response
-
         return for_stream() if stream else for_non_stream()
 
     def chat(
@@ -196,24 +195,28 @@ class VercelAI(Provider):
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        raw: bool = False,  # Added raw parameter
     ) -> str:
-        """Generate response `str`"""
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally
             ):
-                yield self.get_message(response)
-
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
         def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                )
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
             )
-
+            if raw:
+                return result
+            else:
+                return self.get_message(result)
         return for_stream() if stream else for_non_stream()
 
     def get_message(self, response: dict) -> str: