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

webscout/swiftcli/Readme.md

@@ -0,0 +1,323 @@
+<div align="center">
+  
+# ⚡ SwiftCLI
+
+> Build Beautiful Command-Line Applications at Light Speed
+
+[![Python 3.8+](https://img.shields.io/badge/Python-3.8+-blue.svg?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org)
+[![PyPI version](https://img.shields.io/badge/View_on-PyPI-orange.svg?style=for-the-badge&logo=pypi&logoColor=white)](https://pypi.org/project/webscout/)
+[![License](https://img.shields.io/badge/License-MIT-green.svg?style=for-the-badge)](LICENSE)
+
+
+</div>
+
+## 🌟 Key Features
+
+- 🎨 **Rich Output**: Beautiful tables, progress bars, and styled text
+- 🔄 **Command Groups**: Organize commands logically
+- 🎯 **Type Safety**: Full type hints and runtime validation
+- 🔌 **Plugin System**: Extend functionality easily
+- 🌍 **Environment Support**: Load config from env vars and files
+- 🚀 **Modern Python**: Async support, type hints, and more
+
+## 📦 Installation
+
+```bash
+pip install -U webscout
+```
+
+## 🚀 Quick Start
+
+```python
+from webscout.swiftcli import CLI, option, table_output
+
+app = CLI("myapp", version="1.0.0")
+
+@app.command()
+@option("--count", "-c", type=int, default=5)
+@table_output(["ID", "Status"])
+def list_items(count: int):
+    """List system items with status"""
+    return [
+        [i, "Active" if i % 2 == 0 else "Inactive"]
+        for i in range(1, count + 1)
+    ]
+
+if __name__ == "__main__":
+    app.run()
+```
+
+Run it:
+```bash
+$ python app.py list-items --count 3
+┌────┬──────────┐
+│ ID │ Status   │
+├────┼──────────┤
+│ 1  │ Inactive │
+│ 2  │ Active   │
+│ 3  │ Inactive │
+└────┴──────────┘
+```
+
+## 📚 Documentation
+
+### Command Groups
+
+Organize related commands:
+
+```python
+@app.group()
+def db():
+    """Database operations"""
+    pass
+
+@db.command()
+@option("--force", is_flag=True)
+def migrate(force: bool):
+    """Run database migrations"""
+    print(f"Running migrations (force={force})")
+
+# Usage: python app.py db migrate --force
+```
+
+### Rich Output
+
+Beautiful progress bars and tables:
+
+```python
+@app.command()
+@progress("Processing")
+async def process():
+    """Process items with progress"""
+    for i in range(5):
+        yield f"Step {i+1}/5"
+        await asyncio.sleep(0.5)
+
+@app.command()
+@table_output(["Name", "Score"])
+def top_scores():
+    """Show top scores"""
+    return [
+        ["Alice", 100],
+        ["Bob", 95],
+        ["Charlie", 90]
+    ]
+```
+
+### Type-Safe Options
+
+```python
+from enum import Enum
+from datetime import datetime
+from typing import List, Optional
+
+class Format(Enum):
+    JSON = "json"
+    YAML = "yaml"
+    CSV = "csv"
+
+@app.command()
+@option("--format", type=Format, default=Format.JSON)
+@option("--date", type=datetime)
+@option("--tags", type=List[str])
+def export(
+    format: Format,
+    date: datetime,
+    tags: Optional[List[str]] = None
+):
+    """Export data with type validation"""
+    print(f"Exporting as {format.value}")
+    print(f"Date: {date}")
+    if tags:
+        print(f"Tags: {', '.join(tags)}")
+```
+
+### Environment & Config
+
+```python
+@app.command()
+@envvar("API_KEY", required=True)
+@config_file("~/.config/myapp.yaml")
+def api_call(api_key: str, config: dict):
+    """Make API call using config"""
+    url = config.get("api_url")
+    print(f"Calling {url} with key {api_key[:4]}...")
+```
+
+### Async Support
+
+```python
+@app.command()
+async def fetch_data():
+    """Fetch data asynchronously"""
+    async with aiohttp.ClientSession() as session:
+        async with session.get("https://api.example.com") as resp:
+            data = await resp.json()
+            return data
+```
+
+### Plugin System
+
+```python
+from webscout.swiftcli import Plugin
+
+class MetricsPlugin(Plugin):
+    def __init__(self):
+        self.start_time = None
+        
+    def before_command(self, command: str, args: list):
+        self.start_time = time.time()
+        
+    def after_command(self, command: str, args: list, result: any):
+        duration = time.time() - self.start_time
+        print(f"Command {command} took {duration:.2f}s")
+
+app.plugin_manager.register(MetricsPlugin())
+```
+
+## 🛠 Advanced Features
+
+### Custom Output Formatting
+
+```python
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+@app.command()
+def status():
+    """Show system status"""
+    table = Table(show_header=True)
+    table.add_column("Service")
+    table.add_column("Status")
+    table.add_column("Uptime")
+    
+    table.add_row("API", "✅ Online", "24h")
+    table.add_row("DB", "✅ Online", "12h")
+    table.add_row("Cache", "⚠️ Degraded", "6h")
+    
+    console.print(Panel(
+        table,
+        title="System Status",
+        border_style="green"
+    ))
+```
+
+### Command Pipelines
+
+```python
+@app.group(chain=True)
+def process():
+    """Data processing pipeline"""
+    pass
+
+@process.command()
+def extract():
+    """Extract data"""
+    return {"data": [1, 2, 3]}
+
+@process.command()
+def transform(data: dict):
+    """Transform data"""
+    return {"data": [x * 2 for x in data["data"]]}
+
+@process.command()
+def load(data: dict):
+    """Load data"""
+    print(f"Loading: {data}")
+
+# Usage: python app.py process extract transform load
+```
+
+## 🔧 Configuration
+
+### Application Config
+
+```python
+app = CLI(
+    name="myapp",
+    version="1.0.0",
+    description="My awesome CLI app",
+    config_file="~/.config/myapp.yaml",
+    auto_envvar_prefix="MYAPP",
+    plugin_folder="~/.myapp/plugins"
+)
+```
+
+### Command Config
+
+```python
+@app.command()
+@option("--config", type=click.Path(exists=True))
+@option("--verbose", "-v", count=True)
+@option("--format", type=click.Choice(["json", "yaml"]))
+def process(config: str, verbose: int, format: str):
+    """Process with configuration"""
+    pass
+```
+
+## 📋 Best Practices
+
+1. **Use Type Hints**
+   ```python
+   from typing import Optional, List, Dict
+   
+   @app.command()
+   def search(
+       query: str,
+       limit: Optional[int] = 10,
+       tags: List[str] = None
+   ) -> Dict[str, any]:
+       """Search with proper type hints"""
+       pass
+   ```
+
+2. **Structured Error Handling**
+   ```python
+   from webscout.swiftcli import CLIError
+   
+   @app.command()
+   def risky():
+       try:
+           # Risky operation
+           pass
+       except FileNotFoundError as e:
+           raise CLIError("Config file not found") from e
+       except PermissionError as e:
+           raise CLIError("Permission denied") from e
+   ```
+
+3. **Command Organization**
+   ```python
+   # commands/
+   # ├── __init__.py
+   # ├── db.py
+   # ├── auth.py
+   # └── utils.py
+   
+   from .commands import db, auth, utils
+   
+   app.add_command_group(db.commands)
+   app.add_command_group(auth.commands)
+   app.add_command_group(utils.commands)
+   ```
+
+## 🤝 Contributing
+
+Contributions are welcome! Check out our [Contributing Guide](CONTRIBUTING.md) for details.
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+<div align="center">
+
+---
+
+Made with ❤️ by the [Webscout](https://github.com/OEvortex/Webscout) team
+
+[![GitHub stars](https://img.shields.io/github/stars/OEvortex/Webscout?style=social)](https://github.com/OEvortex/Webscout)
+
+</div>

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "8.2.6"
+__version__ = "8.2.8"
 __prog__ = "webscout"

webscout/webscout_search.py

@@ -56,13 +56,7 @@ class WEBS:
         "firefox133", "firefox135",
     )  # fmt: skip
     _impersonates_os = ("android", "ios", "linux", "macos", "windows")
-    _chat_models = {
-        "gpt-4o-mini": "gpt-4o-mini",
-        "llama-3.3-70b": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-        "claude-3-haiku": "claude-3-haiku-20240307",
-        "o3-mini": "o3-mini",
-        "mistral-small-3": "mistralai/Mistral-Small-24B-Instruct-2501",
-    }
+
 
     def __init__(
         self,
@@ -119,11 +113,6 @@ class WEBS:
         self.sleep_timestamp = 0.0
 
         self._exception_event = 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 = ""
 
     def __enter__(self) -> WEBS:
         return self
@@ -203,176 +192,7 @@ class WEBS:
         resp_content = self._get_url("GET", "https://duckduckgo.com", params={"q": keywords}).content
         return _extract_vqd(resp_content, keywords)
 
-    def chat_yield(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> Iterator[str]:
-        """Initiates a 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
-        def get_turnstile_token():
-            try:
-                # Visit the DuckDuckGo chat page to get the Turnstile token
-                resp_content = 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 = 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"chat_yield() Error to get _chat_xfe: {type(ex).__name__}: {ex}"
-                ) from ex
-        # vqd
-        if not self._chat_vqd:
-            resp = 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 = 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 = 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 iter_content instead of stream
-                for chunk in resp.iter_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 as e:
-                                # 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"chat_yield() Rate limit exceeded after {max_retries} retries: {ex}") from ex
-
-                # Get a fresh Turnstile token for the retry
-                turnstile_token = get_turnstile_token()
-                if turnstile_token:
-                    json_data["cf-turnstile-response"] = turnstile_token
-
-                # Exponential backoff
-                sleep_time = 2 ** retry_count
-                sleep(sleep_time)
-
-            except Exception as ex:
-                raise WebscoutE(f"chat_yield() {type(ex).__name__}: {ex}") from ex
-
-    def chat(self, keywords: str, model: str = "gpt-4o-mini", timeout: int = 30, max_retries: int = 3) -> str:
-        """Initiates a 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.
-        """
-        answer_generator = self.chat_yield(keywords, model, timeout, max_retries)
-        return "".join(answer_generator)
 
     def text(
         self,
@@ -1361,4 +1181,4 @@ class WEBS:
                     "visibility_m": hour.get("visibility"),
                 })
 
-        return formatted_data
+        return formatted_data