webscout 2025.10.15__py3-none-any.whl → 2025.10.17__py3-none-any.whl

webscout/Provider/TTI/claudeonline.py

@@ -0,0 +1,315 @@
+import base64
+import json
+import os
+import tempfile
+import time
+from io import BytesIO
+from typing import Optional
+
+import requests
+from requests.exceptions import RequestException
+
+from webscout.litagent import LitAgent
+from webscout.Provider.TTI.base import BaseImages, TTICompatibleProvider
+from webscout.Provider.TTI.utils import ImageData, ImageResponse
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
+
+class Images(BaseImages):
+    def __init__(self, client):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        prompt: str,
+        n: int = 1,
+        size: str = "1024x1024",
+        response_format: str = "url",
+        user: Optional[str] = None,
+        style: str = "none",
+        aspect_ratio: str = "1:1",
+        timeout: int = 60,
+        image_format: str = "png",
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> ImageResponse:
+        """
+        Generate images using Claude Online's /imagine feature via Pollinations.ai.
+
+        Args:
+            model: Model to use (ignored, uses Pollinations.ai)
+            prompt: The image generation prompt
+            n: Number of images to generate (max 1 for Claude Online)
+            size: Image size (supports various sizes)
+            response_format: "url" or "b64_json"
+            timeout: Request timeout in seconds
+            image_format: Output format "png" or "jpeg"
+            **kwargs: Additional parameters
+
+        Returns:
+            ImageResponse with generated image data
+        """
+        if Image is None:
+            raise ImportError("Pillow (PIL) is required for image format conversion.")
+
+        # Claude Online only supports 1 image per request
+        if n > 1:
+            raise ValueError("Claude Online only supports generating 1 image per request")
+
+        # Parse size parameter
+        width, height = self._parse_size(size)
+
+        try:
+            # Clean the prompt (remove command words if present)
+            clean_prompt = self._clean_prompt(prompt)
+
+            # Generate image using Pollinations.ai API
+            timestamp = int(time.time() * 1000)  # Use timestamp as seed for uniqueness
+            seed_value = seed if seed is not None else timestamp
+
+            # Build the Pollinations.ai URL
+            base_url = "https://image.pollinations.ai/prompt"
+            params = {
+                "width": width,
+                "height": height,
+                "nologo": "true",
+                "seed": seed_value
+            }
+
+            image_url = f"{base_url}/{clean_prompt}"
+            query_params = "&".join([f"{k}={v}" for k, v in params.items()])
+            full_image_url = f"{image_url}?{query_params}"
+
+            # Download the image
+            response = requests.get(full_image_url, timeout=timeout, stream=True)
+            response.raise_for_status()
+
+            img_bytes = response.content
+
+            # Convert image format if needed
+            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")
+                    processed_img_bytes = out_io.getvalue()
+
+            # Handle response format
+            if response_format == "url":
+                # Upload to image hosting service
+                uploaded_url = self._upload_image(processed_img_bytes, image_format)
+                if not uploaded_url:
+                    raise RuntimeError("Failed to upload generated image")
+                result_data = [ImageData(url=uploaded_url)]
+            elif response_format == "b64_json":
+                b64 = base64.b64encode(processed_img_bytes).decode("utf-8")
+                result_data = [ImageData(b64_json=b64)]
+            else:
+                raise ValueError("response_format must be 'url' or 'b64_json'")
+
+            return ImageResponse(created=int(time.time()), data=result_data)
+
+        except RequestException as e:
+            raise RuntimeError(f"Failed to generate image with Claude Online: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Unexpected error during image generation: {e}")
+
+    def _parse_size(self, size: str) -> tuple[int, int]:
+        """Parse size string into width and height."""
+        size = size.lower().strip()
+
+        # Handle common size formats
+        size_map = {
+            "256x256": (256, 256),
+            "512x512": (512, 512),
+            "1024x1024": (1024, 1024),
+            "1024x768": (1024, 768),
+            "768x1024": (768, 1024),
+            "1280x720": (1280, 720),
+            "720x1280": (720, 1280),
+            "1920x1080": (1920, 1080),
+            "1080x1920": (1080, 1920),
+        }
+
+        if size in size_map:
+            return size_map[size]
+
+        # Try to parse custom size (e.g., "800x600")
+        try:
+            width, height = size.split("x")
+            return int(width), int(height)
+        except (ValueError, AttributeError):
+            # Default to 1024x1024
+            return 1024, 1024
+
+    def _clean_prompt(self, prompt: str) -> str:
+        """Clean the prompt by removing command prefixes."""
+        # Remove common image generation command prefixes
+        prefixes_to_remove = [
+            r'^/imagine\s*',
+            r'^/image\s*',
+            r'^/picture\s*',
+            r'^/draw\s*',
+            r'^/create\s*',
+            r'^/generate\s*',
+            r'^создай изображение\s*',
+            r'^нарисуй\s*',
+            r'^сгенерируй картинку\s*',
+        ]
+
+        import re
+        clean_prompt = prompt
+        for prefix in prefixes_to_remove:
+            clean_prompt = re.sub(prefix, '', clean_prompt, flags=re.IGNORECASE)
+
+        return clean_prompt.strip()
+
+    def _upload_image(self, img_bytes: bytes, image_format: str, max_retries: int = 3) -> Optional[str]:
+        """Upload image to hosting service and return URL"""
+
+        def upload_to_catbox(img_bytes, image_format):
+            """Upload to catbox.moe"""
+            ext = "jpg" if image_format.lower() == "jpeg" else "png"
+            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": LitAgent().random()}
+
+                    resp = requests.post(
+                        "https://catbox.moe/user/api.php",
+                        files=files,
+                        data=data,
+                        headers=headers,
+                        timeout=30,
+                    )
+
+                    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 json.JSONDecodeError:
+                            pass
+            except Exception:
+                pass
+            finally:
+                if tmp_path and os.path.isfile(tmp_path):
+                    try:
+                        os.remove(tmp_path)
+                    except Exception:
+                        pass
+            return None
+
+        def upload_to_0x0(img_bytes, image_format):
+            """Upload to 0x0.st as fallback"""
+            ext = "jpg" if image_format.lower() == "jpeg" else "png"
+            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 img_file:
+                    files = {"file": img_file}
+                    response = requests.post("https://0x0.st", files=files, timeout=30)
+                    response.raise_for_status()
+                    image_url = response.text.strip()
+                    if image_url.startswith("http"):
+                        return image_url
+            except Exception:
+                pass
+            finally:
+                if tmp_path and os.path.isfile(tmp_path):
+                    try:
+                        os.remove(tmp_path)
+                    except Exception:
+                        pass
+            return None
+
+        # Try primary upload method
+        for attempt in range(max_retries):
+            uploaded_url = upload_to_catbox(img_bytes, image_format)
+            if uploaded_url:
+                return uploaded_url
+            time.sleep(1 * (attempt + 1))
+
+        # Try fallback method
+        for attempt in range(max_retries):
+            uploaded_url = upload_to_0x0(img_bytes, image_format)
+            if uploaded_url:
+                return uploaded_url
+            time.sleep(1 * (attempt + 1))
+
+        return None
+
+
+class ClaudeOnlineTTI(TTICompatibleProvider):
+    """
+    Claude Online Text-to-Image Provider
+
+    Uses Claude Online's /imagine feature with Pollinations.ai backend.
+    Supports high-quality image generation with various styles and sizes.
+    """
+
+    AVAILABLE_MODELS = ["claude-imagine"]
+
+    def __init__(self):
+        self.api_endpoint = "https://image.pollinations.ai/prompt"
+        self.session = requests.Session()
+        self.user_agent = LitAgent().random()
+        self.headers = {
+            "accept": "image/*",
+            "accept-language": "en-US,en;q=0.9",
+            "user-agent": self.user_agent,
+        }
+        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
+
+    # Test the Claude Online TTI provider
+    client = ClaudeOnlineTTI()
+
+    try:
+        response = client.images.create(
+            model="claude-imagine",
+            prompt="a beautiful sunset over mountains with vibrant colors",
+            response_format="url",
+            timeout=60,
+        )
+        print("✅ Image generation successful!")
+        print(response)
+    except Exception as e:
+        print(f"❌ Image generation failed: {e}")
+        import traceback
+        traceback.print_exc()

webscout/__init__.py

@@ -1,6 +1,6 @@
 # webscout/__init__.py
 
-from .search import DuckDuckGoSearch, YepSearch, BingSearch
+from .search import *
 from .version import __version__
 from .Provider import *
 from .Provider.TTI import *

webscout/client.py

@@ -34,20 +34,19 @@ from webscout.Provider.OPENAI import *
 try:
     # Use lazy import to avoid module execution issues
     def run_api(*args, **kwargs):
-        """Run the Webscout OpenAI-compatible API server (FastAPI backend)."""
-        from webscout.auth.server import run_api as _run_api
+        from webscout.server.server import run_api as _run_api
         return _run_api(*args, **kwargs)
     
     def start_server(**kwargs):
         """Start the Webscout OpenAI-compatible API server (FastAPI backend)."""
-        from webscout.auth.server import run_api as _run_api
+        from webscout.server.server import run_api as _run_api
         return _run_api(**kwargs)
 except ImportError:
     # Fallback for environments where the backend is not available
     def run_api(*args, **kwargs):
-        raise ImportError("webscout.auth.server.run_api is not available in this environment.")
+        raise ImportError("webscout.server.server.run_api is not available in this environment.")
     def start_server(*args, **kwargs):
-        raise ImportError("webscout.auth.server.start_server is not available in this environment.")
+        raise ImportError("webscout.server.server.start_server is not available in this environment.")
 
 # ---
 # API Documentation

webscout/litprinter/__init__.py

@@ -1,45 +1,3 @@
-"""
->>> from litprinter import litprint
->>> from litprinter import lit
->>> from litprinter import install, uninstall
->>>
->>> litprint("Hello, world!")
-LIT -> [__main__.py:1] in () >>> Hello, world!
->>>
->>> def my_function():
-...    lit(1, 2, 3)
->>> my_function()
-LIT -> [__main__.py:4] in my_function() >>> 1, 2, 3
->>> install()
->>> ic("This is now the builtins.ic()")
-LIT -> [__main__.py:7] in () >>> This is now the builtins.ic()
->>> uninstall()
-
-This module provides enhanced print and logging functionalities for Python,
-allowing developers to debug their code with style and precision. It
-includes the litprint and lit functions for debugging, log for logging, and
-install/uninstall functions for integration into the builtins module.
-It also handles colorizing output and provides different styles and customizable
-options.
-
-LITPRINTER is inspired by the icecream package and provides similar functionality
-with additional features:
-- Variable inspection with expression display
-- Return value handling for inline usage
-- Support for custom formatters for specific data types
-- Execution context tracking
-- Rich-like colorized output with multiple themes (JARVIS, RICH, MODERN, NEON, CYBERPUNK)
-- Better JSON formatting with indent=2 by default
-- Advanced pretty printing for complex data structures with smart truncation
-- Clickable file paths in supported terminals and editors (VSCode compatible)
-- Enhanced visual formatting with better spacing and separators
-- Special formatters for common types (Exception, bytes, set, frozenset, etc.)
-- Smart object introspection for custom classes
-- Logging capabilities with timestamp and log levels
-"""
-
-# Try to import from the standalone litprinter package first
-# If it's not installed
 try:
     import litprinter
     # If standalone package is found, re-export all its components

webscout/scout/README.md

@@ -43,7 +43,7 @@ pip install webscout
 Or install the latest version from GitHub:
 
 ```bash
-pip install git+https://github.com/OEvortex/Webscout.git
+pip install git+https://github.com/pyscout/Webscout.git
 ```
 
 ## 🚀 Quick Start
@@ -147,10 +147,57 @@ Scout provides powerful tools for navigating and manipulating HTML/XML documents
 - **Document Manipulation**: Modify, replace, or remove elements
 - **Dynamic Building**: Easily append or insert new nodes
 
+#### CSS Selector Support
+
+Scout includes a comprehensive CSS selector engine that supports all common selector types:
+
 ```python
-# CSS selector support
-elements = scout.select('div.content > p')
+# Tag selectors
+paragraphs = scout.select('p')
+divs = scout.select('div')
+
+# Class selectors
+items = scout.select('.item')              # Single class
+cards = scout.select('div.card')           # Tag + class
+special = scout.select('.card.special')    # Multiple classes
+
+# ID selectors
+header = scout.select_one('#header')       # Single element by ID
+menu = scout.select('nav#main-menu')       # Tag + ID
+
+# Attribute selectors
+links = scout.select('a[href]')                    # Has attribute
+external = scout.select('a[rel="nofollow"]')       # Attribute value
+images = scout.select('img[alt]')                  # Has alt attribute
+
+# Descendant selectors (space)
+nested = scout.select('div p')                     # Any p inside div
+deep = scout.select('article section p')           # Deeply nested
+
+# Child selectors (>)
+direct = scout.select('ul > li')                   # Direct children only
+menu_items = scout.select('nav#menu > ul > li')    # Multiple levels
+
+# Combined selectors
+complex = scout.select('div.container > p.text[lang="en"]')
+links = scout.select('ol#results > li.item a[href]')
+
+# Get first match only
+first = scout.select_one('p.intro')
+```
 
+**Supported Selector Types:**
+- **Tag**: `p`, `div`, `a`
+- **Class**: `.class`, `div.class`, `.class1.class2`
+- **ID**: `#id`, `div#id`
+- **Attribute**: `[attr]`, `[attr="value"]`
+- **Descendant**: `div p`, `article section p`
+- **Child**: `div > p`, `ul > li`
+- **Combined**: `p.class#id[attr="value"]`
+
+#### Element Navigation
+
+```python
 # Advanced find with attribute matching
 results = scout.find_all('a', attrs={'class': 'external', 'rel': 'nofollow'})
 
@@ -340,6 +387,10 @@ cached_data = scout.cache('parsed_data')
 - `__init__(markup, features='html.parser', from_encoding=None)`: Initialize with HTML content
 - `find(name, attrs={}, recursive=True, text=None)`: Find first matching element
 - `find_all(name, attrs={}, recursive=True, text=None, limit=None)`: Find all matching elements
+- `find_next(name, attrs={}, text=None)`: Find next element in document order
+- `find_all_next(name, attrs={}, text=None, limit=None)`: Find all next elements in document order
+- `find_previous(name, attrs={}, text=None)`: Find previous element in document order
+- `find_all_previous(name, attrs={}, text=None, limit=None)`: Find all previous elements in document order
 - `select(selector)`: Find elements using CSS selector
 - `get_text(separator=' ', strip=False)`: Extract text from document
 - `analyze_text()`: Perform text analysis
@@ -358,7 +409,7 @@ cached_data = scout.cache('parsed_data')
 - `_crawl_page(url, depth=0)`: Crawl a single page (internal method)
 - `_is_valid_url(url)`: Check if a URL is valid (internal method)
 
-For detailed API documentation, please refer to the [documentation](https://github.com/OEvortex/Webscout/wiki).
+For detailed API documentation, please refer to the [documentation](https://github.com/pyscout/Webscout/wiki).
 
 ## 🔧 Dependencies
 
@@ -393,9 +444,9 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 <div align="center">
   <p>Made with ❤️ by the Webscout team</p>
   <p>
-    <a href="https://github.com/OEvortex/Webscout">GitHub</a> •
-    <a href="https://github.com/OEvortex/Webscout/wiki">Documentation</a> •
-    <a href="https://github.com/OEvortex/Webscout/issues">Report Bug</a> •
-    <a href="https://github.com/OEvortex/Webscout/issues">Request Feature</a>
+    <a href="https://github.com/pyscout/Webscout">GitHub</a> •
+    <a href="https://github.com/pyscout/Webscout/wiki">Documentation</a> •
+    <a href="https://github.com/pyscout/Webscout/issues">Report Bug</a> •
+    <a href="https://github.com/pyscout/Webscout/issues">Request Feature</a>
   </p>
 </div>

webscout/scout/core/scout.py

@@ -454,6 +454,68 @@ class Scout:
             pass
         return siblings
 
+    def find_next(self, name=None, attrs={}, text=None, **kwargs) -> Optional[Tag]:
+        """
+        Find the next element in document order.
+
+        Args:
+            name: Tag name to search for
+            attrs: Attributes to match
+            text: Text content to match
+            **kwargs: Additional attributes
+
+        Returns:
+            Optional[Tag]: Next matching element or None
+        """
+        return self._soup.find_next(name, attrs, text, **kwargs)
+
+    def find_all_next(self, name=None, attrs={}, text=None, limit=None, **kwargs) -> List[Tag]:
+        """
+        Find all next elements in document order.
+
+        Args:
+            name: Tag name to search for
+            attrs: Attributes to match
+            text: Text content to match
+            limit: Maximum number of results
+            **kwargs: Additional attributes
+
+        Returns:
+            List[Tag]: List of matching elements
+        """
+        return self._soup.find_all_next(name, attrs, text, limit, **kwargs)
+
+    def find_previous(self, name=None, attrs={}, text=None, **kwargs) -> Optional[Tag]:
+        """
+        Find the previous element in document order.
+
+        Args:
+            name: Tag name to search for
+            attrs: Attributes to match
+            text: Text content to match
+            **kwargs: Additional attributes
+
+        Returns:
+            Optional[Tag]: Previous matching element or None
+        """
+        return self._soup.find_previous(name, attrs, text, **kwargs)
+
+    def find_all_previous(self, name=None, attrs={}, text=None, limit=None, **kwargs) -> List[Tag]:
+        """
+        Find all previous elements in document order.
+
+        Args:
+            name: Tag name to search for
+            attrs: Attributes to match
+            text: Text content to match
+            limit: Maximum number of results
+            **kwargs: Additional attributes
+
+        Returns:
+            List[Tag]: List of matching elements
+        """
+        return self._soup.find_all_previous(name, attrs, text, limit, **kwargs)
+
     def select(self, selector: str) -> List[Tag]:
         """
         Select elements using CSS selector.