webscout 6.3__py3-none-any.whl → 6.4__py3-none-any.whl

webscout/cli.py

@@ -1,22 +1,19 @@
-import csv
-import logging
 import os
+import sys
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 from urllib.parse import unquote
 from pathlib import Path
-import click
+from .swiftcli import CLI, option, argument, group
 from curl_cffi import requests
 import pyreqwest_impersonate as pri
 from .webscout_search import WEBS
 from .utils import json_dumps, json_loads
 from .version import __version__
-from .interactive import interactive_session
-
-# Import rich for panel interface
+from .Litlogger import LitLogger, LogFormat, ColorScheme
+from rich.console import Console
 from rich.panel import Panel
 from rich.markdown import Markdown
-from rich.console import Console
 from rich.table import Table
 from rich.style import Style
 from rich.text import Text
@@ -26,7 +23,12 @@ from rich.prompt import Prompt, Confirm
 from rich.columns import Columns
 from pyfiglet import figlet_format
 
-logger = logging.getLogger(__name__)
+logger = LitLogger(
+    name="webscout",
+    format=LogFormat.MODERN_EMOJI,
+    color_scheme=ColorScheme.CYBERPUNK,
+    console_output=True
+)
 
 COLORS = {
     0: "black",
@@ -60,296 +62,266 @@ def _print_data(data):
                 if v:
                     width = 300 if k in ("content", "href", "image", "source", "thumbnail", "url") else 78
                     k = "language" if k == "detected_language" else k
-                    text = click.wrap_text(
-                        f"{v}", width=width, initial_indent="", subsequent_indent=" " * 18, preserve_paragraphs=True
-                    ).replace("\n", "\n\n")
+                    text = Text(f"{v}", style="white")
+                    text = text.wrap(width=width, initial_indent="", subsequent_indent=" " * 18, preserve_paragraphs=True)
                 else:
-                    text = v
+                    text = Text(v, style="white")
                 table.add_row(k, text)
 
             # Only the Panel has the title now
             console.print(Panel(table, title=f"Result {i}", expand=False, style="green on black"))
             console.print("\n") 
-            
-
-def _sanitize_keywords(keywords):
-    """Sanitizes keywords for file names and paths. Removes invalid characters like ':'. """
-    keywords = (
-        keywords.replace("filetype", "")
-        .replace(":", "")
-        .replace('"', "'")
-        .replace("site", "")
-        .replace(" ", "_")
-        .replace("/", "_")
-        .replace("\\", "_")
-        .replace(" ", "")
-    )
-    return keywords
-
-@click.group(chain=True)
-def cli():
-    """webscout CLI tool - Search the web with a rich UI."""
-    console = Console()
-    console.print(f"[bold blue]{figlet_format('Webscout')}[/]\n", justify="center")
-
-def safe_entry_point():
-    try:
-        cli()
-    except Exception as ex:
-        click.echo(f"{type(ex).__name__}: {ex}")
 
+# Initialize CLI app
+app = CLI(name="webscout", help="Search the web with a rich UI", version=__version__)
 
-@cli.command()
+@app.command()
 def version():
-    """Shows the current version of webscout."""
+    """Show the version of webscout."""
     console = Console()
-    console.print(Panel(Text(f"webscout v{__version__}", style="cyan"), title="Version", expand=False))
+    console.print(f"[bold green]webscout[/bold green] version: {__version__}")
 
-
-@cli.command()
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
-def chat(proxy):
+@app.command()
+@option("--proxy", help="Proxy URL to use for requests")
+@option("--model", "-m", help="AI model to use", default="gpt-4o-mini", type=str)
+def chat(proxy: str = None, model: str = "gpt-4o-mini"):
     """Interactive AI chat using DuckDuckGo's AI."""
-    models = ["gpt-3.5", "claude-3-haiku", "llama-3-70b", "mixtral-8x7b"]
-    client = WEBS(proxy=proxy)
-
+    webs = WEBS(proxy=proxy)
     console = Console()
-    console.print(Panel(Text("Available AI Models:", style="cyan"), title="DuckDuckGo AI Chat", expand=False))
-    console.print(Columns([Panel(Text(model, justify="center"), expand=True) for model in models]))
-    chosen_model_idx = Prompt.ask("[bold cyan]Choose a model by entering its number[/] [1]", choices=[str(i) for i in range(1, len(models) + 1)], default="1")
-    chosen_model_idx = int(chosen_model_idx) - 1
-    model = models[chosen_model_idx]
-    console.print(f"[bold green]Using model:[/] {model}")
-
-    while True:
-        user_input = Prompt.ask(f"{'-'*78}\n[bold blue]You:[/]")
-        if not user_input.strip():
-            break
-
-        resp_answer = client.chat(keywords=user_input, model=model)
-        text = click.wrap_text(resp_answer, width=78, preserve_paragraphs=True)
-        console.print(Panel(Text(f"AI: {text}", style="green"), title="AI Response"))
-
-        if "exit" in user_input.lower() or "quit" in user_input.lower():
-            console.print(Panel(Text("Exiting chat session.", style="cyan"), title="Goodbye", expand=False))
-            break
-
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Keywords for text search.")
-@click.option("-r", "--region", default="wt-wt", help="Region (e.g., wt-wt, us-en, ru-ru) - See https://duckduckgo.com/params for more options.")
-@click.option("-s", "--safesearch", default="moderate", type=click.Choice(["on", "moderate", "off"]), help="Safe search level.")
-@click.option("-t", "--timelimit", default=None, type=click.Choice(["d", "w", "m", "y"]), help="Time limit (d: day, w: week, m: month, y: year).")
-@click.option("-m", "--max_results", default=20, help="Maximum number of results to retrieve (default: 20).")
-@click.option("-b", "--backend", default="api", type=click.Choice(["api", "html", "lite"]), help="Backend to use (api, html, lite).")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
-def text(keywords, region, safesearch, timelimit, backend, max_results, proxy):
-    """Performs a text search using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).text(
-        keywords=keywords,
-        region=region,
-        safesearch=safesearch,
-        timelimit=timelimit,
-        backend=backend,
-        max_results=max_results,
-    )
-    _print_data(data)
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Keywords for answers search.")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
-def answers(keywords, proxy):
-    """Performs an answers search using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).answers(keywords=keywords)
-    _print_data(data)
-
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Keywords for images search.")
-@click.option("-r", "--region", default="wt-wt", help="Region (e.g., wt-wt, us-en, ru-ru) - See https://duckduckgo.com/params for more options.")
-@click.option("-s", "--safesearch", default="moderate", type=click.Choice(["on", "moderate", "off"]), help="Safe search level.")
-@click.option("-t", "--timelimit", default=None, type=click.Choice(["Day", "Week", "Month", "Year"]), help="Time limit (Day, Week, Month, Year).")
-@click.option("-size", "--size", default=None, type=click.Choice(["Small", "Medium", "Large", "Wallpaper"]), help="Image size (Small, Medium, Large, Wallpaper).")
-@click.option(
-    "-c",
-    "--color",
-    default=None,
-    type=click.Choice(
-        [
-            "color",
-            "Monochrome",
-            "Red",
-            "Orange",
-            "Yellow",
-            "Green",
-            "Blue",
-            "Purple",
-            "Pink",
-            "Brown",
-            "Black",
-            "Gray",
-            "Teal",
-            "White",
-        ]
-    ),
-    help="Image color (color, Monochrome, Red, Orange, Yellow, Green, Blue, Purple, Pink, Brown, Black, Gray, Teal, White).",
-)
-@click.option(
-    "-type", "--type_image", default=None, type=click.Choice(["photo", "clipart", "gif", "transparent", "line"]), help="Image type (photo, clipart, gif, transparent, line)."
-)
-@click.option("-l", "--layout", default=None, type=click.Choice(["Square", "Tall", "Wide"]), help="Image layout (Square, Tall, Wide).")
-@click.option(
-    "-lic",
-    "--license_image",
-    default=None,
-    type=click.Choice(["any", "Public", "Share", "Modify", "ModifyCommercially"]),
-    help="Image license (any, Public, Share, Modify, ModifyCommercially).",
-)
-@click.option("-m", "--max_results", default=90, help="Maximum number of results to retrieve (default: 90).")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
+    
+    # Display header
+    console.print(f"[bold blue]{figlet_format('Webscout Chat')}[/]\n", justify="center")
+    console.print(f"[bold green]Using model:[/] {model}\n")
+    console.print("[cyan]Type your message and press Enter. Press Ctrl+C or type 'exit' to quit.[/]\n")
+    
+    # Start chat loop
+    try:
+        while True:
+            try:
+                user_input = input("You: ").strip()
+                if not user_input or user_input.lower() in ['exit', 'quit']:
+                    break
+                    
+                logger.info(f"Sending message to {model}")
+                response = webs.chat(keywords=user_input, model=model)
+                console.print(f"\nAI: {response}\n")
+                logger.success("Received response from AI")
+                
+            except Exception as e:
+                logger.error(f"Error in chat: {str(e)}")
+                console.print(f"[bold red]Error:[/] {str(e)}\n")
+                
+    except KeyboardInterrupt:
+        logger.info("Chat session terminated by user")
+        
+    console.print("\n[cyan]Chat session ended. Goodbye![/]")
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords")
+@option("--region", "-r", help="Region for search results", default="wt-wt")
+@option("--safesearch", "-s", help="SafeSearch setting", default="moderate")
+@option("--timelimit", "-t", help="Time limit for results", default=None)
+@option("--backend", "-b", help="Search backend to use", default="api")
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=25)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+def text(keywords: str, region: str, safesearch: str, timelimit: str, backend: str, max_results: int, proxy: str = None):
+    """Perform a text search using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.text(keywords, region, safesearch, timelimit, backend, max_results)
+    except Exception as e:
+        logger.error(f"Error in text search: {e}")
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords")
+@option("--region", "-r", help="Region for search results", default="wt-wt")
+@option("--safesearch", "-s", help="SafeSearch setting", default="moderate")
+@option("--timelimit", "-t", help="Time limit for results", default=None)
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=25)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+def answers(keywords: str, region: str, safesearch: str, timelimit: str, max_results: int, proxy: str = None):
+    """Perform an answers search using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.answers(keywords, region, safesearch, timelimit, max_results)
+    except Exception as e:
+        logger.error(f"Error in answers search: {e}")
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords")
+@option("--region", "-r", help="Region for search results", default="wt-wt")
+@option("--safesearch", "-s", help="SafeSearch setting", default="moderate")
+@option("--timelimit", "-t", help="Time limit for results", default=None)
+@option("--size", "-size", help="Image size", default=None)
+@option("--color", "-c", help="Image color", default=None)
+@option("--type", "-type", help="Image type", default=None)
+@option("--layout", "-l", help="Image layout", default=None)
+@option("--license", "-lic", help="Image license", default=None)
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=90)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
 def images(
-    keywords,
-    region,
-    safesearch,
-    timelimit,
-    size,
-    color,
-    type_image,
-    layout,
-    license_image,
-    max_results,
-    proxy,
+    keywords: str,
+    region: str,
+    safesearch: str,
+    timelimit: str,
+    size: str,
+    color: str,
+    type: str,
+    layout: str,
+    license: str,
+    max_results: int,
+    proxy: str = None,
 ):
-    """Performs an images search using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).images(
-        keywords=keywords,
-        region=region,
-        safesearch=safesearch,
-        timelimit=timelimit,
-        size=size,
-        color=color,
-        type_image=type_image,
-        layout=layout,
-        license_image=license_image,
-        max_results=max_results,
-    )
-    _print_data(data)
-
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Keywords for videos search.")
-@click.option("-r", "--region", default="wt-wt", help="Region (e.g., wt-wt, us-en, ru-ru) - See https://duckduckgo.com/params for more options.")
-@click.option("-s", "--safesearch", default="moderate", type=click.Choice(["on", "moderate", "off"]), help="Safe search level.")
-@click.option("-t", "--timelimit", default=None, type=click.Choice(["d", "w", "m"]), help="Time limit (d: day, w: week, m: month).")
-@click.option("-res", "--resolution", default=None, type=click.Choice(["high", "standart"]), help="Video resolution (high, standart).")
-@click.option("-d", "--duration", default=None, type=click.Choice(["short", "medium", "long"]), help="Video duration (short, medium, long).")
-@click.option("-lic", "--license_videos", default=None, type=click.Choice(["creativeCommon", "youtube"]), help="Video license (creativeCommon, youtube).")
-@click.option("-m", "--max_results", default=50, help="Maximum number of results to retrieve (default: 50).")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
-def videos(keywords, region, safesearch, timelimit, resolution, duration, license_videos, max_results, proxy):
-    """Performs a videos search using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).videos(
-        keywords=keywords,
-        region=region,
-        safesearch=safesearch,
-        timelimit=timelimit,
-        resolution=resolution,
-        duration=duration,
-        license_videos=license_videos,
-        max_results=max_results,
-    )
-    _print_data(data)
-
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Keywords for news search.")
-@click.option("-r", "--region", default="wt-wt", help="Region (e.g., wt-wt, us-en, ru-ru) - See https://duckduckgo.com/params for more options.")
-@click.option("-s", "--safesearch", default="moderate", type=click.Choice(["on", "moderate", "off"]), help="Safe search level.")
-@click.option("-t", "--timelimit", default=None, type=click.Choice(["d", "w", "m", "y"]), help="Time limit (d: day, w: week, m: month, y: year).")
-@click.option("-m", "--max_results", default=25, help="Maximum number of results to retrieve (default: 25).")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
-def news(keywords, region, safesearch, timelimit, max_results, proxy):
-    """Performs a news search using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).news(
-        keywords=keywords, region=region, safesearch=safesearch, timelimit=timelimit, max_results=max_results
-    )
-    _print_data(data)
-
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Keywords for maps search.")
-@click.option("-p", "--place", default=None, help="Simplified search - if set, the other parameters are not used.")
-@click.option("-s", "--street", default=None, help="House number/street.")
-@click.option("-c", "--city", default=None, help="City of search.")
-@click.option("-county", "--county", default=None, help="County of search.")
-@click.option("-state", "--state", default=None, help="State of search.")
-@click.option("-country", "--country", default=None, help="Country of search.")
-@click.option("-post", "--postalcode", default=None, help="Postal code of search.")
-@click.option("-lat", "--latitude", default=None, help="Geographic coordinate (north-south position).")
-@click.option("-lon", "--longitude", default=None, help="Geographic coordinate (east-west position); if latitude and longitude are set, the other parameters are not used.")
-@click.option("-r", "--radius", default=0, help="Expand the search square by the distance in kilometers.")
-@click.option("-m", "--max_results", default=50, help="Number of results (default: 50).")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
+    """Perform an images search using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.images(keywords, region, safesearch, timelimit, size, color, type, layout, license, max_results)
+    except Exception as e:
+        logger.error(f"Error in images search: {e}")
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords")
+@option("--region", "-r", help="Region for search results", default="wt-wt")
+@option("--safesearch", "-s", help="SafeSearch setting", default="moderate")
+@option("--timelimit", "-t", help="Time limit for results", default=None)
+@option("--resolution", "-res", help="Video resolution", default=None)
+@option("--duration", "-d", help="Video duration", default=None)
+@option("--license", "-lic", help="Video license", default=None)
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=50)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+def videos(
+    keywords: str,
+    region: str,
+    safesearch: str,
+    timelimit: str,
+    resolution: str,
+    duration: str,
+    license: str,
+    max_results: int,
+    proxy: str = None,
+):
+    """Perform a videos search using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.videos(keywords, region, safesearch, timelimit, resolution, duration, license, max_results)
+    except Exception as e:
+        logger.error(f"Error in videos search: {e}")
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords")
+@option("--region", "-r", help="Region for search results", default="wt-wt")
+@option("--safesearch", "-s", help="SafeSearch setting", default="moderate")
+@option("--timelimit", "-t", help="Time limit for results", default=None)
+@option("--max-results", "-m", help="Maximum number of results", type=int, default=25)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+def news(keywords: str, region: str, safesearch: str, timelimit: str, max_results: int, proxy: str = None):
+    """Perform a news search using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.news(keywords, region, safesearch, timelimit, max_results)
+    except Exception as e:
+        logger.error(f"Error in news search: {e}")
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords")
+@option("--place", "-p", help="Simplified search - if set, the other parameters are not used")
+@option("--street", "-s", help="House number/street")
+@option("--city", "-c", help="City of search")
+@option("--county", "-county", help="County of search")
+@option("--state", "-state", help="State of search")
+@option("--country", "-country", help="Country of search")
+@option("--postalcode", "-post", help="Postal code of search")
+@option("--latitude", "-lat", help="Geographic coordinate (north-south position)")
+@option("--longitude", "-lon", help="Geographic coordinate (east-west position); if latitude and longitude are set, the other parameters are not used")
+@option("--radius", "-r", help="Expand the search square by the distance in kilometers", type=int, default=0)
+@option("--max-results", "-m", help="Number of results", type=int, default=50)
+@option("--proxy", "-p", help="Proxy URL to use for requests")
 def maps(
-    keywords,
-    place,
-    street,
-    city,
-    county,
-    state,
-    country,
-    postalcode,
-    latitude,
-    longitude,
-    radius,
-    max_results,
-    proxy,
+    keywords: str,
+    place: str,
+    street: str,
+    city: str,
+    county: str,
+    state: str,
+    country: str,
+    postalcode: str,
+    latitude: str,
+    longitude: str,
+    radius: int,
+    max_results: int,
+    proxy: str = None,
 ):
-    """Performs a maps search using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).maps(
-        keywords=keywords,
-        place=place,
-        street=street,
-        city=city,
-        county=county,
-        state=state,
-        country=country,
-        postalcode=postalcode,
-        latitude=latitude,
-        longitude=longitude,
-        radius=radius,
-        max_results=max_results,
-    )
-    _print_data(data)
-
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Text for translation.")
-@click.option("-f", "--from_", help="Language to translate from (defaults automatically).")
-@click.option("-t", "--to", default="en", help="Language to translate to (default: 'en').")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
-def translate(keywords, from_, to, proxy):
-    """Performs translation using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).translate(keywords=keywords, from_=from_, to=to)
-    _print_data(data)
-
-
-@cli.command()
-@click.option("-k", "--keywords", required=True, help="Keywords for query.")
-@click.option("-r", "--region", default="wt-wt", help="Region (e.g., wt-wt, us-en, ru-ru) - See https://duckduckgo.com/params for more options.")
-@click.option("-p", "--proxy", default=None, help="Proxy to send requests (e.g., socks5://localhost:9150)")
-def suggestions(keywords, region, proxy):
-    """Performs a suggestions search using DuckDuckGo API with a rich UI."""
-    data = WEBS(proxy=proxy).suggestions(keywords=keywords, region=region)
-    _print_data(data)
-
-
-@cli.command()
-@click.option("--proxy", help="Proxy to use for requests", default=None)
-def interactive(proxy):
+    """Perform a maps search using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.maps(
+            keywords,
+            place,
+            street,
+            city,
+            county,
+            state,
+            country,
+            postalcode,
+            latitude,
+            longitude,
+            radius,
+            max_results,
+        )
+    except Exception as e:
+        logger.error(f"Error in maps search: {e}")
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Text for translation")
+@option("--from", "-f", help="Language to translate from (defaults automatically)")
+@option("--to", "-t", help="Language to translate to (default: 'en')", default="en")
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+def translate(keywords: str, from_: str, to: str, proxy: str = None):
+    """Perform translation using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.translate(keywords, from_, to)
+    except Exception as e:
+        logger.error(f"Error in translation: {e}")
+        raise e
+
+@app.command()
+@option("--keywords", "-k", help="Search keywords")
+@option("--region", "-r", help="Region for search results", default="wt-wt")
+@option("--proxy", "-p", help="Proxy URL to use for requests")
+def suggestions(keywords: str, region: str, proxy: str = None):
+    """Perform a suggestions search using DuckDuckGo API."""
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.suggestions(keywords, region)
+    except Exception as e:
+        logger.error(f"Error in suggestions search: {e}")
+        raise e
+
+@app.command()
+@option("--proxy", help="Proxy URL to use for requests")
+def interactive(proxy: str = None):
     """Start an interactive search session with AI-powered responses."""
-    interactive_session()
+    webs = WEBS(proxy=proxy)
+    try:
+        webs.interactive()
+    except Exception as e:
+        logger.error(f"Error in interactive mode: {e}")
+        raise e
 
+def main():
+    """Main entry point for the CLI."""
+    try:
+        app.run()
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        sys.exit(1)
 
 if __name__ == "__main__":
-    cli(prog_name="WEBS")
+    main()