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

webscout/Provider/OPENAI/uncovrAI.py

@@ -38,6 +38,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]]:
         """
@@ -103,7 +105,9 @@ class Completions(BaseCompletions):
                 payload=payload,
                 model=model,
                 request_id=request_id,
-                created_time=created_time
+                created_time=created_time,
+                timeout=timeout,
+                proxies=proxies
             )
 
         # Handle non-streaming response
@@ -111,7 +115,9 @@ class Completions(BaseCompletions):
             payload=payload,
             model=model,
             request_id=request_id,
-            created_time=created_time
+            created_time=created_time,
+            timeout=timeout,
+            proxies=proxies
         )
 
     def _handle_streaming_response(
@@ -120,7 +126,9 @@ class Completions(BaseCompletions):
         payload: Dict[str, Any],
         model: str,
         request_id: str,
-        created_time: int
+        created_time: int,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         """Handle streaming response from UncovrAI API."""
         try:
@@ -128,7 +136,8 @@ class Completions(BaseCompletions):
                 self._client.url,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             ) as response:
                 if response.status_code != 200:
                     # If we get a non-200 response, try refreshing our identity once
@@ -139,7 +148,8 @@ class Completions(BaseCompletions):
                             self._client.url,
                             json=payload,
                             stream=True,
-                            timeout=self._client.timeout
+                            timeout=timeout or self._client.timeout,
+                            proxies=proxies or getattr(self._client, "proxies", None)
                         ) as retry_response:
                             if not retry_response.ok:
                                 raise IOError(
@@ -216,14 +226,17 @@ class Completions(BaseCompletions):
         payload: Dict[str, Any],
         model: str,
         request_id: str,
-        created_time: int
+        created_time: int,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         """Handle non-streaming response from UncovrAI API."""
         try:
             response = self._client.session.post(
                 self._client.url,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             if response.status_code != 200:
@@ -232,7 +245,8 @@ class Completions(BaseCompletions):
                     response = self._client.session.post(
                         self._client.url,
                         json=payload,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(

webscout/Provider/OPENAI/venice.py

@@ -32,6 +32,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = 0.8,
         top_p: Optional[float] = 0.9,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -73,19 +75,20 @@ 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(
                 self._client.api_endpoint,
                 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
@@ -211,7 +214,7 @@ class Completions(BaseCompletions):
             raise IOError(f"Venice 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
@@ -219,7 +222,8 @@ class Completions(BaseCompletions):
                 self._client.api_endpoint,
                 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

webscout/Provider/OPENAI/writecream.py

@@ -22,14 +22,16 @@ class Completions(BaseCompletions):
         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]]:
         """
@@ -40,15 +42,15 @@ class Completions(BaseCompletions):
         request_id = f"chatcmpl-{uuid.uuid4()}"
         created_time = int(time.time())
         if stream:
-            return self._create_stream(request_id, created_time, payload)
+            return self._create_stream(request_id, created_time, payload, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, payload)
+            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]]
+        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)
+        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)
@@ -72,7 +74,7 @@ class Completions(BaseCompletions):
         yield chunk
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, payload: List[Dict[str, str]]
+        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 = {
@@ -83,7 +85,8 @@ class Completions(BaseCompletions):
                 self._client.base_url,
                 params=params,
                 headers=self._client.headers,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             response.raise_for_status()
             data = response.json()
@@ -129,8 +132,8 @@ class Writecream(OpenAICompatibleProvider):
     """
     AVAILABLE_MODELS = ["writecream"]
 
-    def __init__(self, timeout: Optional[int] = 30, browser: str = "chrome"):
-        self.timeout = timeout
+    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()
@@ -160,4 +163,4 @@ if __name__ == "__main__":
             {"role": "user", "content": "What is the capital of France?"}
         ]
     )
-    print(response.choices[0].message.content)
+    print(response.choices[0].message.content)

webscout/Provider/OPENAI/x0gpt.py

@@ -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
@@ -175,7 +178,7 @@ 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:
             response = self._client.session.post(
@@ -183,7 +186,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
@@ -264,17 +268,15 @@ class X0GPT(OpenAICompatibleProvider):
 
     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()
 

webscout/Provider/OPENAI/yep.py

@@ -49,6 +49,8 @@ class Completions(BaseCompletions):
         temperature: Optional[float] = 0.6,
         top_p: Optional[float] = 0.7,
         system_prompt: Optional[str] = None,  # Added for consistency, but will be ignored
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -99,12 +101,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(
@@ -113,7 +115,8 @@ class Completions(BaseCompletions):
                 cookies=self._client.cookies,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
 
             if not response.ok:
@@ -191,7 +194,7 @@ class Completions(BaseCompletions):
             pass
 
     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:
         full_response_content = ""
         finish_reason = "stop"
@@ -204,7 +207,8 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 cookies=self._client.cookies,
                 json=payload_copy,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             if not response.ok:
                 raise IOError(
@@ -271,17 +275,15 @@ class YEPCHAT(OpenAICompatibleProvider):
 
     def __init__(
         self,
-        timeout: int = 30,
         browser: str = "chrome"
     ):
         """
         Initialize the YEPCHAT client.
 
         Args:
-            timeout: Request timeout in seconds.
             browser: Browser name for LitAgent to generate User-Agent.
         """
-        self.timeout = timeout
+        self.timeout = None
         self.api_endpoint = "https://api.yep.com/v1/chat/completions"
         self.session = cloudscraper.create_scraper()  # Use cloudscraper
 
@@ -379,4 +381,4 @@ if __name__ == '__main__':
         print()  # Add a newline at the end
 
     except Exception as e:
-        print(f"Streaming Test Failed: {e}")
+        print(f"Streaming Test Failed: {e}")

webscout/Provider/PI.py

@@ -158,7 +158,8 @@ class PiAI(Provider):
         except CurlError as e: # Catch CurlError
             raise exceptions.FailedToGenerateResponseError(f"Failed to start conversation (CurlError): {e}") from e
         except Exception as e: # Catch other potential exceptions (like HTTPError, JSONDecodeError)
-            err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+            # Extract error text from the response if available
+            err_text = e.response.text if hasattr(e, 'response') and hasattr(e.response, 'text') else ''
             raise exceptions.FailedToGenerateResponseError(f"Failed to start conversation ({type(e).__name__}): {e} - {err_text}") from e
 
     def ask(

webscout/Provider/STT/__init__.py

@@ -0,0 +1,3 @@
+# This file marks the directory as a Python package.
+from .base import *
+from .elevenlabs import *

webscout/Provider/STT/base.py

@@ -0,0 +1,281 @@
+"""
+Base classes for OpenAI-compatible STT providers.
+
+This module provides the base structure for STT providers that follow
+the OpenAI Whisper API interface pattern.
+"""
+
+import json
+import time
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Generator, List, Optional, Union, BinaryIO
+from pathlib import Path
+
+# Import OpenAI response types from the main OPENAI module
+try:
+    from webscout.Provider.OPENAI.pydantic_imports import (
+        ChatCompletion, ChatCompletionChunk, Choice, ChoiceDelta,
+        Message, Usage, count_tokens
+    )
+except ImportError:
+    # Fallback if pydantic_imports is not available
+    from dataclasses import dataclass
+    
+    @dataclass
+    class Usage:
+        prompt_tokens: int = 0
+        completion_tokens: int = 0
+        total_tokens: int = 0
+    
+    @dataclass
+    class Message:
+        role: str
+        content: str
+    
+    @dataclass
+    class Choice:
+        index: int
+        message: Message
+        finish_reason: Optional[str] = None
+    
+    @dataclass
+    class ChoiceDelta:
+        content: Optional[str] = None
+        role: Optional[str] = None
+    
+    @dataclass
+    class ChatCompletionChunk:
+        id: str
+        choices: List[Dict[str, Any]]
+        created: int
+        model: str
+        object: str = "chat.completion.chunk"
+    
+    @dataclass
+    class ChatCompletion:
+        id: str
+        choices: List[Choice]
+        created: int
+        model: str
+        usage: Usage
+        object: str = "chat.completion"
+    
+    def count_tokens(text: str) -> int:
+        return len(text.split())
+
+
+class TranscriptionResponse:
+    """Response object that mimics OpenAI's transcription response."""
+    
+    def __init__(self, data: Dict[str, Any], response_format: str = "json"):
+        self._data = data
+        self._response_format = response_format
+        
+    @property
+    def text(self) -> str:
+        """Get the transcribed text."""
+        return self._data.get("text", "")
+    
+    @property
+    def language(self) -> Optional[str]:
+        """Get the detected language."""
+        return self._data.get("language")
+    
+    @property
+    def duration(self) -> Optional[float]:
+        """Get the audio duration."""
+        return self._data.get("duration")
+    
+    @property
+    def segments(self) -> Optional[list]:
+        """Get the segments with timestamps."""
+        return self._data.get("segments")
+    
+    @property
+    def words(self) -> Optional[list]:
+        """Get the words with timestamps."""
+        return self._data.get("words")
+    
+    def __str__(self) -> str:
+        """Return string representation based on response format."""
+        if self._response_format == "text":
+            return self.text
+        elif self._response_format == "srt":
+            return self._to_srt()
+        elif self._response_format == "vtt":
+            return self._to_vtt()
+        else:  # json or verbose_json
+            return json.dumps(self._data, indent=2)
+    
+    def _to_srt(self) -> str:
+        """Convert to SRT subtitle format."""
+        if not self.segments:
+            return ""
+        
+        srt_content = []
+        for i, segment in enumerate(self.segments, 1):
+            start_time = self._format_time_srt(segment.get("start", 0))
+            end_time = self._format_time_srt(segment.get("end", 0))
+            text = segment.get("text", "").strip()
+            
+            srt_content.append(f"{i}")
+            srt_content.append(f"{start_time} --> {end_time}")
+            srt_content.append(text)
+            srt_content.append("")
+        
+        return "\n".join(srt_content)
+    
+    def _to_vtt(self) -> str:
+        """Convert to VTT subtitle format."""
+        if not self.segments:
+            return "WEBVTT\n\n"
+        
+        vtt_content = ["WEBVTT", ""]
+        for segment in self.segments:
+            start_time = self._format_time_vtt(segment.get("start", 0))
+            end_time = self._format_time_vtt(segment.get("end", 0))
+            text = segment.get("text", "").strip()
+            
+            vtt_content.append(f"{start_time} --> {end_time}")
+            vtt_content.append(text)
+            vtt_content.append("")
+        
+        return "\n".join(vtt_content)
+    
+    def _format_time_srt(self, seconds: float) -> str:
+        """Format time for SRT format (HH:MM:SS,mmm)."""
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        secs = int(seconds % 60)
+        millisecs = int((seconds % 1) * 1000)
+        return f"{hours:02d}:{minutes:02d}:{secs:02d},{millisecs:03d}"
+    
+    def _format_time_vtt(self, seconds: float) -> str:
+        """Format time for VTT format (HH:MM:SS.mmm)."""
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        secs = int(seconds % 60)
+        millisecs = int((seconds % 1) * 1000)
+        return f"{hours:02d}:{minutes:02d}:{secs:02d}.{millisecs:03d}"
+
+
+class BaseSTTTranscriptions(ABC):
+    """Base class for STT transcriptions interface."""
+    
+    def __init__(self, client):
+        self._client = client
+    
+    @abstractmethod
+    def create(
+        self,
+        *,
+        model: str,
+        file: Union[BinaryIO, str, Path],
+        language: Optional[str] = None,
+        prompt: Optional[str] = None,
+        response_format: str = "json",
+        temperature: Optional[float] = None,
+        timestamp_granularities: Optional[List[str]] = None,
+        stream: bool = False,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
+        **kwargs: Any
+    ) -> Union[TranscriptionResponse, Generator[str, None, None]]:
+        """
+        Create a transcription of the given audio file.
+        
+        Args:
+            model: Model to use for transcription
+            file: Audio file to transcribe
+            language: Language of the audio (ISO-639-1 format)
+            prompt: Optional text to guide the model's style
+            response_format: Format of the response
+            temperature: Sampling temperature (0 to 1)
+            timestamp_granularities: Timestamp granularities to include
+            stream: Whether to stream the response
+            timeout: Request timeout
+            proxies: Proxy configuration
+            **kwargs: Additional parameters
+            
+        Returns:
+            TranscriptionResponse or generator of SSE strings if streaming
+        """
+        raise NotImplementedError
+
+
+class BaseSTTAudio(ABC):
+    """Base class for STT audio interface."""
+    
+    def __init__(self, client):
+        self.transcriptions = self._create_transcriptions(client)
+    
+    @abstractmethod
+    def _create_transcriptions(self, client) -> BaseSTTTranscriptions:
+        """Create the transcriptions interface."""
+        raise NotImplementedError
+
+
+class BaseSTTChat:
+    """Base chat interface for STT providers (placeholder for consistency)."""
+
+    def __init__(self, client):
+        _ = client  # Unused but kept for interface consistency
+        self.completions = None  # STT providers don't have completions
+
+
+class STTCompatibleProvider(ABC):
+    """
+    Abstract Base Class for STT providers mimicking the OpenAI structure.
+    Requires a nested 'audio.transcriptions' structure.
+    """
+    
+    audio: BaseSTTAudio
+    
+    @abstractmethod
+    def __init__(self, **kwargs: Any):
+        """Initialize the STT provider."""
+        pass
+    
+    @property
+    @abstractmethod
+    def models(self):
+        """
+        Property that returns an object with a .list() method returning available models.
+        """
+        pass
+
+
+class STTModels:
+    """Models interface for STT providers."""
+    
+    def __init__(self, available_models: List[str]):
+        self._available_models = available_models
+    
+    def list(self) -> List[Dict[str, Any]]:
+        """List available models."""
+        return [
+            {
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "webscout"
+            }
+            for model in self._available_models
+        ]
+
+
+__all__ = [
+    'TranscriptionResponse',
+    'BaseSTTTranscriptions', 
+    'BaseSTTAudio',
+    'BaseSTTChat',
+    'STTCompatibleProvider',
+    'STTModels',
+    'ChatCompletion',
+    'ChatCompletionChunk',
+    'Choice',
+    'ChoiceDelta',
+    'Message',
+    'Usage',
+    'count_tokens'
+]