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

webscout/Provider/ClaudeOnline.py

@@ -0,0 +1,350 @@
+from typing import Any, Dict, Generator, Optional, Union
+
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
+
+from webscout import exceptions
+from webscout.AIbase import Provider
+from webscout.AIutel import AwesomePrompts, Conversation, Optimizers
+from webscout.litagent import LitAgent
+
+
+class ClaudeOnline(Provider):
+    """
+    A class to interact with the Claude Online API (claude.online/chat).
+
+    This provider implements the reverse-engineered API from claude.online,
+    providing access to Claude AI through their web interface backend.
+    """
+    required_auth = False
+    AVAILABLE_MODELS = ["claude-online"]
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 2049,
+        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 assistant.",
+        model: str = "claude-online"
+    ):
+        """
+        Initializes the Claude Online API client.
+
+        Args:
+            is_conversation: Whether the provider is in conversation mode.
+            max_tokens: Maximum number of tokens to sample.
+            timeout: Timeout for API requests.
+            intro: Introduction message for the conversation.
+            filepath: Filepath for storing conversation history.
+            update_file: Whether to update the conversation history file.
+            proxies: Proxies for the API requests.
+            history_offset: Offset for conversation history.
+            act: Act for the conversation.
+            system_prompt: The system prompt to define the assistant's role.
+            model: Model to use (only "claude-online" supported).
+        """
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+
+        # API endpoints
+        self.chat_url = "https://wewordle.org/gptapi/v1/web/turbo"
+        self.limit_url = "https://wewordle.org/gptapi/v1/web/get_limit"
+
+        # Initialize LitAgent for user agent generation
+        self.agent = LitAgent()
+
+        # Generate browser fingerprint
+        self.fingerprint = self.agent.generate_fingerprint(browser="chrome")
+
+        # Setup headers to mimic browser requests
+        self.headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36',
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'sec-ch-ua': '"Google Chrome";v="141", "Not?A_Brand";v="8", "Chromium";v="141"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'Referer': 'https://claude.online/',
+            'Origin': 'https://claude.online',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'cross-site',
+        }
+
+        # Initialize curl_cffi Session
+        self.session = Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+
+        self.system_prompt = system_prompt
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+
+        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 _make_request(self, url: str, payload: Optional[Dict] = None, method: str = "POST") -> Dict:
+        """
+        Make a request to the API with error handling.
+
+        Args:
+            url: The URL to request
+            payload: Request payload (for POST requests)
+            method: HTTP method
+
+        Returns:
+            Parsed JSON response
+
+        Raises:
+            FailedToGenerateResponseError: If request fails
+        """
+        try:
+            if method == "POST":
+                response = self.session.post(
+                    url,
+                    json=payload,
+                    timeout=self.timeout,
+                    impersonate="chrome110"
+                )
+            else:
+                response = self.session.get(
+                    url,
+                    timeout=self.timeout,
+                    impersonate="chrome110"
+                )
+
+            response.raise_for_status()
+
+            # Check rate limit headers
+            if 'ratelimit-remaining' in response.headers:
+                remaining = int(response.headers['ratelimit-remaining'])
+                if remaining <= 0:
+                    reset_time = int(response.headers.get('ratelimit-reset', 60))
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Rate limit exceeded. Resets in {reset_time} seconds."
+                    )
+
+            return response.json()
+
+        except CurlError as e:
+            raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {str(e)}")
+        except Exception as e:
+            raise exceptions.FailedToGenerateResponseError(f"Request failed ({type(e).__name__}): {str(e)}")
+
+    def get_remaining_limit(self) -> Dict[str, Union[int, float]]:
+        """
+        Get the current rate limit status.
+
+        Returns:
+            Dict containing limit information:
+            - limit: Remaining requests
+            - fullLimit: Unknown parameter (possibly daily limit)
+        """
+        try:
+            response = self._make_request(self.limit_url, method="GET")
+            return {
+                "limit": response.get("limit", 0),
+                "fullLimit": response.get("fullLimit", 0)
+            }
+        except Exception:
+            # Return default values if request fails
+            return {"limit": 0, "fullLimit": 0}
+
+    def create_message(self, content: str, role: str = "user") -> Dict[str, str]:
+        """
+        Create a message dictionary.
+
+        Args:
+            content: Message content
+            role: Message role (user/assistant)
+
+        Returns:
+            Message dictionary
+        """
+        return {
+            "content": content,
+            "role": role
+        }
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        """
+        Send a chat message and get response.
+
+        Args:
+            prompt: The message to send
+            stream: Whether to stream the response (not supported by this API)
+            raw: Whether to return raw response
+            optimizer: Optimizer to use for the prompt
+            conversationally: Whether to generate the prompt conversationally
+
+        Returns:
+            Dict containing response or Generator for streaming
+        """
+        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 Exception(f"Optimizer is not one of {self.__available_optimizers}")
+
+        # Prepare messages (only current message supported by this API)
+        messages = [self.create_message(conversation_prompt, "user")]
+
+        payload = {
+            "messages": messages
+        }
+
+        def for_stream():
+            # This API doesn't support streaming, so simulate it
+            try:
+                response = self._make_request(self.chat_url, payload)
+
+                # Extract message content
+                if "message" in response and "content" in response["message"]:
+                    content = response["message"]["content"]
+
+                    # Simulate streaming by yielding chunks
+                    words = content.split()
+                    current_chunk = ""
+                    for word in words:
+                        current_chunk += word + " "
+                        if len(current_chunk) > 50:  # Yield chunks of ~50 characters
+                            yield dict(text=current_chunk.strip())
+                            current_chunk = ""
+                    if current_chunk:
+                        yield dict(text=current_chunk.strip())
+
+                    self.last_response = {"text": content}
+                    self.conversation.update_chat_history(prompt, content)
+                else:
+                    raise exceptions.FailedToGenerateResponseError("Unexpected response format")
+
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Chat request failed: {str(e)}")
+
+        def for_non_stream():
+            try:
+                response = self._make_request(self.chat_url, payload)
+
+                # Extract message content
+                if "message" in response and "content" in response["message"]:
+                    content = response["message"]["content"]
+                    self.last_response = {"text": content}
+                    self.conversation.update_chat_history(prompt, content)
+                    return self.last_response if not raw else content
+                else:
+                    raise exceptions.FailedToGenerateResponseError("Unexpected response format")
+
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Chat request failed: {str(e)}")
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        """
+        Generate a response from Claude Online.
+
+        Args:
+            prompt: The prompt to send
+            stream: Whether to stream the response
+            optimizer: Optimizer to use
+            conversationally: Whether to generate conversationally
+
+        Returns:
+            Response string or generator for streaming
+        """
+        def for_stream_chat():
+            for response in self.ask(
+                prompt, stream=True, raw=False,
+                optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream_chat():
+            response_data = self.ask(
+                prompt, stream=False, raw=False,
+                optimizer=optimizer, conversationally=conversationally
+            )
+            return self.get_message(response_data)
+
+        return for_stream_chat() if stream else for_non_stream_chat()
+
+    def get_message(self, response: dict) -> str:
+        """
+        Extract message from response.
+
+        Args:
+            response: Response dictionary
+
+        Returns:
+            Message content
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+
+
+if __name__ == "__main__":
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+
+    try:
+        ai = ClaudeOnline(timeout=60)
+        limits = ai.get_remaining_limit()
+        print(f"Rate limits - Remaining: {limits['limit']}, Full limit: {limits['fullLimit']}")
+
+        if limits['limit'] > 0:
+            response = ai.chat("Say 'Hello World' in one word", stream=False)
+            if response and len(response.strip()) > 0:
+                status = "✓"
+                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 response"
+            print(f"{'claude-online':<50} {status:<10} {display_text}")
+        else:
+            print(f"{'claude-online':<50} {'✗':<10} Rate limit exceeded")
+
+    except Exception as e:
+        print(f"{'claude-online':<50} {'✗':<10} {str(e)}")

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/version.py

@@ -1,2 +1,2 @@
-__version__ = "2025.10.16"
+__version__ = "2025.10.17"
 __prog__ = "webscout"

webscout/version.py.bak

@@ -1,2 +1,2 @@
-__version__ = "2025.10.15"
+__version__ = "2025.10.16"
 __prog__ = "webscout"

{webscout-2025.10.16.dist-info → webscout-2025.10.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 2025.10.16
+Version: 2025.10.17
 Summary: Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author-email: OEvortex <helpingai5@gmail.com>
 License: HelpingAI
@@ -50,7 +50,6 @@ Requires-Dist: lxml>=5.2.2
 Requires-Dist: orjson
 Requires-Dist: PyYAML
 Requires-Dist: pillow
-Requires-Dist: bson
 Requires-Dist: cloudscraper
 Requires-Dist: html5lib
 Requires-Dist: aiofiles
@@ -163,7 +162,7 @@ Dynamic: license-file
 - **[YouTube Toolkit](webscout/Extra/YTToolkit/README.md):** Advanced YouTube video and transcript management with multi-language support
 - **[Text-to-Speech (TTS)](webscout/Provider/TTS/README.md):** Convert text into natural-sounding speech using multiple AI-powered providers
 - **[Text-to-Image](webscout/Provider/TTI/README.md):** Generate high-quality images using a wide range of AI art providers
-- **[Weather Tools](webscout/Extra/weather.md):** Retrieve detailed weather information for any location
+- **[Weather Tools](docs/weather.md):** Retrieve detailed weather information for any location
 </p>
 </details>
 

{webscout-2025.10.16.dist-info → webscout-2025.10.17.dist-info}/RECORD

@@ -14,13 +14,12 @@ webscout/prompt_manager.py,sha256=ysKFgPhkV3uqrOCilqcS9rG8xhzdU_d2wx0grC9WCCc,98
 webscout/sanitize.py,sha256=pw2Dzn-Jw9mOD4mpALYAvAf-medA-9AqdzsOmdXQbl0,46577
 webscout/update_checker.py,sha256=bz0TzRxip9DOIVMFyNz9HsGj4RKB0xZgo57AUVSJINo,3708
 webscout/utils.py,sha256=o2hU3qaVPk25sog3e4cyVZO3l8xwaZpYRziZPotEzNo,3075
-webscout/version.py,sha256=bau6psbS6y1YovrRr6K7N3uBj_p0yf9WmHDqSK16bMs,51
-webscout/version.py.bak,sha256=lFdrFaHswFMDr9VdMdSSpxeTuXjC5Z2DIrPJbWo9KtQ,51
+webscout/version.py,sha256=3D9mFWY4P-ZGCKSuDPkkzHusmyndScdoNbUtry1vdCE,51
+webscout/version.py.bak,sha256=bau6psbS6y1YovrRr6K7N3uBj_p0yf9WmHDqSK16bMs,51
 webscout/Extra/Act.md,sha256=_C2VW_Dc-dc7eejpGYKAOZhImHKPiQ7NSwE3bkzr6fg,18952
 webscout/Extra/__init__.py,sha256=KvJRsRBRO-fZp2jSCl6KQnPppi93hriA6O_U1O1s31c,177
 webscout/Extra/gguf.md,sha256=McXGz5sTfzOO9X4mH8yIqu5K3CgjzyXKi4_HQtezdZ4,12435
 webscout/Extra/gguf.py,sha256=sbUsEPbws99yzS2EzZHLmZ55q6esFfu7k2y5WzMBEbA,55683
-webscout/Extra/weather.md,sha256=CaDwLmmHEXHSsMkSxFzrNOl2YslRcIMn3Hd3N1eaFq4,9781
 webscout/Extra/weather.py,sha256=KwbJC2Most6jVLvv8X_Ct7APGimSr98REgLc07kR-Ec,7648
 webscout/Extra/weather_ascii.py,sha256=k6U0F9w5xXPvYK-Wq3pjUh7W0gGJG4e_YhxeUI65Vpk,2612
 webscout/Extra/GitToolkit/__init__.py,sha256=S8clC97xkihcsxfbAO9QOmSO2ljLOiQFoUh_klhp2zw,146
@@ -68,6 +67,7 @@ webscout/Provider/Andi.py,sha256=CWFMRw9edQ0yRGLXtciPsl_O0v2Qs80TH8TkJ2bkAUk,873
 webscout/Provider/Apriel.py,sha256=caAjFQtMLfB0Er_eA-tW8_kGASE5AnaqLYifw1uJuIo,11335
 webscout/Provider/ChatGPTClone.py,sha256=hX_9Ytegiz6oDARzjwU11PPEXJqwTFGHAgShtDLbGHs,9715
 webscout/Provider/ChatSandbox.py,sha256=Hl8vOQzij7VyYVoL3DvJO6HGUs6tXZY3xrbCLKrF_ZI,13122
+webscout/Provider/ClaudeOnline.py,sha256=3J5LEjvxzpYgIcycCq1aG_kFjks7ECkJS6l0HQ5bEyQ,12748
 webscout/Provider/Cloudflare.py,sha256=nrHCZ9SYNNRIxxzR_QRU1fy-jh31WnErxIimF0aDZms,14155
 webscout/Provider/Cohere.py,sha256=wPULeG_2JZdhN8oTBjs_QNqs6atjkYkjCa01mRmg8Fw,8082
 webscout/Provider/Deepinfra.py,sha256=Z3FNMaaVd4KiitDG8LBgGWycNuT6Y1Z06sCFURd0Ynw,15882
@@ -193,6 +193,7 @@ webscout/Provider/TTI/__init__.py,sha256=EwtLtQs6VEpLFOBeXi9hC9FTJIJdHPZTZtu3iFF
 webscout/Provider/TTI/aiarta.py,sha256=aWIATT_xQU7AmH3rK9mDCrUyN_7yOqkpXFPKicrGKfY,14956
 webscout/Provider/TTI/base.py,sha256=SnNs-mJH8tcmcygNnfNtwPvWBk11FUO6nLTfnHnZADQ,5088
 webscout/Provider/TTI/bing.py,sha256=wzUtAprlptlvuA3wndn3i-5UBQIL-YSe8rmjhqb1T-Q,10632
+webscout/Provider/TTI/claudeonline.py,sha256=v6CEst37QG53g-H9rqjwiZeipJyedU1HHG3PrHX31Bw,10969
 webscout/Provider/TTI/gpt1image.py,sha256=PKqc0JU7hweypnSooI7gWuXqJbKz52xfGQny90-Uin0,4831
 webscout/Provider/TTI/imagen.py,sha256=VtSTJzTao4oUje4viEuYbcAw2Fol-JhBPax3XeXuByM,6488
 webscout/Provider/TTI/infip.py,sha256=qAzcym5hyxHyuW5PFqcWN__ebs5s9wLCADakO_28aD4,7083
@@ -328,9 +329,9 @@ webscout/zeroart/__init__.py,sha256=Cy9AUtXnOaFBQjNvCpN19IXJo7Lg15VTaNcTBxOTFek,
 webscout/zeroart/base.py,sha256=I-xhDEfArBb6q7hiF5oPoyXeu2hzL6orp7uWgS_YtG8,2299
 webscout/zeroart/effects.py,sha256=XUNZY1-wMPd6GNL3glFXtWaF9wDis_z55qTyCdnzHDo,5063
 webscout/zeroart/fonts.py,sha256=S7qDhUmDXl1makMreZl_eVW_7-sqVQiGn-kQKl0Hg_A,51006
-webscout-2025.10.16.dist-info/licenses/LICENSE.md,sha256=hyfFlVn7pWcrvuvs-piB8k4J8DlXdOsYje9RyPxc6Ik,7543
-webscout-2025.10.16.dist-info/METADATA,sha256=1jpCGVNGZrYgLltqLS8-vUlre_bLwQdq_O5XT4XljKQ,21690
-webscout-2025.10.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-webscout-2025.10.16.dist-info/entry_points.txt,sha256=4xAgKHWwNhAvJyShLCFs_IU8Reb8zR3wqf8egrsDr8g,118
-webscout-2025.10.16.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
-webscout-2025.10.16.dist-info/RECORD,,
+webscout-2025.10.17.dist-info/licenses/LICENSE.md,sha256=hyfFlVn7pWcrvuvs-piB8k4J8DlXdOsYje9RyPxc6Ik,7543
+webscout-2025.10.17.dist-info/METADATA,sha256=-12NEKcAbsCMUnFV4pl40tKrXhXDW0skcWCfCA1vhG8,21660
+webscout-2025.10.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+webscout-2025.10.17.dist-info/entry_points.txt,sha256=4xAgKHWwNhAvJyShLCFs_IU8Reb8zR3wqf8egrsDr8g,118
+webscout-2025.10.17.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
+webscout-2025.10.17.dist-info/RECORD,,

webscout/Extra/weather.md

@@ -1,281 +0,0 @@
-<div align="center">
-  <h1>☀️ Webscout Weather Toolkit</h1>
-  <p><strong>Comprehensive weather data retrieval and visualization tools</strong></p>
-  
-  <!-- Badges -->
-  <p>
-    <a href="#-installation"><img src="https://img.shields.io/badge/Easy-Installation-success?style=flat-square" alt="Easy Installation"></a>
-    <a href="#-current-weather-data"><img src="https://img.shields.io/badge/Real--time-Data-blue?style=flat-square" alt="Real-time Data"></a>
-    <a href="#-ascii-art-weather"><img src="https://img.shields.io/badge/ASCII-Visualization-orange?style=flat-square" alt="ASCII Visualization"></a>
-  </p>
-</div>
-
-> [!NOTE]
-> Webscout's Weather Toolkit provides powerful tools to retrieve and display weather information in various formats, including structured data and ASCII art visualization.
-
-## 📋 Table of Contents
-
-- [🚀 Installation](#-installation)
-- [🌡️ Current Weather Data](#-current-weather-data)
-- [🔮 Weather Forecast](#-weather-forecast)
-- [🎨 ASCII Art Weather](#-ascii-art-weather)
-- [📊 Data Structure](#-data-structure)
-- [⚙️ Advanced Usage](#-advanced-usage)
-
-## 🚀 Installation
-
-The Weather Toolkit is included in the Webscout package. Install or update Webscout to get access:
-
-```bash
-pip install -U webscout
-```
-
-## 🌡️ Current Weather Data
-
-Retrieve structured current weather information for any location worldwide.
-
-```python
-from webscout.Extra import weather
-
-# Get weather for a specific location
-forecast = weather.get("London")
-
-# Access current conditions
-print(f"Current weather: {forecast.summary}")
-
-# Access temperature details
-if forecast.current_condition:
-    print(f"Temperature: {forecast.current_condition.temp_c}°C / {forecast.current_condition.temp_f}°F")
-    print(f"Feels like: {forecast.current_condition.feels_like_c}°C")
-    print(f"Conditions: {forecast.current_condition.weather_desc}")
-    print(f"Wind: {forecast.current_condition.wind_speed_kmph} km/h from {forecast.current_condition.wind_direction}")
-    print(f"Humidity: {forecast.current_condition.humidity}%")
-    print(f"Visibility: {forecast.current_condition.visibility} km")
-    print(f"Pressure: {forecast.current_condition.pressure} mb")
-```
-
-## 🔮 Weather Forecast
-
-Access detailed forecast information for today and upcoming days.
-
-```python
-from webscout.Extra import weather
-
-forecast = weather.get("Tokyo")
-
-# Today's forecast
-if forecast.today:
-    print(f"Today ({forecast.today.date_formatted}):")
-    print(f"  Temperature range: {forecast.today.min_temp_c}°C - {forecast.today.max_temp_c}°C")
-    print(f"  Sunrise: {forecast.today.sunrise}, Sunset: {forecast.today.sunset}")
-    
-    # Access hourly forecasts
-    if forecast.today.hourly and len(forecast.today.hourly) > 4:
-        noon = forecast.today.hourly[4]  # Noon (12:00) is usually index 4
-        print(f"  Noon conditions: {noon.weather_desc}")
-        print(f"  Chance of rain: {noon.chance_of_rain}%")
-        print(f"  Humidity: {noon.humidity}%")
-        print(f"  UV Index: {noon.uv_index}")
-
-# Tomorrow's forecast
-if forecast.tomorrow:
-    print(f"\nTomorrow ({forecast.tomorrow.date_formatted}):")
-    print(f"  Temperature range: {forecast.tomorrow.min_temp_c}°C - {forecast.tomorrow.max_temp_c}°C")
-    print(f"  Weather: {forecast.tomorrow.weather_desc}")
-    print(f"  Sunrise: {forecast.tomorrow.sunrise}, Sunset: {forecast.tomorrow.sunset}")
-
-# Extended forecast (next 3 days)
-if forecast.days and len(forecast.days) > 2:
-    print("\nExtended Forecast:")
-    for day in forecast.days[2:5]:  # Days 3-5
-        print(f"  {day.date_formatted}: {day.min_temp_c}°C - {day.max_temp_c}°C, {day.weather_desc}")
-```
-
-## 🎨 ASCII Art Weather
-
-Retrieve weather information as visually appealing ASCII art.
-
-```python
-from webscout.Extra import weather_ascii
-
-# Get ASCII art weather 
-result = weather_ascii.get("Paris")
-
-# Display the ASCII art weather
-print(result.content)
-
-# Get ASCII art with temperature in Fahrenheit
-result_f = weather_ascii.get("New York", units="imperial")
-print(result_f.content)
-
-# Get ASCII art with a specific number of forecast days
-result_days = weather_ascii.get("Berlin", days=3)
-print(result_days.content)
-```
-
-Example output:
-```
-Weather for Paris, France
-
-     \   /     Clear
-      .-.      +20°C
-   ― (   ) ―   ↗ 11 km/h
-      `-'      10 km
-     /   \     0.0 mm
-                        ┌─────────────┐
-┌───────────────────────┤  Wed 14 Apr ├───────────────────────┐
-│             Morning   └──────┬──────┘    Evening    Night   │
-├──────────────────────────────┼──────────────────────────────┤
-│               Cloudy         │               Clear          │
-│      .--.     +20..+22 °C    │     \   /     +15 °C         │
-│   .-(    ).   ↗ 11-13 km/h   │      .-.      ↗ 7-9 km/h     │
-│  (___.__)__)  10 km          │   ― (   ) ―   10 km          │
-│               0.0 mm | 0%    │      `-'      0.0 mm | 0%    │
-└──────────────────────────────┴──────────────────────────────┘
-```
-
-## 📊 Data Structure
-
-The Weather Toolkit returns structured data objects with the following key components:
-
-<details>
-<summary><strong>Forecast Object Structure</strong></summary>
-
-```python
-forecast = weather.get("London")
-
-# Main forecast object attributes
-forecast.location        # Location information (city, country, etc.)
-forecast.summary         # Brief summary of current weather
-forecast.current_condition  # Current weather conditions
-forecast.today           # Today's forecast
-forecast.tomorrow        # Tomorrow's forecast
-forecast.days            # List of daily forecasts (including today and tomorrow)
-
-# Current condition attributes
-current = forecast.current_condition
-current.temp_c           # Temperature in Celsius
-current.temp_f           # Temperature in Fahrenheit
-current.feels_like_c     # "Feels like" temperature in Celsius
-current.feels_like_f     # "Feels like" temperature in Fahrenheit
-current.wind_speed_kmph  # Wind speed in km/h
-current.wind_speed_mph   # Wind speed in mph
-current.wind_direction   # Wind direction (e.g., "NW")
-current.humidity         # Humidity percentage
-current.pressure         # Atmospheric pressure in millibars
-current.visibility       # Visibility in kilometers
-current.weather_desc     # Weather description (e.g., "Partly cloudy")
-current.weather_code     # Weather code for icon mapping
-
-# Daily forecast attributes
-day = forecast.today  # or any day from forecast.days
-day.date              # Date (YYYY-MM-DD)
-day.date_formatted    # Formatted date (e.g., "Wed 14 Apr")
-day.max_temp_c        # Maximum temperature in Celsius
-day.min_temp_c        # Minimum temperature in Celsius
-day.max_temp_f        # Maximum temperature in Fahrenheit
-day.min_temp_f        # Minimum temperature in Fahrenheit
-day.sunrise           # Sunrise time
-day.sunset            # Sunset time
-day.weather_desc      # Weather description
-day.weather_code      # Weather code
-day.hourly            # List of hourly forecasts for this day
-```
-</details>
-
-<details>
-<summary><strong>ASCII Weather Object Structure</strong></summary>
-
-```python
-result = weather_ascii.get("Paris")
-
-# ASCII result attributes
-result.content        # The full ASCII art weather display
-result.location       # Location information
-result.temperature    # Current temperature
-result.conditions     # Current weather conditions
-result.forecast_days  # Number of forecast days included
-```
-</details>
-
-## ⚙️ Advanced Usage
-
-<details>
-<summary><strong>Custom Location Formats</strong></summary>
-
-The Weather Toolkit supports various location formats:
-
-```python
-# City name
-weather.get("London")
-
-# City and country
-weather.get("Paris, France")
-
-# ZIP/Postal code (US)
-weather.get("10001")  # New York, NY
-
-# Latitude and Longitude
-weather.get("40.7128,-74.0060")  # New York coordinates
-```
-</details>
-
-<details>
-<summary><strong>Temperature Units</strong></summary>
-
-Control temperature units in ASCII weather display:
-
-```python
-# Default (metric - Celsius)
-weather_ascii.get("Tokyo")
-
-# Imperial (Fahrenheit)
-weather_ascii.get("New York", units="imperial")
-
-# Metric (Celsius)
-weather_ascii.get("Berlin", units="metric")
-```
-</details>
-
-<details>
-<summary><strong>Forecast Days</strong></summary>
-
-Control the number of forecast days in ASCII weather display:
-
-```python
-# Default (1 day)
-weather_ascii.get("Sydney")
-
-# 3-day forecast
-weather_ascii.get("Rio de Janeiro", days=3)
-
-# 5-day forecast (maximum)
-weather_ascii.get("Moscow", days=5)
-```
-</details>
-
-<details>
-<summary><strong>Error Handling</strong></summary>
-
-Implement proper error handling for robust applications:
-
-```python
-from webscout.Extra import weather
-from webscout.exceptions import APIError
-
-try:
-    forecast = weather.get("London")
-    print(f"Current temperature: {forecast.current_condition.temp_c}°C")
-except APIError as e:
-    print(f"API Error: {e}")
-except Exception as e:
-    print(f"An error occurred: {e}")
-```
-</details>
-
-<div align="center">
-  <p>
-    <a href="https://github.com/OEvortex/Webscout"><img alt="GitHub Repository" src="https://img.shields.io/badge/GitHub-Repository-181717?style=for-the-badge&logo=github&logoColor=white"></a>
-    <a href="https://t.me/PyscoutAI"><img alt="Telegram Group" src="https://img.shields.io/badge/Telegram%20Group-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white"></a>
-  </p>
-</div>