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

webscout/webscout_search_async.py

@@ -103,11 +103,6 @@ class AsyncWEBS:
         self.sleep_timestamp = 0.0
 
         self._exception_event = asyncio.Event()
-        self._chat_messages: List[Dict[str, str]] = []
-        self._chat_tokens_count = 0
-        self._chat_vqd: str = ""
-        self._chat_vqd_hash: str = ""
-        self._chat_xfe: str = ""
 
     async def __aenter__(self) -> AsyncWEBS:
         return self
@@ -189,179 +184,6 @@ class AsyncWEBS:
         resp_content = (await self._get_url("GET", "https://duckduckgo.com", params={"q": keywords})).content
         return _extract_vqd(resp_content, keywords)
 
-    async def achat_yield(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> AsyncIterator[str]:
-        """Initiates an async chat session with webscout AI.
-
-        Args:
-            keywords (str): The initial message or question to send to the AI.
-            model (str): The model to use: "gpt-4o-mini", "llama-3.3-70b", "claude-3-haiku",
-                "o3-mini", "mistral-small-3". Defaults to "gpt-4o-mini".
-            timeout (int): Timeout value for the HTTP client. Defaults to 30.
-            max_retries (int): Maximum number of retry attempts for rate limited requests. Defaults to 3.
-
-        Yields:
-            str: Chunks of the response from the AI.
-        """
-        # Get Cloudflare Turnstile token
-        async def get_turnstile_token():
-            try:
-                # Visit the DuckDuckGo chat page to get the Turnstile token
-                resp_content = (await self._get_url(
-                    method="GET",
-                    url="https://duckduckgo.com/?q=DuckDuckGo+AI+Chat&ia=chat&duckai=1",
-                )).content
-
-                # Extract the Turnstile token if available
-                if b'cf-turnstile-response' in resp_content:
-                    token = resp_content.split(b'cf-turnstile-response="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                    return token
-                return ""
-            except Exception:
-                return ""
-
-        # x-fe-version
-        if not self._chat_xfe:
-            resp_content = (await self._get_url(
-                method="GET",
-                url="https://duckduckgo.com/?q=DuckDuckGo+AI+Chat&ia=chat&duckai=1",
-            )).content
-            try:
-                xfe1 = resp_content.split(b'__DDG_BE_VERSION__="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                xfe2 = resp_content.split(b'__DDG_FE_CHAT_HASH__="', maxsplit=1)[1].split(b'"', maxsplit=1)[0].decode()
-                self._chat_xfe = f"{xfe1}-{xfe2}"
-            except Exception as ex:
-                raise WebscoutE(
-                    f"achat_yield() Error to get _chat_xfe: {type(ex).__name__}: {ex}"
-                ) from ex
-        # vqd
-        if not self._chat_vqd:
-            resp = await self._get_url(
-                method="GET", url="https://duckduckgo.com/duckchat/v1/status", headers={"x-vqd-accept": "1"}
-            )
-            self._chat_vqd = resp.headers.get("x-vqd-4", "")
-            self._chat_vqd_hash = resp.headers.get("x-vqd-hash-1", "")
-
-        self._chat_messages.append({"role": "user", "content": keywords})
-        self._chat_tokens_count += max(len(keywords) // 4, 1)  # approximate number of tokens
-        if model not in self._chat_models:
-            warnings.warn(f"{model=} is unavailable. Using 'gpt-4o-mini'", stacklevel=1)
-            model = "gpt-4o-mini"
-
-        # Get Cloudflare Turnstile token
-        turnstile_token = await get_turnstile_token()
-
-        json_data = {
-            "model": self._chat_models[model],
-            "messages": self._chat_messages,
-        }
-
-        # Add Turnstile token if available
-        if turnstile_token:
-            json_data["cf-turnstile-response"] = turnstile_token
-
-        # Enhanced headers to better mimic a real browser
-        chat_headers = {
-            "x-fe-version": self._chat_xfe,
-            "x-vqd-4": self._chat_vqd,
-            "x-vqd-hash-1": "",
-            "Accept": "text/event-stream",
-            "Accept-Language": "en-US,en;q=0.9",
-            "Cache-Control": "no-cache",
-            "Content-Type": "application/json",
-            "DNT": "1",
-            "Origin": "https://duckduckgo.com",
-            "Referer": "https://duckduckgo.com/",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "User-Agent": self.client.headers.get("User-Agent", "")
-        }
-
-        # Retry logic for rate limited requests
-        retry_count = 0
-        while retry_count <= max_retries:
-            try:
-                resp = await self._get_url(
-                    method="POST",
-                    url="https://duckduckgo.com/duckchat/v1/chat",
-                    headers=chat_headers,
-                    json=json_data,
-                    timeout=timeout,
-                )
-
-                self._chat_vqd = resp.headers.get("x-vqd-4", "")
-                self._chat_vqd_hash = resp.headers.get("x-vqd-hash-1", "")
-                chunks = []
-
-                # curl_cffi uses aiter_content instead of aiter_bytes
-                async for chunk in resp.aiter_content(chunk_size=1024):
-                    lines = chunk.split(b"data:")
-                    for line in lines:
-                        if line := line.strip():
-                            if line == b"[DONE]":
-                                break
-                            if line == b"[DONE][LIMIT_CONVERSATION]":
-                                raise ConversationLimitException("ERR_CONVERSATION_LIMIT")
-                            try:
-                                x = json_loads(line)
-                                if isinstance(x, dict):
-                                    if x.get("action") == "error":
-                                        err_message = x.get("type", "")
-                                        if x.get("status") == 429:
-                                            raise (
-                                                ConversationLimitException(err_message)
-                                                if err_message == "ERR_CONVERSATION_LIMIT"
-                                                else RatelimitE(err_message)
-                                            )
-                                        raise WebscoutE(err_message)
-                                    elif message := x.get("message"):
-                                        chunks.append(message)
-                                        yield message
-                            except Exception:
-                                # Skip invalid JSON data
-                                continue
-
-                # If we get here, the request was successful
-                result = "".join(chunks)
-                self._chat_messages.append({"role": "assistant", "content": result})
-                self._chat_tokens_count += len(result)
-                return
-
-            except RatelimitE as ex:
-                retry_count += 1
-                if retry_count > max_retries:
-                    raise WebscoutE(f"achat_yield() Rate limit exceeded after {max_retries} retries: {ex}") from ex
-
-                # Get a fresh Turnstile token for the retry
-                turnstile_token = await get_turnstile_token()
-                if turnstile_token:
-                    json_data["cf-turnstile-response"] = turnstile_token
-
-                # Exponential backoff
-                sleep_time = 2 ** retry_count
-                await asyncio.sleep(sleep_time)
-
-            except Exception as ex:
-                raise WebscoutE(f"achat_yield() {type(ex).__name__}: {ex}") from ex
-
-    async def achat(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> str:
-        """Initiates an async chat session with webscout AI.
-
-        Args:
-            keywords (str): The initial message or question to send to the AI.
-            model (str): The model to use: "gpt-4o-mini", "llama-3.3-70b", "claude-3-haiku",
-                "o3-mini", "mistral-small-3". Defaults to "gpt-4o-mini".
-            timeout (int): Timeout value for the HTTP client. Defaults to 30.
-            max_retries (int): Maximum number of retry attempts for rate limited requests. Defaults to 3.
-
-        Returns:
-            str: The response from the AI.
-        """
-        chunks = []
-        async for chunk in self.achat_yield(keywords, model, timeout, max_retries):
-            chunks.append(chunk)
-        return "".join(chunks)
-
     async def atext(
         self,
         keywords: str,
@@ -829,4 +651,4 @@ class AsyncWEBS:
             TimeoutE: Inherits from WebscoutE, raised for API request timeouts.
         """
         # These methods are not implemented in the async version yet
-        raise NotImplementedError("aweather method is not implemented yet")
+        raise NotImplementedError("aweather method is not implemented yet")

webscout/zeroart/README.md

@@ -0,0 +1,89 @@
+# 🎨 ZeroArt: Zero-Dependency ASCII Art Generator
+
+## 🚀 Overview
+
+ZeroArt is a powerful, lightweight Python library for generating stunning ASCII art text with zero external dependencies. Transform your plain text into eye-catching, stylized art with just a few lines of code!
+
+## ✨ Features
+
+- **Multiple Font Styles**
+  - Block Font
+  - Slant Font
+  - Neon Font
+  - Cyber Font
+
+- **Zero Dependencies**
+  - Completely standalone library
+  - No external package requirements
+
+- **Easy to Use**
+  - Simple, intuitive API
+  - Minimal setup needed
+
+- **Text Effects**
+  - Rainbow coloring
+  - Glitch effect
+  - Text wrapping
+  - Outline generation
+
+## 🛠 Installation
+
+No installation required! Just copy the `zeroart` directory into your project.
+
+## 💻 Usage Examples
+
+### Basic ASCII Art
+
+```python
+from webscout import zeroart
+
+# Generate ASCII art
+art = zeroart.figlet_format("PYTHON", font='block')
+print(art)
+
+# Directly print ASCII art
+zeroart.print_figlet("CODING", font='slant')
+```
+
+### Font Styles
+
+```python
+from webscout import zeroart
+
+# Different font styles
+print(zeroart.figlet_format("AWESOME", font='block'))   # Block style
+print(zeroart.figlet_format("CODING", font='slant'))    # Slant style
+print(zeroart.figlet_format("NEON", font='neon'))       # Neon style
+print(zeroart.figlet_format("CYBER", font='cyber'))     # Cyber style
+```
+
+### Text Effects
+
+```python
+from webscout import zeroart
+
+# Rainbow effect
+print(zeroart.rainbow("COLORFUL", font='neon'))
+
+# Glitch effect
+print(zeroart.glitch("GLITCH", font='cyber'))
+
+# Outline effect
+print(zeroart.outline("BORDER", font='block'))
+```
+
+## 🎨 Available Fonts
+
+1. **Block Font**: Classic, bold block-style letters
+2. **Slant Font**: Elegant, slanted text
+3. **Neon Font**: Glowing, pixel-style art
+4. **Cyber Font**: Cyberpunk-inspired rendering
+
+## 🤝 Contributing
+
+Contributions are welcome! 
+
+- Fork the repository
+- Create a new font
+- Add text effects
+- Improve existing code

webscout/zeroart/__init__.py

@@ -1,55 +1,135 @@
-"""
-ZeroArt: A zero-dependency ASCII art text generator
-
-Create awesome ASCII art text without external dependencies!
-"""
-
-from .base import ZeroArtFont
-from .fonts import BlockFont, SlantFont, NeonFont, CyberFont
-from .effects import AsciiArtEffects
-
-def figlet_format(text, font='block'):
-    """
-    Generate ASCII art text
-    
-    :param text: Text to convert
-    :param font: Font style (default: 'block')
-    :return: ASCII art representation of text
-    """
-    font_map = {
-        'block': BlockFont(),
-        'slant': SlantFont(),
-        'neon': NeonFont(),
-        'cyber': CyberFont()
-    }
-    
-    selected_font = font_map.get(font.lower(), BlockFont())
-    return selected_font.render(text)
-
-def print_figlet(text, font='block'):
-    """
-    Print ASCII art text directly
-    
-    :param text: Text to convert and print
-    :param font: Font style (default: 'block')
-    """
-    print(figlet_format(text, font))
-
-# Expose additional effects
-rainbow = AsciiArtEffects.rainbow_effect
-glitch = AsciiArtEffects.glitch_effect
-wrap_text = AsciiArtEffects.wrap_text
-outline = AsciiArtEffects.outline_effect
-
-__all__ = [
-    'figlet_format', 
-    'print_figlet', 
-    'rainbow', 
-    'glitch', 
-    'wrap_text', 
-    'outline',
-    'BlockFont', 
-    'SlantFont', 
-    'NeonFont', 
-    'CyberFont'
+"""
+ZeroArt: A zero-dependency ASCII art text generator
+
+Create awesome ASCII art text without external dependencies!
+"""
+
+from typing import Dict, List, Literal, Optional, Union
+from .base import ZeroArtFont
+from .fonts import BlockFont, SlantFont, NeonFont, CyberFont, DottedFont, ShadowFont
+from .effects import AsciiArtEffects
+
+FontType = Literal['block', 'slant', 'neon', 'cyber', 'dotted', 'shadow']
+
+def figlet_format(text: str, font: Union[str, ZeroArtFont] = 'block') -> str:
+    """
+    Generate ASCII art text
+    
+    :param text: Text to convert
+    :param font: Font style (default: 'block')
+    :return: ASCII art representation of text
+    """
+    font_map: Dict[str, ZeroArtFont] = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont(),
+        'dotted': DottedFont(),
+        'shadow': ShadowFont()
+    }
+    
+    if isinstance(font, str):
+        selected_font: ZeroArtFont = font_map.get(font.lower(), BlockFont())
+    else:
+        selected_font = font
+    return selected_font.render(text)
+
+def print_figlet(text: str, font: Union[str, ZeroArtFont] = 'block') -> None:
+    """
+    Print ASCII art text directly
+    
+    :param text: Text to convert and print
+    :param font: Font style (default: 'block')
+    """
+    print(figlet_format(text, font))
+
+# Expose additional effects with font handling
+def rainbow(text: str, font: Union[str, ZeroArtFont] = 'block') -> str:
+    """
+    Apply a rainbow-like color effect to ASCII art
+    
+    :param text: Text to render
+    :param font: Font style (default: 'block')
+    :return: Rainbow-styled ASCII art
+    """
+    font_map: Dict[str, ZeroArtFont] = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont(),
+        'dotted': DottedFont(),
+        'shadow': ShadowFont()
+    }
+    
+    if isinstance(font, str):
+        selected_font: ZeroArtFont = font_map.get(font.lower(), BlockFont())
+    else:
+        selected_font = font
+    return AsciiArtEffects.rainbow_effect(text, selected_font)
+
+def glitch(text: str, font: Union[str, ZeroArtFont] = 'block', glitch_intensity: float = 0.1) -> str:
+    """
+    Apply a glitch-like distortion to ASCII art
+    
+    :param text: Text to render
+    :param font: Font style (default: 'block')
+    :param glitch_intensity: Probability of character distortion
+    :return: Glitched ASCII art
+    """
+    font_map: Dict[str, ZeroArtFont] = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont(),
+        'dotted': DottedFont(),
+        'shadow': ShadowFont()
+    }
+    
+    if isinstance(font, str):
+        selected_font: ZeroArtFont = font_map.get(font.lower(), BlockFont())
+    else:
+        selected_font = font
+    return AsciiArtEffects.glitch_effect(text, selected_font, glitch_intensity)
+
+wrap_text = AsciiArtEffects.wrap_text
+
+def outline(text: str, font: Union[str, ZeroArtFont] = 'block', outline_char: str = '*') -> str:
+    """
+    Add an outline effect to ASCII art
+    
+    :param text: Text to render
+    :param font: Font style (default: 'block')
+    :param outline_char: Character to use for outline
+    :return: ASCII art with outline
+    """
+    font_map: Dict[str, ZeroArtFont] = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont(),
+        'dotted': DottedFont(),
+        'shadow': ShadowFont()
+    }
+    
+    if isinstance(font, str):
+        selected_font: ZeroArtFont = font_map.get(font.lower(), BlockFont())
+    else:
+        selected_font = font
+    return AsciiArtEffects.outline_effect(text, selected_font, outline_char)
+
+__all__ = [
+    'figlet_format', 
+    'print_figlet', 
+    'rainbow', 
+    'glitch', 
+    'wrap_text', 
+    'outline',
+    'BlockFont', 
+    'SlantFont', 
+    'NeonFont', 
+    'CyberFont',
+    'DottedFont',
+    'ShadowFont',
+    'ZeroArtFont',
+    'FontType'
 ]

webscout/zeroart/base.py

@@ -1,15 +1,16 @@
 """
 ZeroArt Base: Core classes and utilities for ASCII art generation
 """
+from typing import Dict, List, Optional, Union
 
 class ZeroArtFont:
     """Base class for ASCII art fonts"""
-    def __init__(self, name):
-        self.name = name
-        self.letters = {}
-        self.special_chars = {}
+    def __init__(self, name: str) -> None:
+        self.name: str = name
+        self.letters: Dict[str, List[str]] = {}
+        self.special_chars: Dict[str, List[str]] = {}
 
-    def add_letter(self, char, art_lines):
+    def add_letter(self, char: str, art_lines: List[str]) -> None:
         """
         Add a custom letter to the font
         
@@ -18,7 +19,7 @@ class ZeroArtFont:
         """
         self.letters[char.upper()] = art_lines
 
-    def add_special_char(self, name, art_lines):
+    def add_special_char(self, name: str, art_lines: List[str]) -> None:
         """
         Add a special ASCII art character or design
         
@@ -27,7 +28,7 @@ class ZeroArtFont:
         """
         self.special_chars[name] = art_lines
 
-    def get_letter(self, char):
+    def get_letter(self, char: str) -> List[str]:
         """
         Get ASCII art for a specific character
         
@@ -36,19 +37,24 @@ class ZeroArtFont:
         """
         return self.letters.get(char.upper(), self.letters.get(' ', [' ']))
 
-    def render(self, text):
+    def render(self, text: str) -> str:
+        """
+        Render text as ASCII art
+        
+        :param text: Text to render as ASCII art
+        :return: ASCII art representation of the text
+        """
         if not text:
             return ""
-            
-        # Get the maximum height of any character in the font
-        max_height = max(len(self.get_letter(c)) for c in text)
+              # Get the maximum height of any character in the font
+        max_height: int = max(len(self.get_letter(c)) for c in text)
         
         # Initialize art_lines with empty strings
-        art_lines = ["" for _ in range(max_height)]
+        art_lines: List[str] = ["" for _ in range(max_height)]
         
         # Process each character
         for char in text:
-            char_art = self.get_letter(char)
+            char_art: List[str] = self.get_letter(char)
             # Pad shorter characters with empty lines to match max_height
             while len(char_art) < max_height:
                 char_art.append(" " * len(char_art[0]))