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

webscout/Provider/OPENAI/api.py

@@ -9,16 +9,18 @@ authentication, and provider management.
 from __future__ import annotations
 
 import json
-import logging
 import os
 import secrets
 import sys
 import time
 import uuid
 import inspect
+import re
+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
@@ -28,6 +30,18 @@ from fastapi.routing import APIRoute
 from fastapi.exceptions import RequestValidationError
 from fastapi.security import APIKeyHeader
 from starlette.exceptions import HTTPException as StarletteHTTPException
+
+def clean_text(text):
+    """Clean text by removing null bytes and control characters except newlines and tabs."""
+    if not isinstance(text, str):
+        return text
+    
+    # Remove null bytes
+    text = text.replace('\x00', '')
+    
+    # Keep newlines, tabs, and other printable characters, remove other control chars
+    # This regex matches control characters except \n, \r, \t
+    return re.sub(r'[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
 from starlette.status import (
     HTTP_422_UNPROCESSABLE_ENTITY,
     HTTP_404_NOT_FOUND,
@@ -44,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
@@ -51,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:
@@ -97,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):
@@ -153,7 +172,7 @@ class ChatCompletionRequest(BaseModel):
         extra = "ignore"  # Ignore extra fields that aren't in the model
         schema_extra = {
             "example": {
-                "model": "ChatGPT/gpt-4",
+                "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?"}
@@ -164,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
@@ -223,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
@@ -275,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:
@@ -303,6 +352,7 @@ def create_app():
             "ImagePart": ImagePart,
             "Message": Message,
             "ChatCompletionRequest": ChatCompletionRequest,
+            "ImageGenerationRequest": ImageGenerationRequest,
         }
 
         for name, model_cls in pydantic_models_to_register.items():
@@ -386,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
@@ -536,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
@@ -571,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(
@@ -606,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."""
@@ -634,7 +850,16 @@ def resolve_provider_and_model(model_identifier: str) -> tuple[Any, str]:
 
     # Validate model availability
     if hasattr(provider_class, "AVAILABLE_MODELS") and model_name is not None:
-        available = getattr(provider_class, "AVAILABLE_MODELS", [])
+        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 provider '{provider_class.__name__}'. Available models: {available}",
@@ -645,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."""
@@ -722,34 +1014,69 @@ async def handle_streaming_response(provider: Any, params: Dict[str, Any], reque
                             chunk_data = chunk
                         else:  # Fallback for unknown chunk types
                             chunk_data = chunk
-                        yield f"data: {json.dumps(chunk_data)}\n\n"
+                        
+                        # Clean text content in the chunk to remove control characters
+                        if isinstance(chunk_data, dict) and 'choices' in chunk_data:
+                            for choice in chunk_data.get('choices', []):
+                                if isinstance(choice, dict):
+                                    # Handle delta for streaming
+                                    if 'delta' in choice and isinstance(choice['delta'], dict) and 'content' in choice['delta']:
+                                        choice['delta']['content'] = clean_text(choice['delta']['content'])
+                                    # Handle message for non-streaming
+                                    elif 'message' in choice and isinstance(choice['message'], dict) and 'content' in choice['message']:
+                                        choice['message']['content'] = clean_text(choice['message']['content'])
+                        
+                        yield f"data: {json.dumps(chunk_data, ensure_ascii=False)}\n\n"
                 except TypeError as te:
                     logger.error(f"Error iterating over completion_stream: {te}")
                     # Fall back to treating as non-generator response
                     if hasattr(completion_stream, 'model_dump'):
-                        yield f"data: {json.dumps(completion_stream.model_dump(exclude_none=True))}\n\n"
+                        response_data = completion_stream.model_dump(exclude_none=True)
                     elif hasattr(completion_stream, 'dict'):
-                        yield f"data: {json.dumps(completion_stream.dict(exclude_none=True))}\n\n"
+                        response_data = completion_stream.dict(exclude_none=True)
                     else:
-                        yield f"data: {json.dumps(completion_stream)}\n\n"
+                        response_data = completion_stream
+                    
+                    # Clean text content in the response
+                    if isinstance(response_data, dict) and 'choices' in response_data:
+                        for choice in response_data.get('choices', []):
+                            if isinstance(choice, dict):
+                                if 'delta' in choice and isinstance(choice['delta'], dict) and 'content' in choice['delta']:
+                                    choice['delta']['content'] = clean_text(choice['delta']['content'])
+                                elif 'message' in choice and isinstance(choice['message'], dict) and 'content' in choice['message']:
+                                    choice['message']['content'] = clean_text(choice['message']['content'])
+                    
+                    yield f"data: {json.dumps(response_data, ensure_ascii=False)}\n\n"
             else:  # Non-generator response
                 if hasattr(completion_stream, 'model_dump'):
-                    yield f"data: {json.dumps(completion_stream.model_dump(exclude_none=True))}\n\n"
+                    response_data = completion_stream.model_dump(exclude_none=True)
                 elif hasattr(completion_stream, 'dict'):
-                    yield f"data: {json.dumps(completion_stream.dict(exclude_none=True))}\n\n"
+                    response_data = completion_stream.dict(exclude_none=True)
                 else:
-                    yield f"data: {json.dumps(completion_stream)}\n\n"
+                    response_data = completion_stream
+                
+                # Clean text content in the response
+                if isinstance(response_data, dict) and 'choices' in response_data:
+                    for choice in response_data.get('choices', []):
+                        if isinstance(choice, dict):
+                            if 'delta' in choice and isinstance(choice['delta'], dict) and 'content' in choice['delta']:
+                                choice['delta']['content'] = clean_text(choice['delta']['content'])
+                            elif 'message' in choice and isinstance(choice['message'], dict) and 'content' in choice['message']:
+                                choice['message']['content'] = clean_text(choice['message']['content'])
+                
+                yield f"data: {json.dumps(response_data, ensure_ascii=False)}\n\n"
 
         except Exception as e:
             logger.error(f"Error in streaming response for request {request_id}: {e}")
+            error_message = clean_text(str(e))
             error_data = {
                 "error": {
-                    "message": str(e),
+                    "message": error_message,
                     "type": "server_error",
                     "code": "streaming_error"
                 }
             }
-            yield f"data: {json.dumps(error_data)}\n\n"
+            yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
         finally:
             yield "data: [DONE]\n\n"
     return StreamingResponse(streaming(), media_type="text/event-stream")
@@ -789,6 +1116,13 @@ async def handle_non_streaming_response(provider: Any, params: Dict[str, Any],
                 HTTP_500_INTERNAL_SERVER_ERROR,
                 "provider_error"
             )
+        
+        # Clean text content in the response to remove control characters
+        if isinstance(response_data, dict) and 'choices' in response_data:
+            for choice in response_data.get('choices', []):
+                if isinstance(choice, dict) and 'message' in choice:
+                    if isinstance(choice['message'], dict) and 'content' in choice['message']:
+                        choice['message']['content'] = clean_text(choice['message']['content'])
 
         elapsed = time.time() - start_time
         logger.info(f"Completed non-streaming request {request_id} in {elapsed:.2f}s")
@@ -797,8 +1131,9 @@ async def handle_non_streaming_response(provider: Any, params: Dict[str, Any],
 
     except Exception as e:
         logger.error(f"Error in non-streaming response for request {request_id}: {e}")
+        error_message = clean_text(str(e))
         raise APIError(
-            f"Provider error: {str(e)}",
+            f"Provider error: {error_message}",
             HTTP_500_INTERNAL_SERVER_ERROR,
             "provider_error"
         )
@@ -864,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}")
@@ -895,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")
 
@@ -967,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())