webscout 8.2.6__py3-none-any.whl → 8.2.8__py3-none-any.whl

webscout/Provider/OPENAI/uncovrAI.py

@@ -453,3 +453,10 @@ class UncovrAI(OpenAICompatibleProvider):
             # If any error occurs, return the original text
             print(f"{RED}Warning: Error formatting text: {e}{RESET}")
             return text
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()

webscout/Provider/OPENAI/utils.py

@@ -1,6 +1,8 @@
-from typing import List, Dict, Optional, Any, Union
-from dataclasses import dataclass, asdict, is_dataclass
+from typing import List, Dict, Optional, Any, Union, Literal
+from dataclasses import dataclass, asdict, is_dataclass, field
 from enum import Enum
+import time
+import uuid
 
 # --- OpenAI Response Structure Mimics ---
 # Moved here for reusability across different OpenAI-compatible providers
@@ -95,13 +97,107 @@ class Choice(BaseModel):
     finish_reason: Optional[str] = None
     logprobs: Optional[Dict[str, Any]] = None
 
+@dataclass
+class ModelData(BaseModel):
+    """OpenAI model info response."""
+    id: str
+    object: str = "model"
+    created: int = int(time.time())
+    owned_by: str = "webscout"
+    permission: Optional[List[Dict[str, Any]]] = None
+    root: Optional[str] = None
+    parent: Optional[str] = None
+
+@dataclass
+class ModelList(BaseModel):
+    """OpenAI model list response."""
+    data: List[ModelData] # Moved before 'object'
+    object: str = "list"
+
+
+# @dataclass
+# class EmbeddingData(BaseModel):
+#     """Single embedding data."""
+#     embedding: List[float]
+#     index: int
+#     object: str = "embedding"
+
+# @dataclass
+# class EmbeddingResponse(BaseModel):
+#     """OpenAI embeddings response."""
+#     data: List[EmbeddingData]
+#     model: str
+#     usage: CompletionUsage
+#     object: str = "list"
+
+# @dataclass
+# class FineTuningJob(BaseModel):
+#     """OpenAI fine-tuning job."""
+#     id: str
+#     model: str
+#     created_at: int
+#     status: str
+#     training_file: str
+#     hyperparameters: Dict[str, Any]
+#     object: str = "fine_tuning.job"
+#     finished_at: Optional[int] = None
+#     validation_file: Optional[str] = None
+#     trained_tokens: Optional[int] = None
+#     result_files: Optional[List[str]] = None
+#     organization_id: Optional[str] = None
+
+# @dataclass
+# class FineTuningJobList(BaseModel):
+#     """OpenAI fine-tuning job list response."""
+#     data: List[FineTuningJob]
+#     object: str = "list"
+#     has_more: bool = False
+
+# @dataclass
+# class File(BaseModel):
+#     """OpenAI file."""
+#     id: str
+#     bytes: int
+#     created_at: int
+#     filename: str
+#     purpose: str
+#     object: str = "file"
+#     status: str = "uploaded"
+#     status_details: Optional[str] = None
+
+# @dataclass
+# class FileList(BaseModel):
+#     """OpenAI file list response."""
+#     data: List[File]
+#     object: str = "list"
+
+# @dataclass
+# class DeletedObject(BaseModel):
+#     """OpenAI deleted object response."""
+#     id: str
+#     object: str = "deleted_object"
+#     deleted: bool = True
+
+# @dataclass
+# class ImageData(BaseModel):
+#     """OpenAI generated image."""
+#     url: Optional[str] = None
+#     b64_json: Optional[str] = None
+#     revised_prompt: Optional[str] = None
+
+# @dataclass
+# class ImageResponse(BaseModel):
+#     """OpenAI image generation response."""
+#     data: List[ImageData]
+#     created: int = int(time.time())
+
 @dataclass
 class ChatCompletion(BaseModel):
     """Chat completion response."""
-    id: str
-    created: int
     model: str
     choices: List[Choice]
+    id: str = field(default_factory=lambda: f"chatcmpl-{str(uuid.uuid4())}")
+    created: int = field(default_factory=lambda: int(time.time()))
     object: str = "chat.completion"
     system_fingerprint: Optional[str] = None
     usage: Optional[CompletionUsage] = None
@@ -109,10 +205,10 @@ class ChatCompletion(BaseModel):
 @dataclass
 class ChatCompletionChunk(BaseModel):
     """Streaming chat completion response chunk."""
-    id: str
-    created: int
     model: str
     choices: List[Choice]
+    id: str = field(default_factory=lambda: f"chatcmpl-{str(uuid.uuid4())}")
+    created: int = field(default_factory=lambda: int(time.time()))
     object: str = "chat.completion.chunk"
     system_fingerprint: Optional[str] = None
 
@@ -120,7 +216,7 @@ class ChatCompletionChunk(BaseModel):
 # --- Helper Functions ---
 
 def format_prompt(messages: List[Dict[str, Any]], add_special_tokens: bool = False,
-                do_continue: bool = False, include_system: bool = True) -> str:
+                 do_continue: bool = False, include_system: bool = True) -> str:
     """
     Format a series of messages into a single string, optionally adding special tokens.
 

webscout/Provider/OPENAI/venice.py

@@ -411,3 +411,15 @@ class Venice(OpenAICompatibleProvider):
         # Default to the most capable model
         print(f"Warning: Unknown model '{model}'. Using 'mistral-31-24b' instead.")
         return "mistral-31-24b"
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
+
+    @classmethod
+    def models(cls):
+        """Return the list of available models for Venice."""
+        return cls.AVAILABLE_MODELS

webscout/Provider/OPENAI/wisecat.py

@@ -288,13 +288,11 @@ class WiseCat(OpenAICompatibleProvider):
         )
     """
 
-    AVAILABLE_MODELS = [
-        "chat-model-small",
-        "chat-model-large",
-        "chat-model-reasoning",
-    ]
-
-    # No model mapping needed as we use the model names directly
+    _base_models = ["chat-model-small", "chat-model-large", "chat-model-reasoning"]
+    # Create AVAILABLE_MODELS as a list with the format "WiseCat/model"
+    AVAILABLE_MODELS = [f"WiseCat/{model}" for model in _base_models]
+    # Create a mapping dictionary for internal use
+    _model_mapping = {model: f"WiseCat/{model}" for model in _base_models}
 
     def __init__(
         self,
@@ -364,18 +362,20 @@ class WiseCat(OpenAICompatibleProvider):
 
     def convert_model_name(self, model: str) -> str:
         """
-        Convert model names to ones supported by WiseCat.
-
-        Args:
-            model: Model name to convert
-
-        Returns:
-            WiseCat model name
+        Convert model names to ones supported by WiseCat. Accepts both 'WiseCat/model' and raw model names.
         """
-        # If the model is already a valid WiseCat model, return it
-        if model in self.AVAILABLE_MODELS:
-            return model
-
-        # Default to the most capable model
+        if model.startswith("WiseCat/"):
+            model_raw = model.replace("WiseCat/", "", 1)
+        else:
+            model_raw = model
+        if f"WiseCat/{model_raw}" in self.AVAILABLE_MODELS:
+            return model_raw
         print(f"Warning: Unknown model '{model}'. Using 'chat-model-large' instead.")
         return "chat-model-large"
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return WiseCat.AVAILABLE_MODELS
+        return _ModelList()

webscout/Provider/OPENAI/writecream.py

@@ -144,6 +144,13 @@ class Writecream(OpenAICompatibleProvider):
     def convert_model_name(self, model: str) -> str:
         return "writecream"
 
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return Writecream.AVAILABLE_MODELS
+        return _ModelList()
+
 # Simple test if run directly
 if __name__ == "__main__":
     client = Writecream()

webscout/Provider/OPENAI/x0gpt.py

@@ -319,6 +319,13 @@ class X0GPT(OpenAICompatibleProvider):
         # Initialize the chat interface
         self.chat = Chat(self)
 
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return X0GPT.AVAILABLE_MODELS
+        return _ModelList()
+
     def format_text(self, text: str) -> str:
         """
         Format text by replacing escaped newlines with actual newlines.

webscout/Provider/OPENAI/yep.py

@@ -56,7 +56,13 @@ class Completions(BaseCompletions):
         Mimics openai.chat.completions.create
         Note: YEPCHAT does not support system messages. They will be ignored.
         """
-        if model not in self._client.AVAILABLE_MODELS:
+        # Accept both raw and prefixed model names from the user, but always send the raw name to the API
+        if model.startswith("YEPCHAT/"):
+            model_raw = model.replace("YEPCHAT/", "", 1)
+        else:
+            model_raw = model
+        # Validate model
+        if f"YEPCHAT/{model_raw}" not in self._client.AVAILABLE_MODELS:
             raise ValueError(
                 f"Invalid model: {model}. Choose from: {self._client.AVAILABLE_MODELS}"
             )
@@ -86,7 +92,7 @@ class Completions(BaseCompletions):
             "top_p": top_p,
             "temperature": temperature,
             "messages": filtered_messages,  # Use filtered messages
-            "model": model,
+            "model": model_raw,  # Send only the raw model name to the API
         }
 
         # Add any extra kwargs to the payload
@@ -104,7 +110,6 @@ class Completions(BaseCompletions):
         self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
-            # Use session.post from cloudscraper instance
             response = self._client.session.post(
                 self._client.api_endpoint,
                 headers=self._client.headers,
@@ -115,7 +120,6 @@ class Completions(BaseCompletions):
             )
 
             if not response.ok:
-                # Simplified error handling for now, add refresh logic if needed
                 raise IOError(
                     f"YEPCHAT API Error: {response.status_code} {response.reason} - {response.text}"
                 )
@@ -133,9 +137,10 @@ class Completions(BaseCompletions):
                             delta_data = choice_data.get('delta', {})
                             finish_reason = choice_data.get('finish_reason')
                             content = delta_data.get('content')
+                            role = delta_data.get('role', None)
 
-                            if content is not None:  # Only yield chunks with content
-                                delta = ChoiceDelta(content=content, role=delta_data.get('role', 'assistant'))
+                            if content is not None or role is not None:
+                                delta = ChoiceDelta(content=content, role=role)
                                 choice = Choice(index=0, delta=delta, finish_reason=finish_reason)
                                 chunk = ChatCompletionChunk(
                                     id=request_id,
@@ -151,7 +156,7 @@ class Completions(BaseCompletions):
 
             # Yield final chunk with finish reason if not already sent
             delta = ChoiceDelta()
-            choice = Choice(index=0, delta=delta, finish_reason="stop")  # Assume stop if loop finishes
+            choice = Choice(index=0, delta=delta, finish_reason="stop")
             chunk = ChatCompletionChunk(
                 id=request_id,
                 choices=[choice],
@@ -167,21 +172,34 @@ class Completions(BaseCompletions):
         self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
     ) -> ChatCompletion:
         full_response_content = ""
-        finish_reason = "stop"  # Assume stop unless error occurs
-
+        finish_reason = "stop"
         try:
-            stream_generator = self._create_stream(request_id, created_time, model, payload)
-            for chunk in stream_generator:
-                if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content:
-                    full_response_content += chunk.choices[0].delta.content
-                if chunk.choices and chunk.choices[0].finish_reason:
-                    finish_reason = chunk.choices[0].finish_reason  # Capture finish reason if provided
-
-        except IOError as e:
+            # Make a non-streaming request to the API
+            payload_copy = payload.copy()
+            payload_copy["stream"] = False
+            response = self._client.session.post(
+                self._client.api_endpoint,
+                headers=self._client.headers,
+                cookies=self._client.cookies,
+                json=payload_copy,
+                timeout=self._client.timeout
+            )
+            if not response.ok:
+                raise IOError(
+                    f"YEPCHAT API Error: {response.status_code} {response.reason} - {response.text}"
+                )
+            data = response.json()
+            if 'choices' in data and len(data['choices']) > 0:
+                # YEPCHAT non-streaming returns message content in choices[0]['message']['content']
+                full_response_content = data['choices'][0].get('message', {}).get('content', '')
+                finish_reason = data['choices'][0].get('finish_reason', 'stop')
+            else:
+                full_response_content = ''
+                finish_reason = 'stop'
+        except Exception as e:
             print(f"Error obtaining non-stream response from YEPCHAT: {e}")
             finish_reason = "error"
 
-        # Construct the final ChatCompletion object
         message = ChatCompletionMessage(
             role="assistant",
             content=full_response_content
@@ -191,9 +209,7 @@ class Completions(BaseCompletions):
             message=message,
             finish_reason=finish_reason
         )
-        # Usage data is not provided by this API in a standard way, set to 0
         usage = CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0)
-
         completion = ChatCompletion(
             id=request_id,
             choices=[choice],
@@ -219,7 +235,13 @@ class YEPCHAT(OpenAICompatibleProvider):
         )
         print(response.choices[0].message.content)
     """
-    AVAILABLE_MODELS = ["DeepSeek-R1-Distill-Qwen-32B", "Mixtral-8x7B-Instruct-v0.1"]
+    _base_models = ["DeepSeek-R1-Distill-Qwen-32B", "Mixtral-8x7B-Instruct-v0.1"]
+
+    # Create AVAILABLE_MODELS as a list with the format "YEPCHAT/model"
+    AVAILABLE_MODELS = [f"YEPCHAT/{model}" for model in _base_models]
+
+    # Create a mapping dictionary for internal use
+    _model_mapping = {model: f"YEPCHAT/{model}" for model in _base_models}
 
     def __init__(
         self,
@@ -274,6 +296,13 @@ class YEPCHAT(OpenAICompatibleProvider):
         # Initialize the chat interface
         self.chat = Chat(self)
 
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return YEPCHAT.AVAILABLE_MODELS
+        return _ModelList()
+
     def convert_model_name(self, model: str) -> str:
         """
         Ensures the model name is valid for YEPCHAT.

webscout/Provider/OpenGPT.py

@@ -184,7 +184,7 @@ class OpenGPT(Provider):
         # If stream=True was requested, simulate streaming by yielding the full message at once
         if stream:
             def stream_wrapper():
-                yield self.get_message(response_data)
+                yield self.get_message(response_data)  # yield only the text string
             return stream_wrapper()
         else:
             # If stream=False, return the full message directly

webscout/Provider/TTI/AiForce/README.md

@@ -0,0 +1,159 @@
+# AiForce Provider 🔥
+
+Yo fam! This is the AiForce provider for generating some fire images! Part of the HelpingAI squad! 👑
+
+## Features 💪
+
+- Both sync and async support ⚡
+- 12 fire models to choose from 🎨
+- Smart retry mechanism 🔄
+- Custom image sizes 📐
+- Save with custom names 💾
+- Fire logging with cyberpunk theme 🌟
+- Proxy support for stealth mode 🕵️‍♂️
+
+## Quick Start 🚀
+
+### Installation 📦
+
+```bash
+pip install webscout
+```
+
+### Basic Usage 💫
+
+```python
+# Sync way
+from webscout import AiForceimager
+
+provider = AiForceimager()
+images = provider.generate("Epic dragon")
+paths = provider.save(images)
+
+# Async way
+from webscout import AsyncAiForceimager
+import asyncio
+
+async def generate():
+    provider = AsyncAiForceimager()
+    images = await provider.generate("Cool art")
+    paths = await provider.save(images)
+
+asyncio.run(generate())
+```
+
+## Available Models 🎭
+
+| Model | Description | Best For |
+|-------|-------------|----------|
+| `Flux-1.1-Pro` | Latest pro model (Default) | High quality general purpose |
+| `stable-diffusion-xl-lightning` | Fast SDXL model | Quick generations |
+| `stable-diffusion-xl-base` | Base SDXL model | High quality base |
+| `ideogram` | Artistic model | Creative artwork |
+| `flux` | Standard model | General purpose |
+| `flux-realism` | Photorealistic model | Realistic images |
+| `flux-anime` | Anime style | Anime/manga art |
+| `flux-3d` | 3D rendering | 3D objects/scenes |
+| `flux-disney` | Disney style | Disney-like art |
+| `flux-pixel` | Pixel art | Retro/game art |
+| `flux-4o` | 4k output | High resolution |
+| `any-dark` | Dark theme | Gothic/dark art |
+
+## Advanced Examples 🔥
+
+### Custom Settings 🛠️
+
+```python
+provider = AiForceimager(
+    timeout=120,  # Longer timeout
+    proxies={
+        'http': 'http://proxy.example.com:8080'
+    }
+)
+```
+
+### Multiple Images with Custom Size 📸
+
+```python
+images = provider.generate(
+    prompt="A shiny red sports car",
+    amount=3,  # Generate 3 images
+    model="flux-realism",  # Use realistic model
+    width=1024,  # Custom width
+    height=768,  # Custom height
+    seed=42  # For reproducible results
+)
+```
+
+### Custom Save Options 💾
+
+```python
+paths = provider.save(
+    images,
+    name="sports_car",  # Custom name
+    dir="my_images",  # Custom directory
+    filenames_prefix="v1_"  # Add prefix
+)
+```
+
+### Async with Error Handling ⚡
+
+```python
+async def generate_safely():
+    provider = AsyncAiForceimager()
+    try:
+        images = await provider.generate(
+            prompt="Epic dragon",
+            model="flux-3d",
+            amount=2
+        )
+        paths = await provider.save(images, dir="dragons")
+        print(f"Saved to: {paths}")
+    except Exception as e:
+        print(f"Oops! Something went wrong: {e}")
+
+asyncio.run(generate_safely())
+```
+
+## Tips & Tricks 💡
+
+1. Use `flux-realism` for photorealistic images
+2. Use `flux-3d` for product renders
+3. Use `flux-anime` for anime style art
+4. Set custom timeouts for large images
+5. Use proxies for better reliability
+6. Add seed for reproducible results
+
+## Error Handling 🛡️
+
+The provider handles common errors:
+
+- Network issues
+- API timeouts
+- Invalid inputs
+- File saving errors
+
+Example with retry:
+
+```python
+provider = AiForceimager()
+try:
+    images = provider.generate(
+        "Epic scene",
+        max_retries=5,  # More retries
+        retry_delay=10  # Longer delay
+    )
+except Exception as e:
+    print(f"Generation failed: {e}")
+```
+
+## Contributing 🤝
+
+Pull up to the squad! We're always looking for improvements:
+
+1. Fork it
+2. Create your feature branch
+3. Push your changes
+4. Hit us with that pull request
+
+Made with 💖 by the HelpingAI Team

webscout/Provider/TTI/FreeAIPlayground/README.md

@@ -0,0 +1,99 @@
+# FreeAI Image Provider 🎨
+
+Generate amazing images with our FreeAI provider! Access to powerful models like DALL-E 3 and Flux series! 🚀
+
+## Features 💫
+- Both sync and async support ⚡
+- 7 powerful models to choose from 🎭
+- Smart retry mechanism 🔄
+- Custom image sizes 📐
+- Save with custom names 💾
+- Fire logging with cyberpunk theme 🌟
+- Proxy support for stealth mode 🕵️‍♂️
+
+## Quick Start 🚀
+
+### Installation 📦
+```bash
+pip install webscout
+```
+
+### Basic Usage 💫
+
+```python
+# Sync way
+from webscout import FreeAIImager
+
+provider = FreeAIImager()
+images = provider.generate("Epic dragon")
+paths = provider.save(images)
+
+# Async way
+from webscout import AsyncFreeAIImager
+import asyncio
+
+async def generate():
+    provider = AsyncFreeAIImager()
+    images = await provider.generate("Cool art")
+    paths = await provider.save(images)
+
+asyncio.run(generate())
+```
+
+## Available Models 🎭
+
+| Model | Description | Best For |
+|-------|-------------|----------|
+| `dall-e-3` | Latest DALL-E model (Default) | High quality general purpose |
+| `Flux Pro Ultra` | Premium Flux model | Professional quality |
+| `Flux Pro` | Standard Pro model | High quality images |
+| `Flux Pro Ultra Raw` | Unprocessed Ultra output | Raw creative control |
+| `Flux Schnell` | Fast generation model | Quick results |
+| `Flux Realism` | Photorealistic model | Realistic images |
+| `grok-2-aurora` | Aurora enhancement | Artistic flair |
+
+## Advanced Usage 🔧
+
+### Custom Settings
+```python
+provider = FreeAIImager(
+    model="Flux Pro Ultra",
+    timeout=120,
+    logging=True
+)
+
+images = provider.generate(
+    prompt="Epic dragon",
+    amount=2,
+    size="1024x1024",
+    quality="hd",
+    style="vivid"
+)
+paths = provider.save(images, dir="dragons")
+```
+
+### Async with Error Handling ⚡
+```python
+async def generate_safely():
+    provider = AsyncFreeAIImager()
+    try:
+        images = await provider.generate(
+            prompt="Epic dragon",
+            model="Flux Pro Ultra",
+            amount=2
+        )
+        paths = await provider.save(images, dir="dragons")
+        print(f"Saved to: {paths}")
+    except Exception as e:
+        print(f"Oops! Something went wrong: {e}")
+
+asyncio.run(generate_safely())
+```
+
+## Tips & Tricks 💡
+
+1. Use `Flux Realism` for photorealistic images
+2. Use `Flux Pro Ultra` for highest quality
+3. Use `Flux Schnell` for quick drafts
+4. Set custom timeouts for large generations
+5. Enable logging for detailed progress updates