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

webscout/Provider/Writecream.py

@@ -1,246 +0,0 @@
-from curl_cffi import CurlError 
-from curl_cffi.requests import Session # Keep Session import
-import json
-from typing import Any, Dict, Optional, Generator, Union
-
-from webscout.AIutel import Optimizers
-from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
-from webscout.AIbase import Provider
-from webscout import exceptions
-from webscout.litagent import LitAgent
-
-class Writecream(Provider):
-    """
-    A class to interact with the Writecream API.
-    """
-
-    AVAILABLE_MODELS = ["writecream-gpt"]
-
-    def __init__(
-        self,
-        is_conversation: bool = True,
-        max_tokens: int = 600,
-        timeout: int = 30,
-        intro: str = None,
-        filepath: str = None,
-        update_file: bool = True,
-        proxies: dict = {},
-        history_offset: int = 10250,
-        act: str = None,
-        system_prompt: str = "You are a helpful and informative AI assistant.",
-        base_url: str = "https://8pe3nv3qha.execute-api.us-east-1.amazonaws.com/default/llm_chat",
-        referer: str = "https://www.writecream.com/chatgpt-chat/",
-        link: str = "writecream.com",
-        model: str = "writecream-gpt"
-    ):
-        """
-        Initializes the Writecream API with given parameters.
-        """
-        if model not in self.AVAILABLE_MODELS:
-            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
-
-        # Initialize curl_cffi Session
-        self.session = Session()
-        self.is_conversation = is_conversation
-        self.max_tokens_to_sample = max_tokens
-        self.base_url = base_url
-        self.timeout = timeout
-        self.last_response = {}
-        self.system_prompt = system_prompt
-        self.model = model
-        # Initialize LitAgent
-        self.agent = LitAgent()
-        self.referer = referer
-        self.link = link
-
-        self.headers = {
-            # Use LitAgent for User-Agent
-            "User-Agent": self.agent.random(),
-            "Referer": self.referer
-            # Add other headers if needed by curl_cffi impersonation or API
-        }
-
-        self.__available_optimizers = (
-            method
-            for method in dir(Optimizers)
-            if callable(getattr(Optimizers, method)) and not method.startswith("__")
-        )
-
-        # Update curl_cffi session headers and proxies
-        self.session.headers.update(self.headers)
-        self.session.proxies.update(proxies)
-
-        Conversation.intro = (
-            AwesomePrompts().get_act(
-                act, raise_not_found=True, default=None, case_insensitive=True
-            )
-            if act
-            else intro or Conversation.intro
-        )
-
-        self.conversation = Conversation(
-            is_conversation, self.max_tokens_to_sample, filepath, update_file
-        )
-        self.conversation.history_offset = history_offset
-
-    def ask(
-        self,
-        prompt: str,
-        stream: bool = False,
-        raw: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-    ) -> Union[Dict[str, Any], Generator]:
-        """
-        Sends a message to the Writecream API and returns the response.
-
-        Args:
-            prompt (str): Prompt to be sent.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            raw (bool, optional): Stream back raw response as received. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
-
-        Returns:
-            Union[Dict[str, Any], Generator]: Response from the API.
-        """
-        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
-        if optimizer:
-            if optimizer in self.__available_optimizers:
-                conversation_prompt = getattr(Optimizers, optimizer)(
-                    conversation_prompt if conversationally else prompt
-                )
-            else:
-                raise exceptions.FailedToGenerateResponseError(
-                    f"Optimizer is not one of {self.__available_optimizers}"
-                )
-
-        final_query = [
-            {"role": "system", "content": self.system_prompt},
-            {"role": "user", "content": conversation_prompt}
-        ]
-
-        params = {
-            "query": json.dumps(final_query),
-            "link": self.link
-        }
-
-        def for_non_stream():
-            try:
-                # Use curl_cffi session.get with impersonate
-                response = self.session.get(
-                    self.base_url,
-                    params=params,
-                    timeout=self.timeout,
-                    impersonate="chrome120" # Add impersonate
-                )
-                response.raise_for_status()
-                response_text = response.text # Get the raw text
-
-                # Use sanitize_stream to process the non-streaming text
-                # It will try to parse the whole text as JSON because to_json=True
-                processed_stream = sanitize_stream(
-                    data=response_text,
-                    to_json=True, # Attempt to parse the whole response text as JSON
-                    intro_value=None, # No prefix expected on the full response
-                    content_extractor=lambda chunk: chunk.get("response", chunk.get("response_content", "")) if isinstance(chunk, dict) else None
-                )
-
-                # Extract the single result from the generator
-                response_content = ""
-                for content in processed_stream:
-                    response_content = content if isinstance(content, str) else ""
-
-                # Update conversation history
-                self.last_response = {"text": response_content}
-                self.conversation.update_chat_history(prompt, response_content)
-
-                return {"text": response_content}
-            except CurlError as e: # Catch CurlError
-                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
-            except Exception as e:
-                # Include original exception type
-                raise exceptions.FailedToGenerateResponseError(f"Failed to get response ({type(e).__name__}): {e}")
-
-        # Currently, Writecream API doesn't support streaming, so we always return non-streaming response
-        return for_non_stream()
-
-    def chat(
-        self,
-        prompt: str,
-        stream: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-    ) -> Union[str, Generator[str, None, None]]:
-        """
-        Generates a response from the Writecream API.
-
-        Args:
-            prompt (str): Prompt to be sent.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
-
-        Returns:
-            Union[str, Generator[str, None, None]]: Response from the API.
-        """
-        def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    stream=False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                )
-            )
-
-        if stream:
-            # For compatibility with AUTO streaming interface, yield a dict
-            response_dict = self.ask(
-                prompt,
-                stream=False,
-                optimizer=optimizer,
-                conversationally=conversationally,
-            )
-            yield response_dict
-        else:
-            return for_non_stream()
-
-    def get_message(self, response: dict) -> str:
-        """
-        Retrieves message only from response.
-
-        Args:
-            response (dict): Response generated by `self.ask`
-
-        Returns:
-            str: Message extracted
-        """
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response["text"]
-
-
-if __name__ == "__main__":
-    # Ensure curl_cffi is installed
-    print("-" * 80)
-    print(f"{'Model':<30} {'Status':<10} {'Response'}")
-    print("-" * 80)
-
-    try:
-        test_api = Writecream(timeout=60)
-        prompt = "Say 'Hello' in one word"
-        response = test_api.chat(prompt)
-
-        if response and len(response.strip()) > 0:
-            status = "✓"
-            # Clean and truncate response
-            clean_text = response.strip().encode('utf-8', errors='ignore').decode('utf-8')
-            display_text = clean_text[:50] + "..." if len(clean_text) > 50 else clean_text
-        else:
-            status = "✗"
-            display_text = "Empty or invalid response"
-
-        print(f"{test_api.model:<30} {status:<10} {display_text}")
-    except Exception as e:
-        print(f"{Writecream.AVAILABLE_MODELS[0]:<30} {'✗':<10} {str(e)}")

webscout/auth/static/favicon.svg

@@ -1,11 +0,0 @@
-/* Custom Swagger UI Favicon - SVG format */
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32">
-  <defs>
-    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="100%">
-      <stop offset="0%" style="stop-color:#6366f1;stop-opacity:1" />
-      <stop offset="100%" style="stop-color:#8b5cf6;stop-opacity:1" />
-    </linearGradient>
-  </defs>
-  <rect width="32" height="32" rx="8" fill="url(#grad1)"/>
-  <path d="M8 12h16M8 16h12M8 20h8" stroke="white" stroke-width="2" stroke-linecap="round"/>
-</svg>

webscout/auth/swagger_ui.py

@@ -1,203 +0,0 @@
-"""
-Custom Swagger UI implementation for Webscout FastAPI server.
-Provides a modern, beautiful, and fully functional API documentation interface.
-"""
-
-import os
-import logging
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
-from jinja2 import Environment, FileSystemLoader, TemplateNotFound
-
-class CustomSwaggerUI:
-    """Custom Swagger UI handler for FastAPI applications."""
-
-    def __init__(self, app: FastAPI):
-        self.app = app
-        self.template_dir = os.path.join(os.path.dirname(__file__), "templates")
-        self.static_dir = os.path.join(os.path.dirname(__file__), "static")
-        self.template_static_dir = os.path.join(self.template_dir, "static")
-
-        # Initialize Jinja2 environment
-        self.jinja_env = Environment(
-            loader=FileSystemLoader(self.template_dir),
-            autoescape=True
-        )
-
-        # Mount static files - prioritize template static files
-        static_mounted = False
-
-        # First try to mount template static files (higher priority)
-        if os.path.exists(self.template_static_dir):
-            try:
-                app.mount("/static", StaticFiles(directory=self.template_static_dir), name="template_static")
-                static_mounted = True
-                logging.info(f"Mounted template static files from: {self.template_static_dir}")
-            except Exception as e:
-                logging.warning(f"Failed to mount template static files: {e}")
-
-        # Fallback to regular static directory if template static not available
-        if not static_mounted and os.path.exists(self.static_dir):
-            try:
-                app.mount("/static", StaticFiles(directory=self.static_dir), name="static")
-                logging.info(f"Mounted static files from: {self.static_dir}")
-            except Exception as e:
-                logging.warning(f"Failed to mount static files: {e}")
-
-        # Log static file status
-        if not static_mounted:
-            logging.warning("No static files mounted - CSS and JS may not load correctly")
-
-        self._setup_routes()
-    
-    def _setup_routes(self):
-        """Setup custom Swagger UI routes."""
-        
-        @self.app.get("/docs", response_class=HTMLResponse, include_in_schema=False)
-        async def custom_swagger_ui(request: Request):
-            """Serve the custom Swagger UI."""
-            return await self._render_swagger_ui(request)
-        
-        @self.app.get("/swagger-ui", response_class=HTMLResponse, include_in_schema=False)
-        async def custom_swagger_ui_alt(request: Request):
-            """Alternative endpoint for custom Swagger UI."""
-            return await self._render_swagger_ui(request)
-    
-    async def _render_swagger_ui(self, request: Request) -> HTMLResponse:
-        """Render the custom Swagger UI template."""
-        try:
-            # Get app metadata
-            title = getattr(self.app, 'title', 'Webscout OpenAI API')
-            description = getattr(self.app, 'description', 'OpenAI API compatible interface')
-            version = getattr(self.app, 'version', '0.2.0')
-
-            # Get base URL
-            base_url = str(request.base_url).rstrip('/')
-
-            # Load and count models
-            model_count = await self._get_model_count()
-            provider_count = await self._get_provider_count()
-
-            # Load the main template using Jinja2 environment
-            template = self.jinja_env.get_template("swagger_ui.html")
-
-            # Render with context
-            rendered_html = template.render(
-                title=title,
-                description=description,
-                version=version,
-                base_url=base_url,
-                model_count=model_count,
-                provider_count=provider_count
-            )
-
-            return HTMLResponse(content=rendered_html, status_code=200)
-
-        except TemplateNotFound:
-            # Template file doesn't exist, use fallback
-            logging.warning("Template file 'swagger_ui.html' not found, using fallback HTML")
-            return HTMLResponse(content=self._get_fallback_html(), status_code=200)
-
-        except Exception as e:
-            # Other errors, log and use fallback
-            logging.error(f"Error rendering Swagger UI template: {e}")
-            return HTMLResponse(content=self._get_fallback_html(), status_code=200)
-    
-    async def _get_model_count(self) -> int:
-        """Get the number of available models."""
-        try:
-            # Try to get from auth config
-            from .config import AppConfig
-            if hasattr(AppConfig, 'provider_map') and AppConfig.provider_map:
-                # Count models (keys with "/" are model names)
-                model_count = len([model for model in AppConfig.provider_map.keys() if "/" in model])
-                return model_count if model_count > 0 else 589
-            return 589  # Default fallback
-        except Exception as e:
-            logging.debug(f"Could not get model count: {e}")
-            return 589
-
-    async def _get_provider_count(self) -> int:
-        """Get the number of available providers."""
-        try:
-            # Try to get from auth config
-            from .config import AppConfig
-            if hasattr(AppConfig, 'provider_map') and AppConfig.provider_map:
-                # Count unique providers
-                providers = set()
-                for model_key in AppConfig.provider_map.keys():
-                    if "/" in model_key:
-                        provider_name = model_key.split("/")[0]
-                        providers.add(provider_name)
-                return len(providers) if len(providers) > 0 else 42
-            return 42  # Default fallback
-        except Exception as e:
-            logging.debug(f"Could not get provider count: {e}")
-            return 42
-    
-    def _get_fallback_html(self) -> str:
-        """Fallback HTML if template loading fails."""
-        return """
-        <!DOCTYPE html>
-        <html lang="en">
-        <head>
-            <meta charset="UTF-8">
-            <meta name="viewport" content="width=device-width, initial-scale=1.0">
-            <title>Webscout API Documentation</title>
-            <style>
-                body {
-                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-                    color: white;
-                    margin: 0;
-                    padding: 2rem;
-                    min-height: 100vh;
-                    display: flex;
-                    align-items: center;
-                    justify-content: center;
-                    flex-direction: column;
-                }
-                .container {
-                    text-align: center;
-                    background: rgba(255, 255, 255, 0.1);
-                    backdrop-filter: blur(10px);
-                    padding: 3rem;
-                    border-radius: 1rem;
-                    border: 1px solid rgba(255, 255, 255, 0.2);
-                }
-                h1 { font-size: 3rem; margin-bottom: 1rem; }
-                p { font-size: 1.2rem; margin-bottom: 2rem; opacity: 0.9; }
-                .btn {
-                    background: rgba(255, 255, 255, 0.2);
-                    color: white;
-                    border: 1px solid rgba(255, 255, 255, 0.3);
-                    padding: 1rem 2rem;
-                    border-radius: 0.5rem;
-                    text-decoration: none;
-                    font-weight: 600;
-                    transition: all 0.3s ease;
-                    display: inline-block;
-                    margin: 0.5rem;
-                }
-                .btn:hover {
-                    background: rgba(255, 255, 255, 0.3);
-                    transform: translateY(-2px);
-                }
-            </style>
-        </head>
-        <body>
-            <div class="container">
-                <h1>🚀 Webscout API</h1>
-                <p>OpenAI-Compatible API Documentation</p>
-                <a href="/redoc" class="btn">📖 ReDoc Documentation</a>
-                <a href="/openapi.json" class="btn">📋 OpenAPI Schema</a>
-            </div>
-        </body>
-        </html>
-        """
-
-
-def setup_custom_swagger_ui(app: FastAPI) -> CustomSwaggerUI:
-    """Setup custom Swagger UI for the FastAPI app."""
-    return CustomSwaggerUI(app)