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

webscout/Provider/OPENAI/api.py

@@ -9,7 +9,6 @@ authentication, and provider management.
 from __future__ import annotations
 
 import json
-import logging
 import os
 import secrets
 import sys
@@ -21,6 +20,7 @@ import codecs
 from typing import List, Dict, Optional, Union, Any, Generator, Callable
 import types
 
+from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
 import uvicorn
 from fastapi import FastAPI, Response, Request, Body
 from fastapi.middleware.cors import CORSMiddleware
@@ -58,6 +58,9 @@ from webscout.Provider.OPENAI import *
 from webscout.Provider.OPENAI.utils import (
     ChatCompletion, Choice, ChatCompletionMessage, CompletionUsage
 )
+from webscout.Provider.TTI import *
+from webscout.Provider.TTI.utils import ImageData, ImageResponse
+from webscout.Provider.TTI.base import TTICompatibleProvider
 
 
 # Configuration constants
@@ -65,15 +68,13 @@ DEFAULT_PORT = 8000
 DEFAULT_HOST = "0.0.0.0"
 API_VERSION = "v1"
 
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[
-        logging.StreamHandler(sys.stdout),
-    ]
+# Setup Litlogger
+logger = Logger(
+    name="webscout.api",
+    level=LogLevel.INFO,
+    handlers=[ConsoleHandler(stream=sys.stdout)],
+    fmt=LogFormat.DEFAULT
 )
-logger = logging.getLogger("webscout.api")
 
 
 class ServerConfig:
@@ -111,6 +112,10 @@ class ServerConfig:
 # Global configuration instance
 config = ServerConfig()
 
+# Cache for provider instances to avoid reinitialization on every request
+provider_instances: Dict[str, Any] = {}
+tti_provider_instances: Dict[str, Any] = {}
+
 
 # Define Pydantic models for multimodal content parts, aligning with OpenAI's API
 class TextPart(BaseModel):
@@ -167,7 +172,7 @@ class ChatCompletionRequest(BaseModel):
         extra = "ignore"  # Ignore extra fields that aren't in the model
         schema_extra = {
             "example": {
-                "model": "ChatGPT/gpt-4o",
+                "model": "Cloudflare/@cf/meta/llama-4-scout-17b-16e-instruct",
                 "messages": [
                     {"role": "system", "content": "You are a helpful assistant."},
                     {"role": "user", "content": "Hello, how are you?"}
@@ -178,6 +183,33 @@ class ChatCompletionRequest(BaseModel):
             }
         }
 
+class ImageGenerationRequest(BaseModel):
+    """Request model for OpenAI-compatible image generation endpoint."""
+    prompt: str = Field(..., description="A text description of the desired image(s). The maximum length is 1000 characters.")
+    model: str = Field(..., description="The model to use for image generation.")
+    n: Optional[int] = Field(1, description="The number of images to generate. Must be between 1 and 10.")
+    size: Optional[str] = Field("1024x1024", description="The size of the generated images. Must be one of: '256x256', '512x512', or '1024x1024'.")
+    response_format: Optional[Literal["url", "b64_json"]] = Field("url", description="The format in which the generated images are returned. Must be either 'url' or 'b64_json'.")
+    user: Optional[str] = Field(None, description="A unique identifier representing your end-user, which can help to monitor and detect abuse.")
+    style: Optional[str] = Field(None, description="Optional style for the image (provider/model-specific).")
+    aspect_ratio: Optional[str] = Field(None, description="Optional aspect ratio for the image (provider/model-specific).")
+    timeout: Optional[int] = Field(None, description="Optional timeout for the image generation request in seconds.")
+    image_format: Optional[str] = Field(None, description="Optional image format (e.g., 'png', 'jpeg').")
+    seed: Optional[int] = Field(None, description="Optional random seed for reproducibility.")
+
+    class Config:
+        extra = "ignore"
+        schema_extra = {
+            "example": {
+                "prompt": "A futuristic cityscape at sunset, digital art",
+                "model": "PollinationsAI/turbo",
+                "n": 1,
+                "size": "1024x1024",
+                "response_format": "url",
+                "user": "user-1234"
+            }
+        }
+
 class ModelInfo(BaseModel):
     """Model information for the models endpoint."""
     id: str
@@ -237,7 +269,9 @@ class AppConfig:
     """Legacy configuration class for backward compatibility."""
     api_key: Optional[str] = None
     provider_map = {}
+    tti_provider_map = {}  # Add TTI provider map
     default_provider = "ChatGPT"
+    default_tti_provider = "PollinationsAI"  # Add default TTI provider
     base_url: Optional[str] = None
 
     @classmethod
@@ -289,6 +323,7 @@ def create_app():
     api.register_validation_exception_handler()
     api.register_routes()
     initialize_provider_map()
+    initialize_tti_provider_map()  # Initialize TTI providers
 
     def custom_openapi():
         if app.openapi_schema:
@@ -317,6 +352,7 @@ def create_app():
             "ImagePart": ImagePart,
             "Message": Message,
             "ChatCompletionRequest": ChatCompletionRequest,
+            "ImageGenerationRequest": ImageGenerationRequest,
         }
 
         for name, model_cls in pydantic_models_to_register.items():
@@ -400,6 +436,63 @@ def initialize_provider_map() -> None:
         logger.error(f"Failed to initialize provider map: {e}")
         raise APIError(f"Provider initialization failed: {e}", HTTP_500_INTERNAL_SERVER_ERROR)
 
+def initialize_tti_provider_map() -> None:
+    """Initialize the TTI provider map by discovering available TTI providers."""
+    logger.info("Initializing TTI provider map...")
+
+    try:
+        import webscout.Provider.TTI as tti_module
+        
+        provider_count = 0
+        model_count = 0
+
+        for name, obj in inspect.getmembers(tti_module):
+            if (
+                inspect.isclass(obj)
+                and issubclass(obj, TTICompatibleProvider)
+                and obj.__name__ != "TTICompatibleProvider"
+                and obj.__name__ != "BaseImages"
+            ):
+                provider_name = obj.__name__
+                AppConfig.tti_provider_map[provider_name] = obj
+                provider_count += 1
+
+                # Register available models for this TTI provider
+                if hasattr(obj, "AVAILABLE_MODELS") and isinstance(
+                    obj.AVAILABLE_MODELS, (list, tuple, set)
+                ):
+                    for model in obj.AVAILABLE_MODELS:
+                        if model and isinstance(model, str):
+                            model_key = f"{provider_name}/{model}"
+                            AppConfig.tti_provider_map[model_key] = obj
+                            model_count += 1
+
+        # Fallback to PollinationsAI if no TTI providers found
+        if not AppConfig.tti_provider_map:
+            logger.warning("No TTI providers found, using PollinationsAI fallback")
+            try:
+                from webscout.Provider.TTI.pollinations import PollinationsAI
+                fallback_models = ["flux", "turbo", "gptimage"]
+
+                AppConfig.tti_provider_map["PollinationsAI"] = PollinationsAI
+
+                for model in fallback_models:
+                    model_key = f"PollinationsAI/{model}"
+                    AppConfig.tti_provider_map[model_key] = PollinationsAI
+
+                AppConfig.default_tti_provider = "PollinationsAI"
+                provider_count = 1
+                model_count = len(fallback_models)
+            except ImportError as e:
+                logger.error(f"Failed to import PollinationsAI fallback: {e}")
+                raise APIError("No TTI providers available", HTTP_500_INTERNAL_SERVER_ERROR)
+
+        logger.info(f"Initialized {provider_count} TTI providers with {model_count} models")
+
+    except Exception as e:
+        logger.error(f"Failed to initialize TTI provider map: {e}")
+        raise APIError(f"TTI Provider initialization failed: {e}", HTTP_500_INTERNAL_SERVER_ERROR)
+
 class Api:
     def __init__(self, app: FastAPI) -> None:
         self.app = app
@@ -550,6 +643,29 @@ class Api:
                     "created": int(time.time()),
                     "owned_by": provider_class.__name__
                 })
+            # Sort models alphabetically by the part after the first '/'
+            models = sorted(models, key=lambda m: m["id"].split("/", 1)[1].lower())
+            return {
+                "object": "list",
+                "data": models
+            }
+
+        @self.app.get("/v1/TTI/models", response_model=ModelListResponse)
+        async def list_tti_models():
+            models = []
+            for model_name, provider_class in AppConfig.tti_provider_map.items():
+                if "/" not in model_name:
+                    continue  # Skip provider names
+                if any(m["id"] == model_name for m in models):
+                    continue
+                models.append({
+                    "id": model_name,
+                    "object": "model",
+                    "created": int(time.time()),
+                    "owned_by": provider_class.__name__
+                })
+            # Sort models alphabetically by the part after the first '/'
+            models = sorted(models, key=lambda m: m["id"].split("/", 1)[1].lower())
             return {
                 "object": "list",
                 "data": models
@@ -585,10 +701,10 @@ class Api:
                 # Resolve provider and model
                 provider_class, model_name = resolve_provider_and_model(chat_request.model)
 
-                # Initialize provider with error handling
+                # Initialize provider with caching and error handling
                 try:
-                    provider = provider_class()
-                    logger.debug(f"Initialized provider: {provider_class.__name__}")
+                    provider = get_provider_instance(provider_class)
+                    logger.debug(f"Using provider instance: {provider_class.__name__}")
                 except Exception as e:
                     logger.error(f"Failed to initialize provider {provider_class.__name__}: {e}")
                     raise APIError(
@@ -620,6 +736,92 @@ class Api:
                     "internal_error"
                 )
 
+        @self.app.post(
+            "/v1/images/generations",
+            response_model_exclude_none=True,
+            response_model_exclude_unset=True,
+            openapi_extra={
+                "requestBody": {
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/ImageGenerationRequest"
+                            },
+                            "example": ImageGenerationRequest.Config.schema_extra["example"]
+                        }
+                    }
+                }            }
+        )
+        async def image_generations(
+            image_request: ImageGenerationRequest = Body(...)
+        ):
+            """Handle image generation requests (OpenAI-compatible)."""
+            request_id = f"imggen-{uuid.uuid4()}"
+            try:
+                logger.info(f"Processing image generation request {request_id} for model: {image_request.model}")
+                # Provider/model resolution using TTI providers
+                provider_class, model_name = resolve_tti_provider_and_model(image_request.model)
+                # Initialize provider with caching
+                try:
+                    provider = get_tti_provider_instance(provider_class)
+                    logger.debug(f"Using TTI provider instance: {provider_class.__name__}")
+                except Exception as e:
+                    logger.error(f"Failed to initialize provider {provider_class.__name__}: {e}")
+                    raise APIError(
+                        f"Failed to initialize provider {provider_class.__name__}: {e}",
+                        HTTP_500_INTERNAL_SERVER_ERROR,
+                        "provider_error"
+                    )
+                # Prepare parameters for provider
+                params = {
+                    "model": model_name,
+                    "prompt": image_request.prompt,
+                    "n": image_request.n,
+                    "size": image_request.size,
+                    "response_format": image_request.response_format,
+                    "user": image_request.user,
+                    "style": image_request.style,
+                    "aspect_ratio": image_request.aspect_ratio,
+                    "timeout": image_request.timeout,
+                    "image_format": image_request.image_format,
+                    "seed": image_request.seed,
+                }
+                # Remove None values
+                params = {k: v for k, v in params.items() if v is not None}
+                # Call provider
+                try:
+                    result = provider.images.create(**params)
+                except Exception as e:
+                    logger.error(f"Error in image generation for request {request_id}: {e}")
+                    raise APIError(
+                        f"Provider error: {str(e)}",
+                        HTTP_500_INTERNAL_SERVER_ERROR,
+                        "provider_error"
+                    )
+                # Standardize response
+                if hasattr(result, "model_dump"):
+                    response_data = result.model_dump(exclude_none=True)
+                elif hasattr(result, "dict"):
+                    response_data = result.dict(exclude_none=True)
+                elif isinstance(result, dict):
+                    response_data = result
+                else:
+                    raise APIError(
+                        "Invalid response format from provider",
+                        HTTP_500_INTERNAL_SERVER_ERROR,
+                        "provider_error"
+                    )
+                return response_data
+            except APIError:
+                raise
+            except Exception as e:
+                logger.error(f"Unexpected error in image generation {request_id}: {e}")
+                raise APIError(
+                    f"Internal server error: {str(e)}",
+                    HTTP_500_INTERNAL_SERVER_ERROR,
+                    "internal_error"
+                )
+
 
 def resolve_provider_and_model(model_identifier: str) -> tuple[Any, str]:
     """Resolve provider class and model name from model identifier."""
@@ -668,6 +870,73 @@ def resolve_provider_and_model(model_identifier: str) -> tuple[Any, str]:
 
     return provider_class, model_name
 
+def resolve_tti_provider_and_model(model_identifier: str) -> tuple[Any, str]:
+    """Resolve TTI provider class and model name from model identifier."""
+    provider_class = None
+    model_name = None
+
+    # Check for explicit provider/model syntax
+    if model_identifier in AppConfig.tti_provider_map and "/" in model_identifier:
+        provider_class = AppConfig.tti_provider_map[model_identifier]
+        _, model_name = model_identifier.split("/", 1)
+    elif "/" in model_identifier:
+        provider_name, model_name = model_identifier.split("/", 1)
+        provider_class = AppConfig.tti_provider_map.get(provider_name)
+    else:
+        provider_class = AppConfig.tti_provider_map.get(AppConfig.default_tti_provider)
+        model_name = model_identifier
+
+    if not provider_class:
+        available_providers = list(set(v.__name__ for v in AppConfig.tti_provider_map.values()))
+        raise APIError(
+            f"TTI Provider for model '{model_identifier}' not found. Available TTI providers: {available_providers}",
+            HTTP_404_NOT_FOUND,
+            "model_not_found",
+            param="model"
+        )
+
+    # Validate model availability
+    if hasattr(provider_class, "AVAILABLE_MODELS") and model_name is not None:
+        available = getattr(provider_class, "AVAILABLE_MODELS", None)
+        # If it's a property, get from instance
+        if isinstance(available, property):
+            try:
+                available = getattr(provider_class(), "AVAILABLE_MODELS", [])
+            except Exception:
+                available = []
+        # If still not iterable, fallback to empty list
+        if not isinstance(available, (list, tuple, set)):
+            available = list(available) if hasattr(available, "__iter__") and not isinstance(available, str) else []
+        if available and model_name not in available:
+            raise APIError(
+                f"Model '{model_name}' not supported by TTI provider '{provider_class.__name__}'. Available models: {available}",
+                HTTP_404_NOT_FOUND,
+                "model_not_found",
+                param="model"
+            )
+
+    return provider_class, model_name
+
+
+def get_provider_instance(provider_class: Any):
+    """Return a cached instance of the provider, creating it if necessary."""
+    key = provider_class.__name__
+    instance = provider_instances.get(key)
+    if instance is None:
+        instance = provider_class()
+        provider_instances[key] = instance
+    return instance
+
+
+def get_tti_provider_instance(provider_class: Any):
+    """Return a cached instance of the TTI provider, creating it if needed."""
+    key = provider_class.__name__
+    instance = tti_provider_instances.get(key)
+    if instance is None:
+        instance = provider_class()
+        tti_provider_instances[key] = instance
+    return instance
+
 
 def process_messages(messages: List[Message]) -> List[Dict[str, Any]]:
     """Process and validate chat messages."""
@@ -930,6 +1199,8 @@ def run_api(
     if show_available_providers: # Initialize map if needed for display before app creation
         if not AppConfig.provider_map: # Avoid re-initializing if already done by app creation logic path
             initialize_provider_map()
+        if not AppConfig.tti_provider_map:
+            initialize_tti_provider_map() # Ensure TTI providers are initialized for display
 
         print("\n=== Webscout OpenAI API Server ===")
         print(f"Server URL: http://{host if host != '0.0.0.0' else 'localhost'}:{port}")
@@ -961,6 +1232,19 @@ def run_api(
         else:
             print("\nNo specific models registered. Use provider names as models.")
 
+        tti_providers = list(set(v.__name__ for v in AppConfig.tti_provider_map.values()))
+        print(f"\n--- Available TTI Providers ({len(tti_providers)}) ---")
+        for i, provider_name in enumerate(sorted(tti_providers), 1):
+            print(f"{i}. {provider_name}")
+
+        tti_models = sorted([model for model in AppConfig.tti_provider_map.keys() if model not in tti_providers])
+        if tti_models:
+            print(f"\n--- Available TTI Models ({len(tti_models)}) ---")
+            for i, model_name in enumerate(tti_models, 1):
+                print(f"{i}. {model_name} (via {AppConfig.tti_provider_map[model_name].__name__})")
+        else:
+            print("\nNo specific TTI models registered. Use TTI provider names as models.")
+
         print("\nUse Ctrl+C to stop the server.")
         print("=" * 40 + "\n")
 
@@ -1033,3 +1317,4 @@ if __name__ == "__main__":
         base_url=args.base_url,
         debug=args.debug
     )
+

webscout/Provider/OPENAI/autoproxy.py

@@ -0,0 +1,39 @@
+# # ProxyFox integration for OpenAI-compatible providers
+# # This module provides a singleton proxy pool for all providers
+
+# import proxyfox
+
+# def get_auto_proxy(protocol='https', country=None, max_speed_ms=1000):
+#     """
+#     Returns a single proxy string (e.g. '11.22.33.44:8080') using proxyfox.
+#     You can specify protocol, country, and max_speed_ms for filtering.
+#     """
+#     kwargs = {'protocol': protocol, 'max_speed_ms': max_speed_ms}
+#     if country:
+#         kwargs['country'] = country
+#     return proxyfox.get_one(**kwargs)
+
+# # Optionally: pool support for advanced usage
+# _pool = None
+
+# def get_proxy_pool(size=10, refresh_interval=300, protocol='https', max_speed_ms=1000):
+#     global _pool
+#     if _pool is None:
+#         _pool = proxyfox.create_pool(
+#             size=size,
+#             refresh_interval=refresh_interval,
+#             protocol=protocol,
+#             max_speed_ms=max_speed_ms
+#         )
+#     return _pool
+
+# def get_pool_proxy():
+#     pool = get_proxy_pool()
+#     return pool.get()
+
+# def get_all_pool_proxies():
+#     pool = get_proxy_pool()
+#     return pool.all()
+
+# if __name__ == "__main__":
+#     print(get_auto_proxy())

webscout/Provider/OPENAI/base.py

@@ -3,12 +3,11 @@ from typing import List, Dict, Optional, Union, Generator, Any, TypedDict, Calla
 import json
 import logging
 from dataclasses import dataclass
-
 logger = logging.getLogger(__name__)
 
 
 # Import the utils for response structures
-from webscout.Provider.OPENAI.utils import ChatCompletion, ChatCompletionChunk, Choice, ChatCompletionMessage, ToolCall, ToolFunction
+from webscout.Provider.OPENAI.utils import ChatCompletion, ChatCompletionChunk
 
 # Define tool-related structures
 class ToolDefinition(TypedDict):
@@ -174,10 +173,93 @@ class BaseChat(ABC):
     completions: BaseCompletions
 
 
+# class ProxyAutoMeta(ABCMeta):
+#     """
+#     Metaclass to ensure all OpenAICompatibleProvider subclasses automatically get proxy support.
+#     This will inject proxies into any requests.Session, httpx.Client, or curl_cffi session attributes found on the instance.
+
+#     To disable automatic proxy injection, set disable_auto_proxy=True in the constructor or
+#     set the class attribute DISABLE_AUTO_PROXY = True.
+#     """
+#     def __call__(cls, *args, **kwargs):
+#         instance = super().__call__(*args, **kwargs)
+
+#         # Check if auto proxy is disabled
+#         disable_auto_proxy = kwargs.get('disable_auto_proxy', False) or getattr(cls, 'DISABLE_AUTO_PROXY', False)
+
+#         proxies = getattr(instance, 'proxies', None) or kwargs.get('proxies', None)
+#         if proxies is None and not disable_auto_proxy:
+#             try:
+#                 proxies = {"http": get_auto_proxy(), "https": get_auto_proxy()}
+#             except Exception as e:
+#                 logger.warning(f"Failed to get auto proxy, disabling proxy support: {e}")
+#                 proxies = {}
+#         elif proxies is None:
+#             proxies = {}
+#         instance.proxies = proxies
+#         # Patch sessions if we have valid proxies
+#         if proxies:
+#             for attr in dir(instance):
+#                 obj = getattr(instance, attr)
+#                 if isinstance(obj, requests.Session):
+#                     obj.proxies.update(proxies)
+#                 if httpx and isinstance(obj, httpx.Client):
+#                     try:
+#                         obj._proxies = proxies
+#                     except Exception:
+#                         pass
+#                 # Patch curl_cffi sessions if present
+#                 if CurlSession and isinstance(obj, CurlSession):
+#                     try:
+#                         obj.proxies.update(proxies)
+#                     except Exception:
+#                         pass
+#                 if CurlAsyncSession and isinstance(obj, CurlAsyncSession):
+#                     try:
+#                         obj.proxies.update(proxies)
+#                     except Exception:
+#                         pass
+#         # Provide helpers for proxied sessions
+#         def get_proxied_session():
+#             s = requests.Session()
+#             s.proxies.update(proxies)
+#             return s
+#         instance.get_proxied_session = get_proxied_session
+
+#         def get_proxied_curl_session(impersonate="chrome120", **kwargs):
+#             """Get a curl_cffi Session with proxies configured"""
+#             if CurlSession:
+#                 return CurlSession(proxies=proxies, impersonate=impersonate, **kwargs)
+#             else:
+#                 raise ImportError("curl_cffi is not installed")
+#         instance.get_proxied_curl_session = get_proxied_curl_session
+
+#         def get_proxied_curl_async_session(impersonate="chrome120", **kwargs):
+#             """Get a curl_cffi AsyncSession with proxies configured"""
+#             if CurlAsyncSession:
+#                 return CurlAsyncSession(proxies=proxies, impersonate=impersonate, **kwargs)
+#             else:
+#                 raise ImportError("curl_cffi is not installed")
+#         instance.get_proxied_curl_async_session = get_proxied_curl_async_session
+
+#         return instance
+# class OPENAICompatibleMeta(ABC, metaclass=ProxyAutoMeta):
 class OpenAICompatibleProvider(ABC):
     """
     Abstract Base Class for providers mimicking the OpenAI Python client structure.
     Requires a nested 'chat.completions' structure with tool support.
+    All subclasses automatically get proxy support via ProxyAutoMeta.
+
+    # Available proxy helpers:
+    # - self.get_proxied_session() - returns a requests.Session with proxies
+    # - self.get_proxied_curl_session() - returns a curl_cffi.Session with proxies
+    # - self.get_proxied_curl_async_session() - returns a curl_cffi.AsyncSession with proxies
+
+    # Proxy support is automatically injected into:
+    # - requests.Session objects
+    # - httpx.Client objects
+    # - curl_cffi.requests.Session objects
+    # - curl_cffi.requests.AsyncSession objects
     """
     chat: BaseChat
     available_tools: Dict[str, Tool] = {}  # Dictionary of available tools
@@ -185,19 +267,14 @@ class OpenAICompatibleProvider(ABC):
     supports_tool_choice: bool = False  # Whether the provider supports tool_choice
 
     @abstractmethod
-    def __init__(self, api_key: Optional[str] = None, tools: Optional[List[Tool]] = None, **kwargs: Any):
-        """
-        Initialize the provider, potentially with an API key and tools.
-        
-        Args:
-            api_key: Optional API key for the provider
-            tools: Optional list of tools to make available to the provider
-            **kwargs: Additional provider-specific parameters
-        """
+    def __init__(self, api_key: Optional[str] = None, tools: Optional[List[Tool]] = None, proxies: Optional[dict] = None, **kwargs: Any):
         self.available_tools = {}
         if tools:
             self.register_tools(tools)
-        raise NotImplementedError
+        # self.proxies is set by ProxyAutoMeta
+        # Subclasses should use self.proxies for all network requests
+        # Optionally, use self.get_proxied_session() for a requests.Session with proxies
+        # raise NotImplementedError  # <-- Commented out for metaclass test
 
     @property
     @abstractmethod

webscout/Provider/OPENAI/chatgpt.py

@@ -37,9 +37,21 @@ class ChatGPTReversed:
     csrf_token = None
     initialized = False
 
+    _instance = None
+
+    def __new__(cls, model="auto"):
+        if cls._instance is None:
+            cls._instance = super(ChatGPTReversed, cls).__new__(cls)
+            cls._instance.initialized = False
+        return cls._instance
+
     def __init__(self, model="auto"):
-        if ChatGPTReversed.initialized:
-            raise Exception("ChatGPTReversed has already been initialized.")
+        if self.initialized:
+            # Already initialized, just update model if needed
+            if model not in self.AVAILABLE_MODELS:
+                raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+            self.model = model
+            return
 
         if model not in self.AVAILABLE_MODELS:
             raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
@@ -573,3 +585,4 @@ if __name__ == "__main__":
         messages=[{"role": "user", "content": "How manr r in strawberry"}]
     )
     print(response.choices[0].message.content)
+    print()

webscout/Provider/OPENAI/chatgptclone.py

@@ -7,8 +7,8 @@ import re
 from typing import List, Dict, Optional, Union, Generator, Any
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage, count_tokens
 )
@@ -510,4 +510,15 @@ class ChatGPTClone(OpenAICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
-        return _ModelList()
+        return _ModelList()
+if __name__ == "__main__":
+    # Example usage
+    client = ChatGPTClone()
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.choices[0].message.content)
+    print()
+    print("Proxies on instance:", client.proxies)
+    print("Proxies on session:", client.session.proxies)