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

webscout/Provider/TTI/fastflux.py

@@ -1,233 +0,0 @@
-import requests
-import os
-import tempfile
-import time
-import base64
-from typing import Optional, List, Dict, Any
-from webscout.Provider.TTI.utils import (
-    ImageData,
-    ImageResponse
-)
-from webscout.Provider.TTI.base import TTICompatibleProvider, BaseImages
-from io import BytesIO
-from webscout.litagent import LitAgent
-
-try:
-    from PIL import Image
-except ImportError:
-    Image = None
-
-
-class Images(BaseImages):
-    def __init__(self, client):
-        self._client = client
-
-    def create(
-        self,
-        model: str = "flux_1_schnell",
-        prompt: str = None,
-        n: int = 1,
-        size: str = "1_1",
-        response_format: str = "url",
-        user: Optional[str] = None,
-        style: str = "none",
-        aspect_ratio: str = "1:1",
-        timeout: int = 60,
-        image_format: str = "png",
-        is_public: bool = False,
-        **kwargs,
-    ) -> ImageResponse:
-        if not prompt:
-            raise ValueError("Prompt is required!")
-        agent = LitAgent()
-        images = []
-        urls = []
-        api_url = self._client.api_endpoint
-        payload = {
-            "prompt": prompt,
-            "model": model,
-            "size": size,
-            "isPublic": is_public,
-        }
-        for _ in range(n):
-            resp = self._client.session.post(
-                api_url,
-                json=payload,
-                timeout=timeout,
-            )
-            resp.raise_for_status()
-            result = resp.json()
-            if result and "result" in result:
-                image_data = result["result"]
-                base64_data = image_data.split(",")[1]
-                img_bytes = base64.b64decode(base64_data)
-                # Convert to png or jpeg in memory if needed
-                if Image is not None:
-                    with BytesIO(img_bytes) as input_io:
-                        with Image.open(input_io) as im:
-                            out_io = BytesIO()
-                            if image_format.lower() == "jpeg":
-                                im = im.convert("RGB")
-                                im.save(out_io, format="JPEG")
-                            else:
-                                im.save(out_io, format="PNG")
-                            img_bytes = out_io.getvalue()
-                images.append(img_bytes)
-                if response_format == "url":
-
-                    def upload_file_with_retry(img_bytes, image_format, max_retries=3):
-                        ext = "jpg" if image_format.lower() == "jpeg" else "png"
-                        for attempt in range(max_retries):
-                            tmp_path = None
-                            try:
-                                with tempfile.NamedTemporaryFile(
-                                    suffix=f".{ext}", delete=False
-                                ) as tmp:
-                                    tmp.write(img_bytes)
-                                    tmp.flush()
-                                    tmp_path = tmp.name
-                                with open(tmp_path, "rb") as f:
-                                    files = {
-                                        "fileToUpload": (
-                                            f"image.{ext}",
-                                            f,
-                                            f"image/{ext}",
-                                        )
-                                    }
-                                    data = {"reqtype": "fileupload", "json": "true"}
-                                    headers = {"User-Agent": agent.random()}
-                                    if attempt > 0:
-                                        headers["Connection"] = "close"
-                                    resp = requests.post(
-                                        "https://catbox.moe/user/api.php",
-                                        files=files,
-                                        data=data,
-                                        headers=headers,
-                                        timeout=timeout,
-                                    )
-                                    if resp.status_code == 200 and resp.text.strip():
-                                        text = resp.text.strip()
-                                        if text.startswith("http"):
-                                            return text
-                                        try:
-                                            result = resp.json()
-                                            if "url" in result:
-                                                return result["url"]
-                                        except Exception:
-                                            if "http" in text:
-                                                return text
-                            except Exception:
-                                if attempt < max_retries - 1:
-                                    time.sleep(1 * (attempt + 1))
-                            finally:
-                                if tmp_path and os.path.isfile(tmp_path):
-                                    try:
-                                        os.remove(tmp_path)
-                                    except Exception:
-                                        pass
-                        return None
-
-                    def upload_file_alternative(img_bytes, image_format):
-                        try:
-                            ext = "jpg" if image_format.lower() == "jpeg" else "png"
-                            with tempfile.NamedTemporaryFile(
-                                suffix=f".{ext}", delete=False
-                            ) as tmp:
-                                tmp.write(img_bytes)
-                                tmp.flush()
-                                tmp_path = tmp.name
-                            try:
-                                if not os.path.isfile(tmp_path):
-                                    return None
-                                with open(tmp_path, "rb") as img_file:
-                                    files = {"file": img_file}
-                                    response = requests.post(
-                                        "https://0x0.st", files=files
-                                    )
-                                    response.raise_for_status()
-                                    image_url = response.text.strip()
-                                    if not image_url.startswith("http"):
-                                        return None
-                                    return image_url
-                            except Exception:
-                                return None
-                            finally:
-                                try:
-                                    os.remove(tmp_path)
-                                except Exception:
-                                    pass
-                        except Exception:
-                            return None
-
-                    uploaded_url = upload_file_with_retry(img_bytes, image_format)
-                    if not uploaded_url:
-                        uploaded_url = upload_file_alternative(img_bytes, image_format)
-                    if uploaded_url:
-                        urls.append(uploaded_url)
-                    else:
-                        raise RuntimeError(
-                            "Failed to upload image to catbox.moe using all available methods"
-                        )
-            else:
-                raise RuntimeError("No image data received from FastFlux API")
-        result_data = []
-        if response_format == "url":
-            for url in urls:
-                result_data.append(ImageData(url=url))
-        elif response_format == "b64_json":
-            import base64
-
-            for img in images:
-                b64 = base64.b64encode(img).decode("utf-8")
-                result_data.append(ImageData(b64_json=b64))
-        else:
-            raise ValueError("response_format must be 'url' or 'b64_json'")
-        from time import time as _time
-
-        return ImageResponse(created=int(_time()), data=result_data)
-
-
-class FastFluxAI(TTICompatibleProvider):
-    AVAILABLE_MODELS = [
-        "flux_1_schnell",
-    ]
-
-    def __init__(self, api_key: str = None):
-        self.api_endpoint = "https://api.freeflux.ai/v1/images/generate"
-        self.session = requests.Session()
-        self.user_agent = LitAgent().random()
-        self.api_key = api_key
-        self.headers = {
-            "accept": "application/json, text/plain, */*",
-            "accept-language": "en-US,en;q=0.9",
-            "content-type": "application/json",
-            "origin": "https://freeflux.ai",
-            "referer": "https://freeflux.ai/",
-            "user-agent": self.user_agent,
-        }
-        if self.api_key:
-            self.headers["authorization"] = f"Bearer {self.api_key}"
-        self.session.headers.update(self.headers)
-        self.images = Images(self)
-
-    @property
-    def models(self):
-        class _ModelList:
-            def list(inner_self):
-                return type(self).AVAILABLE_MODELS
-
-        return _ModelList()
-
-
-if __name__ == "__main__":
-    from rich import print
-
-    client = FastFluxAI()
-    response = client.images.create(
-        model="flux_1_schnell",
-        prompt="A cool cyberpunk city at night",
-        response_format="url",
-        n=2,
-        timeout=30,
-    )
-    print(response)

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)}")