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

webscout/Provider/OPENAI/NEMOTRON.py

@@ -1,232 +0,0 @@
-import time
-import uuid
-import requests
-import json
-import random
-import datetime
-import re
-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, count_tokens
-)
-try:
-    from webscout.litagent import LitAgent
-except ImportError:
-    class LitAgent:
-        def random(self) -> str:
-            return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
-from webscout.AIutel import sanitize_stream
-from webscout import exceptions
-
-
-class Completions(BaseCompletions):
-    def __init__(self, client: 'NEMOTRON'):
-        self._client = client
-
-    def create(
-        self,
-        *,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: Optional[int] = None,
-        stream: bool = False,
-        temperature: Optional[float] = None,
-        top_p: Optional[float] = None,
-        **kwargs: Any
-    ) -> ChatCompletion:
-        nemotron_model_name = self._client.convert_model_name(model)
-        prompt_content = format_prompt(messages, add_special_tokens=True, include_system=True, do_continue=True)
-        payload = {
-            "content": prompt_content,
-            "imageSrc": "",
-            "model": nemotron_model_name,
-            "user": self._client._get_user_data(),
-            "conversationId": kwargs.get("conversation_id", "")
-        }
-        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)
-
-    def _create_stream(
-        self, request_id: str, created_time: int, model_name: str, payload: Dict[str, Any]
-    ) -> Generator[ChatCompletionChunk, None, None]:
-        try:
-            response_generator = self._client._internal_make_request(payload, stream=True)
-            for text_chunk in response_generator:
-                if text_chunk:
-                    delta = ChoiceDelta(content=text_chunk, role="assistant")
-                    choice = Choice(index=0, delta=delta, finish_reason=None)
-                    chunk = ChatCompletionChunk(
-                        id=request_id,
-                        choices=[choice],
-                        created=created_time,
-                        model=model_name,
-                    )
-                    yield chunk
-            final_delta = ChoiceDelta()
-            final_choice = Choice(index=0, delta=final_delta, finish_reason="stop")
-            final_chunk = ChatCompletionChunk(
-                id=request_id,
-                choices=[final_choice],
-                created=created_time,
-                model=model_name,
-            )
-            yield final_chunk
-        except Exception as e:
-            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]
-    ) -> ChatCompletion:
-        full_response_content = ""
-        try:
-            response_generator = self._client._internal_make_request(payload, stream=False)
-            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 = count_tokens(payload.get("content", ""))
-        completion_tokens = count_tokens(full_response_content)
-        usage = CompletionUsage(
-            prompt_tokens=prompt_tokens,
-            completion_tokens=completion_tokens,
-            total_tokens=prompt_tokens + completion_tokens
-        )
-        completion = ChatCompletion(
-            id=request_id,
-            choices=[choice],
-            created=created_time,
-            model=model_name,
-            usage=usage,
-        )
-        return completion
-
-class Chat(BaseChat):
-    def __init__(self, client: 'NEMOTRON'):
-        self.completions = Completions(client)
-
-class NEMOTRON(OpenAICompatibleProvider):
-    AVAILABLE_MODELS = [
-        "gpt4o",
-        "nemotron70b",
-    ]
-    
-    API_BASE_URL = "https://nemotron.one/api/chat"
-    def __init__(
-        self,
-        timeout: int = 30,
-        proxies: dict = {}
-    ):
-        self.session = requests.Session()
-        self.timeout = timeout
-        agent = LitAgent()
-        user_agent = agent.random()
-        self.base_headers = {
-            "authority": "nemotron.one",
-            "accept": "*/*",
-            "accept-language": "en-US,en;q=0.9",
-            "content-type": "application/json",
-            "origin": "https://nemotron.one",
-            "sec-ch-ua": '"Chromium";v="136", "Not.A/Brand";v="99"',
-            "sec-ch-ua-mobile": "?0",
-            "sec-ch-ua-platform": '"Windows"',
-            "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:
-        random_letter = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-        random_string = ''.join(random.choice(random_letter) for _ in range(10))
-        return f"{random_string}@gmail.com"
-
-    def _generate_random_id(self) -> str:
-        timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S%f")
-        random_letter = "abcdefghijklmnopqrstuvwxyz0123456789"
-        random_string = ''.join(random.choice(random_letter) for _ in range(8))
-        return f"cm{random_string}{timestamp[:10]}"
-
-    def _get_user_data(self) -> Dict[str, Any]:
-        current_time = datetime.datetime.now().isoformat()
-        return {
-            "name": "user",
-            "email": self._generate_random_email(),
-            "image": "https://lh3.googleusercontent.com/a/default-user=s96-c",
-            "id": self._generate_random_id(),
-            "password": None,
-            "emailVerified": None,
-            "credits": 100000000000,
-            "isPro": False,
-            "createdAt": current_time,
-            "updatedAt": current_time
-        }
-
-    def convert_model_name(self, model_alias: str) -> str:
-        """
-        Convert model names to ones supported by NEMOTRON API.
-        
-        Args:
-            model_alias: Model name to convert
-        
-        Returns:
-            NEMOTRON model name for API payload
-        """
-        # Accept only direct model names
-        if model_alias in self.AVAILABLE_MODELS:
-            return model_alias
-        
-        # Case-insensitive matching
-        for m in self.AVAILABLE_MODELS:
-            if m.lower() == model_alias.lower():
-                return m
-        
-        # Default to gpt4o if no match
-        print(f"Warning: Unknown model '{model_alias}'. Using 'gpt4o' instead.")
-        return "gpt4o"
-
-    def _internal_make_request(
-        self,
-        payload: Dict[str, Any],
-        stream: bool = False
-    ) -> Generator[str, None, None]:
-        request_headers = self.base_headers.copy()
-        request_headers["referer"] = f"https://nemotron.one/chat/{payload['model']}"
-        try:
-            if stream:
-                with self.session.post(
-                    self.API_BASE_URL,
-                    headers=request_headers,
-                    json=payload,
-                    stream=True,
-                    timeout=self.timeout
-                ) as response:
-                    response.raise_for_status()
-                    yield from sanitize_stream(
-                        response.iter_content(chunk_size=1024),
-                        to_json=False,
-                    )
-            else:
-                response = self.session.post(
-                    self.API_BASE_URL,
-                    headers=request_headers,
-                    json=payload,
-                    timeout=self.timeout
-                )
-                response.raise_for_status()
-                yield response.text
-        except requests.exceptions.RequestException as e:
-            raise exceptions.ProviderConnectionError(f"NEMOTRON API Connection error: {str(e)}")
-        except Exception as e:
-            raise RuntimeError(f"NEMOTRON API request unexpected error: {str(e)}")
-    @property
-    def models(self):
-        class _ModelList:
-            def list(inner_self):
-                return type(self).AVAILABLE_MODELS
-        return _ModelList()

webscout/Provider/OPENAI/Qwen3.py

@@ -1,283 +0,0 @@
-import requests
-import json
-import time
-import uuid
-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,
-    get_last_user_message, get_system_prompt,
-    count_tokens
-)
-
-class Completions(BaseCompletions):
-    def __init__(self, client: 'Qwen3'):
-        self._client = client
-
-    def create(
-        self,
-        *,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: Optional[int] = 2048,
-        stream: bool = False,
-        temperature: Optional[float] = None,
-        top_p: Optional[float] = None,
-        **kwargs: Any
-    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
-        payload = {
-            "data": [
-                get_last_user_message(messages),
-                {
-                    "thinking_budget": kwargs.get("thinking_budget", 38),
-                    "model": self._client.get_model(model),
-                    "sys_prompt": get_system_prompt(messages)
-                },
-                None, None
-            ],
-            "event_data": None,
-            "fn_index": 13,
-            "trigger_id": 31,
-            "session_hash": str(uuid.uuid4()).replace('-', '')
-        }
-
-        request_id = f"chatcmpl-{uuid.uuid4()}"
-        created_time = int(time.time())
-
-        if stream:
-            return self._create_stream(request_id, created_time, model, payload)
-        else:
-            return self._create_non_stream(request_id, created_time, model, payload)
-
-    def _create_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
-    ) -> Generator[ChatCompletionChunk, None, None]:
-        session = self._client.session
-        headers = self._client.headers
-        # Step 1: Join the queue
-        join_resp = session.post(self._client.api_endpoint, headers=headers, json=payload, timeout=self._client.timeout)
-        join_resp.raise_for_status()
-        event_id = join_resp.json().get('event_id')
-        session_hash = payload["session_hash"]
-
-        # Step 2: Stream data
-        params = {'session_hash': session_hash}
-        stream_resp = session.get(self._client.url + "/gradio_api/queue/data", headers=self._client.stream_headers, params=params, stream=True, timeout=self._client.timeout)
-        stream_resp.raise_for_status()
-
-        # --- New logic to yield all content, tool reasoning, and status, similar to Reasoning class ---
-        is_thinking_tag_open = False # True if <think> has been yielded and not yet </think>
-
-        for line in stream_resp.iter_lines():
-            if line:
-                decoded_line = line.decode('utf-8')
-                if decoded_line.startswith('data: '):
-                    try:
-                        json_data = json.loads(decoded_line[6:])
-                        if json_data.get('msg') == 'process_generating':
-                            if 'output' in json_data and 'data' in json_data['output'] and len(json_data['output']['data']) > 5:
-                                updates_list = json_data['output']['data'][5] # This is a list of operations
-                                for op_details in updates_list:
-                                    action = op_details[0]
-                                    path = op_details[1]
-                                    value = op_details[2]
-
-                                    content_to_yield = None
-                                    is_current_op_tool = False
-                                    is_current_op_text = False
-
-                                    # Case 1: Adding a new content block (tool or text object)
-                                    if action == "add" and isinstance(value, dict) and "type" in value:
-                                        if len(path) == 4 and path[0] == "value" and path[2] == "content":
-                                            block_type = value.get("type")
-                                            content_to_yield = value.get("content")
-                                            if block_type == "tool":
-                                                is_current_op_tool = True
-                                            elif block_type == "text":
-                                                is_current_op_text = True
-                                    
-                                    # Case 2: Appending content string to an existing block
-                                    elif action == "append" and isinstance(value, str):
-                                        if len(path) == 5 and path[0] == "value" and path[2] == "content" and path[4] == "content":
-                                            block_index = path[3] # 0 for tool's content, 1 for text's content
-                                            content_to_yield = value
-                                            if block_index == 0: # Appending to tool's content
-                                                is_current_op_tool = True
-                                            elif block_index == 1: # Appending to text's content
-                                                is_current_op_text = True
-                                    
-                                    # Case 3: Tool status update (e.g., "End of Thought")
-                                    elif action == "replace" and len(path) == 6 and \
-                                         path[0] == "value" and path[2] == "content" and \
-                                         path[3] == 0 and path[4] == "options" and path[5] == "status": # path[3]==0 ensures it's the tool block
-                                        if value == "done": # Tool block processing is complete
-                                            if is_thinking_tag_open:
-                                                delta = ChoiceDelta(content="</think>\n\n", role="assistant")
-                                                yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-                                                is_thinking_tag_open = False
-                                        continue # This operation itself doesn't yield visible content
-
-                                    # Yielding logic
-                                    if is_current_op_tool and content_to_yield:
-                                        if not is_thinking_tag_open:
-                                            delta = ChoiceDelta(content="<think>", role="assistant")
-                                            yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-                                            is_thinking_tag_open = True
-                                        
-                                        delta = ChoiceDelta(content=content_to_yield, role="assistant")
-                                        yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-
-                                    elif is_current_op_text and content_to_yield:
-                                        if is_thinking_tag_open: # If text starts, close any open thinking tag
-                                            delta = ChoiceDelta(content="</think>", role="assistant")
-                                            yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-                                            is_thinking_tag_open = False
-                                        
-                                        delta = ChoiceDelta(content=content_to_yield, role="assistant")
-                                        yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-
-                        if json_data.get('msg') == 'process_completed':
-                            if is_thinking_tag_open: # Ensure </think> is yielded if process completes mid-thought
-                                delta = ChoiceDelta(content="</think>", role="assistant")
-                                yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-                                is_thinking_tag_open = False
-                            break
-                    except json.JSONDecodeError:
-                        continue
-                    except Exception as e:
-                        # Log or handle other potential exceptions
-                        continue
-        
-        # After the loop, ensure the tag is closed if the stream broke for reasons other than 'process_completed'
-        if is_thinking_tag_open:
-            delta = ChoiceDelta(content="</think>", role="assistant")
-            yield ChatCompletionChunk(id=request_id, choices=[Choice(index=0, delta=delta)], created=created_time, model=model)
-
-    def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
-    ) -> ChatCompletion:
-        # For non-streaming, just call the join endpoint and parse the result
-        session = self._client.session
-        headers = self._client.headers
-        resp = session.post(self._client.api_endpoint, headers=headers, json=payload, timeout=self._client.timeout)
-        resp.raise_for_status()
-        data = resp.json()
-        # Return the full content as a single message, including all tool and text reasoning if present
-        output = ""
-        if 'output' in data and 'data' in data['output'] and len(data['output']['data']) > 5:
-            updates = data['output']['data'][5]
-            parts = []
-            for update in updates:
-                if isinstance(update, list) and len(update) > 2 and isinstance(update[2], str):
-                    parts.append(update[2])
-                elif isinstance(update, list) and isinstance(update[1], list) and len(update[1]) > 4:
-                    if update[1][4] == "content":
-                        parts.append(update[2])
-                    elif update[1][4] == "options" and update[2] != "done":
-                        parts.append(str(update[2]))
-                elif isinstance(update, dict):
-                    if update.get('type') == 'tool':
-                        parts.append(update.get('content', ''))
-                    elif update.get('type') == 'text':
-                        parts.append(update.get('content', ''))
-            output = "\n".join([str(p) for p in parts if p])
-        else:
-            output = data.get('output', {}).get('data', ["", "", "", "", "", [["", "", ""]]])[5][0][2]
-        message = ChatCompletionMessage(role="assistant", content=output)
-        choice = Choice(index=0, message=message, finish_reason="stop")
-        # Use count_tokens to compute usage
-        prompt_tokens = count_tokens([m.get('content', '') for m in payload['data'] if isinstance(m, dict) and 'content' in m or isinstance(m, str)])
-        completion_tokens = count_tokens(output)
-        usage = CompletionUsage(
-            prompt_tokens=prompt_tokens,
-            completion_tokens=completion_tokens,
-            total_tokens=prompt_tokens + completion_tokens
-        )
-        completion = ChatCompletion(
-            id=request_id,
-            choices=[choice],
-            created=created_time,
-            model=model,
-            usage=usage,
-        )
-        return completion
-
-class Chat(BaseChat):
-    def __init__(self, client: 'Qwen3'):
-        self.completions = Completions(client)
-
-class Qwen3(OpenAICompatibleProvider):
-    url = "https://qwen-qwen3-demo.hf.space"
-    api_endpoint = "https://qwen-qwen3-demo.hf.space/gradio_api/queue/join?__theme=system"
-    AVAILABLE_MODELS = [
-        "qwen3-235b-a22b",
-        "qwen3-32b",
-        "qwen3-30b-a3b",
-        "qwen3-14b",
-        "qwen3-8b",
-        "qwen3-4b",
-        "qwen3-1.7b",
-        "qwen3-0.6b",
-    ]
-    MODEL_ALIASES = {
-        "qwen-3-235b": "qwen3-235b-a22b",
-        "qwen-3-30b": "qwen3-30b-a3b",
-        "qwen-3-32b": "qwen3-32b",
-        "qwen-3-14b": "qwen3-14b",
-        "qwen-3-4b": "qwen3-4b",
-        "qwen-3-1.7b": "qwen3-1.7b",
-        "qwen-3-0.6b": "qwen3-0.6b"
-    }
-
-    def __init__(self, timeout: Optional[int] = None):
-        self.timeout = timeout
-        self.session = requests.Session()
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:136.0) Gecko/20100101 Firefox/136.0',
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Accept-Encoding': 'gzip, deflate, br, zstd',
-            'Referer': f'{self.url}/?__theme=system',
-            'content-type': 'application/json',
-            'Origin': self.url,
-            'Connection': 'keep-alive',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-            'Pragma': 'no-cache',
-            'Cache-Control': 'no-cache',
-        }
-        self.stream_headers = {
-            'Accept': 'text/event-stream',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Referer': f'{self.url}/?__theme=system',
-            'User-Agent': self.headers['User-Agent'],
-        }
-        self.session.headers.update(self.headers)
-        self.chat = Chat(self)
-
-    def get_model(self, model):
-        return self.MODEL_ALIASES.get(model, model)
-
-    @property
-    def models(self):
-        class _ModelList:
-            def list(inner_self):
-                return type(self).AVAILABLE_MODELS
-        return _ModelList()
-
-if __name__ == "__main__":
-    client = Qwen3()
-    from rich import print
-    resp = client.chat.completions.create(
-        model="qwen3-14b",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": "Hello "}
-        ],
-        stream=True
-    )
-    for chunk in resp:
-        print(chunk, end="", flush=True)