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

webscout/Provider/OPENAI/GeminiProxy.py

@@ -0,0 +1,328 @@
+import json
+import time
+import uuid
+import base64
+from typing import List, Dict, Optional, Union, Generator, Any
+
+import requests
+from uuid import uuid4
+
+# Import base classes and utility structures
+from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from .utils import (
+    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
+    ChatCompletionMessage, CompletionUsage, count_tokens
+)
+
+from webscout.litagent import LitAgent
+from webscout import exceptions
+
+
+class Completions(BaseCompletions):
+    def __init__(self, client: 'GeminiProxy'):
+        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,
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None,
+        **kwargs: Any
+    ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
+        """
+        Create a chat completion with GeminiProxy API.
+        
+        Args:
+            model: The model to use (from AVAILABLE_MODELS)
+            messages: List of message dictionaries with 'role' and 'content'
+            max_tokens: Maximum number of tokens to generate
+            stream: Whether to stream the response (not supported by GeminiProxy)
+            temperature: Sampling temperature (0-1)
+            top_p: Nucleus sampling parameter (0-1)
+            timeout: Request timeout in seconds
+            proxies: Proxy configuration
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            If stream=False, returns a ChatCompletion object
+            If stream=True, returns a Generator yielding ChatCompletionChunk objects
+        """
+        # Generate request ID and timestamp
+        request_id = str(uuid.uuid4())
+        created_time = int(time.time())
+        
+        # Extract image URL from kwargs if present
+        img_url = kwargs.get('img_url')
+        
+        # Convert messages to GeminiProxy format
+        conversation_prompt = self._format_messages(messages)
+        
+        # Prepare parts for the request
+        parts = []
+        if img_url:
+            parts.append({"inline_data": self._get_image(img_url, proxies, timeout)})
+        parts.append({"text": conversation_prompt})
+        
+        # Prepare the payload
+        payload = {
+            "model": model,
+            "contents": [{"parts": parts}]
+        }
+        
+        # GeminiProxy doesn't support streaming, so we always return non-streaming
+        if stream:
+            return self._create_streaming_fallback(
+                request_id=request_id,
+                created_time=created_time,
+                model=model,
+                payload=payload,
+                timeout=timeout,
+                proxies=proxies
+            )
+        
+        # Non-streaming implementation
+        return self._create_non_streaming(
+            request_id=request_id,
+            created_time=created_time,
+            model=model,
+            payload=payload,
+            timeout=timeout,
+            proxies=proxies
+        )
+    
+    def _format_messages(self, messages: List[Dict[str, str]]) -> str:
+        """Convert OpenAI messages format to a single conversation prompt."""
+        formatted_parts = []
+        
+        for message in messages:
+            role = message.get("role", "")
+            content = message.get("content", "")
+            
+            if role == "system":
+                formatted_parts.append(f"System: {content}")
+            elif role == "user":
+                formatted_parts.append(f"User: {content}")
+            elif role == "assistant":
+                formatted_parts.append(f"Assistant: {content}")
+        
+        return "\n".join(formatted_parts)
+    
+    def _get_image(self, img_url: str, proxies: Optional[dict] = None, timeout: Optional[int] = None) -> Dict[str, str]:
+        """Fetch and encode image from URL."""
+        try:
+            session = requests.Session()
+            if proxies:
+                session.proxies.update(proxies)
+            
+            response = session.get(
+                img_url, 
+                stream=True, 
+                timeout=timeout or self._client.timeout
+            )
+            response.raise_for_status()
+            
+            mime_type = response.headers.get("content-type", "application/octet-stream")
+            data = base64.b64encode(response.content).decode("utf-8")
+            return {"mime_type": mime_type, "data": data}
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Error fetching image: {e}")
+    
+    def _create_non_streaming(
+        self,
+        *,
+        request_id: str,
+        created_time: int,
+        model: str,
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None
+    ) -> ChatCompletion:
+        """Implementation for non-streaming chat completions."""
+        original_proxies = self._client.session.proxies.copy()
+        if proxies is not None:
+            self._client.session.proxies.update(proxies)
+        
+        try:
+            response = self._client.session.post(
+                self._client.base_url,
+                json=payload,
+                headers=self._client.headers,
+                timeout=timeout if timeout is not None else self._client.timeout
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            # Extract content from GeminiProxy response
+            content = self._extract_content(data)
+            
+            # Create the completion message
+            message = ChatCompletionMessage(
+                role="assistant",
+                content=content
+            )
+            
+            # Create the choice
+            choice = Choice(
+                index=0,
+                message=message,
+                finish_reason="stop"
+            )
+            
+            # Estimate token usage
+            prompt_tokens = count_tokens([msg.get("content", "") for msg in payload.get("contents", [{}])[0].get("parts", [{}])])
+            completion_tokens = count_tokens(content)
+            usage = CompletionUsage(
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                total_tokens=prompt_tokens + completion_tokens
+            )
+            
+            # Create the completion object
+            completion = ChatCompletion(
+                id=request_id,
+                choices=[choice],
+                created=created_time,
+                model=model,
+                usage=usage,
+            )
+            
+            return completion
+            
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"GeminiProxy request failed: {e}")
+        finally:
+            if proxies is not None:
+                self._client.session.proxies = original_proxies
+    
+    def _create_streaming_fallback(
+        self,
+        *,
+        request_id: str,
+        created_time: int,
+        model: str,
+        payload: Dict[str, Any],
+        timeout: Optional[int] = None,
+        proxies: Optional[dict] = None
+    ) -> Generator[ChatCompletionChunk, None, None]:
+        """Fallback streaming implementation that simulates streaming from non-streaming response."""
+        # Get the full response first
+        completion = self._create_non_streaming(
+            request_id=request_id,
+            created_time=created_time,
+            model=model,
+            payload=payload,
+            timeout=timeout,
+            proxies=proxies
+        )
+        
+        # Simulate streaming by yielding chunks
+        content = completion.choices[0].message.content
+        if content:
+            # Split content into chunks (simulate streaming)
+            chunk_size = max(1, len(content) // 10)  # Split into ~10 chunks
+            for i in range(0, len(content), chunk_size):
+                chunk_content = content[i:i + chunk_size]
+                
+                delta = ChoiceDelta(content=chunk_content)
+                choice = Choice(index=0, delta=delta, finish_reason=None)
+                
+                chunk = ChatCompletionChunk(
+                    id=request_id,
+                    choices=[choice],
+                    created=created_time,
+                    model=model
+                )
+                
+                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=model
+        )
+        
+        yield chunk
+    
+    def _extract_content(self, response: dict) -> str:
+        """Extract content from GeminiProxy response."""
+        try:
+            return response['candidates'][0]['content']['parts'][0]['text']
+        except (KeyError, IndexError, TypeError):
+            return str(response)
+
+
+class Chat(BaseChat):
+    def __init__(self, client: 'GeminiProxy'):
+        self.completions = Completions(client)
+
+
+class GeminiProxy(OpenAICompatibleProvider):
+    """
+    OpenAI-compatible client for GeminiProxy API.
+    
+    Usage:
+        client = GeminiProxy()
+        response = client.chat.completions.create(
+            model="gemini-2.0-flash-lite",
+            messages=[{"role": "user", "content": "Hello!"}]
+        )
+        print(response.choices[0].message.content)
+    """
+    
+    AVAILABLE_MODELS = [
+        "gemini-2.0-flash-lite",
+        "gemini-2.0-flash",
+        "gemini-2.5-pro-preview-06-05",
+        "gemini-2.5-pro-preview-05-06",
+        "gemini-2.5-flash-preview-04-17",
+        "gemini-2.5-flash-preview-05-20",
+    ]
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,  # Not used but included for compatibility
+        browser: str = "chrome",
+        **kwargs: Any
+    ):
+        """
+        Initialize the GeminiProxy client.
+        
+        Args:
+            api_key: Not used but included for compatibility with OpenAI interface
+            browser: Browser type for fingerprinting
+            **kwargs: Additional parameters
+        """
+        super().__init__(api_key=api_key, **kwargs)
+        
+        self.timeout = 30
+        self.base_url = "https://us-central1-infinite-chain-295909.cloudfunctions.net/gemini-proxy-staging-v1"
+        
+        # Initialize LitAgent for fingerprinting
+        self.agent = LitAgent()
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+        
+        # Initialize session
+        self.session = requests.Session()
+        self.headers = self.fingerprint.copy()
+        self.session.headers.update(self.headers)
+        self.session.proxies = {}
+        
+        # Initialize chat interface
+        self.chat = Chat(self)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()

webscout/Provider/OPENAI/README.md

@@ -68,6 +68,8 @@ Currently, the following providers are implemented with OpenAI-compatible interf
 - TogetherAI
 - PiAI
 - FalconH1
+- XenAI
+- GeminiProxy
 ---
 
 

webscout/Provider/OPENAI/README_AUTOPROXY.md

@@ -0,0 +1,238 @@
+# WebScout Auto-Proxy System
+
+The WebScout Auto-Proxy system provides automatic proxy injection for all OpenAI-compatible providers. This system fetches proxies from a remote source and automatically configures them for HTTP sessions.
+
+## Features
+
+- **Automatic Proxy Injection**: All OpenAI-compatible providers automatically get proxy support
+- **Multiple HTTP Client Support**: Works with `requests`, `httpx`, and `curl_cffi`
+- **Proxy Pool Management**: Automatically fetches and caches proxies from remote source
+- **Working Proxy Detection**: Tests proxies to find working ones
+- **Easy Disable Option**: Can be disabled per provider instance or globally
+
+## How It Works
+
+The system uses a metaclass (`ProxyAutoMeta`) that automatically:
+
+1. Fetches proxies from `http://207.180.209.185:5000/ips.txt`
+2. Caches proxies for 5 minutes to avoid excessive requests
+3. Randomly selects a proxy for each provider instance
+4. Patches existing HTTP session objects with proxy configuration
+5. Provides helper methods for creating proxied sessions
+
+## Usage
+
+### Automatic Usage (Default)
+
+All OpenAI-compatible providers automatically get proxy support:
+
+```python
+from webscout.Provider.OPENAI.yep import YEPCHAT
+
+# Proxy is automatically configured
+client = YEPCHAT()
+
+# All requests will use the configured proxy
+response = client.chat.completions.create(
+    model="DeepSeek-R1-Distill-Qwen-32B",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+### Disabling Auto-Proxy
+
+You can disable automatic proxy injection:
+
+```python
+# Disable for a specific instance
+client = YEPCHAT(disable_auto_proxy=True)
+
+# Or set a class attribute to disable for all instances
+class MyProvider(OpenAICompatibleProvider):
+    DISABLE_AUTO_PROXY = True
+```
+
+### Manual Proxy Configuration
+
+You can also provide your own proxies:
+
+```python
+custom_proxies = {
+    'http': 'http://user:pass@proxy.example.com:8080',
+    'https': 'http://user:pass@proxy.example.com:8080'
+}
+
+client = YEPCHAT(proxies=custom_proxies)
+```
+
+### Using Helper Methods
+
+Each provider instance gets helper methods for creating proxied sessions:
+
+```python
+client = YEPCHAT()
+
+# Get a requests.Session with proxies configured
+session = client.get_proxied_session()
+
+# Get a curl_cffi Session with proxies configured
+curl_session = client.get_proxied_curl_session(impersonate="chrome120")
+
+# Get an httpx.Client with proxies configured (if httpx is installed)
+httpx_client = client.get_proxied_httpx_client()
+```
+
+## Direct API Usage
+
+You can also use the proxy functions directly:
+
+```python
+from webscout.Provider.OPENAI.autoproxy import (
+    get_auto_proxy,
+    get_proxy_dict,
+    get_working_proxy,
+    test_proxy,
+    get_proxy_stats
+)
+
+# Get a random proxy
+proxy = get_auto_proxy()
+
+# Get proxy in dictionary format
+proxy_dict = get_proxy_dict()
+
+# Find a working proxy (tests multiple proxies)
+working_proxy = get_working_proxy(max_attempts=5)
+
+# Test if a proxy is working
+is_working = test_proxy(proxy)
+
+# Get proxy cache statistics
+stats = get_proxy_stats()
+```
+
+## Proxy Format
+
+The system expects proxies in the format:
+```
+http://username:password@host:port
+```
+
+Example:
+```
+http://fnXlN8NP6StpxZkxmNLyOt2MaVLQunpGC7K96j7R0KbnE5sU_2RdYRxaoy7P2yfqrD7Y8UFexv8kpTyK0LwkDQ==:fnXlN8NP6StpxZkxmNLyOt2MaVLQunpGC7K96j7R0KbnE5sU_2RdYRxaoy7P2yfqrD7Y8UFexv8kpTyK0LwkDQ==@190.103.177.163:80
+```
+
+## Configuration
+
+### Cache Duration
+
+You can adjust the proxy cache duration:
+
+```python
+from webscout.Provider.OPENAI.autoproxy import set_proxy_cache_duration
+
+# Set cache to 10 minutes
+set_proxy_cache_duration(600)
+```
+
+### Force Refresh
+
+You can force refresh the proxy cache:
+
+```python
+from webscout.Provider.OPENAI.autoproxy import refresh_proxy_cache
+
+# Force refresh and get number of proxies loaded
+count = refresh_proxy_cache()
+print(f"Loaded {count} proxies")
+```
+
+## Error Handling
+
+The system gracefully handles errors:
+
+- If proxy fetching fails, providers work without proxies
+- If a proxy test fails, the system tries other proxies
+- If no working proxy is found, providers fall back to direct connections
+
+## Logging
+
+The system uses Python's logging module. To see proxy-related logs:
+
+```python
+import logging
+logging.basicConfig(level=logging.INFO)
+
+# Or specifically for the autoproxy module
+logger = logging.getLogger('webscout.Provider.OPENAI.autoproxy')
+logger.setLevel(logging.DEBUG)
+```
+
+## Testing
+
+Run the test suite to verify functionality:
+
+```bash
+python webscout/Provider/OPENAI/test_autoproxy.py
+```
+
+## Implementation Details
+
+### ProxyAutoMeta Metaclass
+
+The `ProxyAutoMeta` metaclass is applied to `OpenAICompatibleProvider` and:
+
+1. Intercepts class instantiation
+2. Checks for `disable_auto_proxy` parameter or class attribute
+3. Fetches and configures proxies if not disabled
+4. Patches existing session objects
+5. Adds helper methods to the instance
+
+### Session Patching
+
+The system automatically patches these session types:
+- `requests.Session` - Updates the `proxies` attribute
+- `httpx.Client` - Sets the `_proxies` attribute
+- `curl_cffi.Session` - Updates the `proxies` attribute
+- `curl_cffi.AsyncSession` - Updates the `proxies` attribute
+
+### Proxy Source
+
+Proxies are fetched from: `http://207.180.209.185:5000/ips.txt`
+
+The system expects one proxy per line in the format shown above.
+
+## Troubleshooting
+
+### No Proxies Available
+
+If you see "No proxies available" messages:
+1. Check if the proxy source URL is accessible
+2. Verify your internet connection
+3. Check if the proxy format is correct
+
+### Proxy Test Failures
+
+If proxy tests fail:
+1. Some proxies may be temporarily unavailable (normal)
+2. The test URL (`https://httpbin.org/ip`) may be blocked
+3. Network connectivity issues
+
+### Provider Not Getting Proxies
+
+If a provider doesn't get automatic proxies:
+1. Ensure it inherits from `OpenAICompatibleProvider`
+2. Check if `disable_auto_proxy` is set
+3. Verify the metaclass is properly imported
+
+## Contributing
+
+To add proxy support to a new provider:
+
+1. Inherit from `OpenAICompatibleProvider`
+2. Accept `disable_auto_proxy` parameter in `__init__`
+3. Use `self.proxies` for HTTP requests
+4. Optionally use helper methods like `self.get_proxied_session()`
+
+The metaclass will handle the rest automatically!

webscout/Provider/OPENAI/__init__.py

@@ -40,4 +40,18 @@ from .oivscode import * # Add OnRender provider
 from .Qwen3 import *
 from .FalconH1 import *
 from .PI import *  # Add PI.ai provider
-from .TogetherAI import *  # Add TogetherAI provider
+from .TogetherAI import *  # Add TogetherAI provider
+from .xenai import *  # Add XenAI provider
+from .GeminiProxy import *  # Add GeminiProxy provider
+
+# Export auto-proxy functionality
+from .autoproxy import (
+    get_auto_proxy,
+    get_proxy_dict,
+    get_working_proxy,
+    test_proxy,
+    get_proxy_stats,
+    refresh_proxy_cache,
+    set_proxy_cache_duration,
+    ProxyAutoMeta
+)