webscout 6.2b0__py3-none-any.whl → 6.3__py3-none-any.whl

webscout/Extra/gguf.py

@@ -1,47 +1,221 @@
 # webscout/Extra/gguf.py
 import subprocess
 import os 
+import sys
+import logging
+import shutil
+from pathlib import Path
+from typing import List, Optional, Dict, Any
 from pyfiglet import figlet_format
 from rich.console import Console
-
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from rich.logging import RichHandler
+from rich.panel import Panel
+from rich.table import Table
+
+# Set up logging with Rich
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True)]
+)
+
+log = logging.getLogger("rich")
 console = Console()
 
-def convert(model_id, username=None, token=None, quantization_methods="q4_k_m,q5_k_m"):
-    """Converts and quantizes a Hugging Face model to GGUF format.
-
-    Args:
-        model_id (str): The Hugging Face model ID (e.g., 'google/flan-t5-xl').
-        username (str, optional): Your Hugging Face username. Required for uploads.
-        token (str, optional): Your Hugging Face API token. Required for uploads. 
-        quantization_methods (str, optional): Comma-separated quantization methods. 
-                                                Defaults to "q4_k_m,q5_k_m".
-
-    Raises:
-        ValueError: If an invalid quantization method is provided.
-    """
+class ConversionError(Exception):
+    """Custom exception for conversion errors"""
+    pass
 
-    console.print(f"[bold green]{figlet_format('GGUF Converter')}[/]\n", justify="center")
-    # List of valid quantization methods
-    valid_methods = [
-        "q2_k", "q3_k_l", "q3_k_m", "q3_k_s", 
-        "q4_0", "q4_1", "q4_k_m", "q4_k_s", 
-        "q5_0", "q5_1", "q5_k_m", "q5_k_s", 
-        "q6_k", "q8_0"
-    ]
+class ModelConverter:
+    """Handles the conversion of Hugging Face models to GGUF format."""
+    
+    VALID_METHODS = {
+        "q2_k": "2-bit quantization",
+        "q3_k_l": "3-bit quantization (large)",
+        "q3_k_m": "3-bit quantization (medium)",
+        "q3_k_s": "3-bit quantization (small)",
+        "q4_0": "4-bit quantization (version 0)",
+        "q4_1": "4-bit quantization (version 1)",
+        "q4_k_m": "4-bit quantization (medium)",
+        "q4_k_s": "4-bit quantization (small)",
+        "q5_0": "5-bit quantization (version 0)",
+        "q5_1": "5-bit quantization (version 1)",
+        "q5_k_m": "5-bit quantization (medium)",
+        "q5_k_s": "5-bit quantization (small)",
+        "q6_k": "6-bit quantization",
+        "q8_0": "8-bit quantization"
+    }
+    
+    def __init__(self, model_id: str, username: Optional[str] = None, 
+                 token: Optional[str] = None, quantization_methods: str = "q4_k_m,q5_k_m"):
+        self.model_id = model_id
+        self.username = username
+        self.token = token
+        self.quantization_methods = quantization_methods.split(',')
+        self.model_name = model_id.split('/')[-1]
+        self.workspace = Path(os.getcwd())
+        
+    def validate_inputs(self) -> None:
+        """Validates all input parameters."""
+        if not '/' in self.model_id:
+            raise ValueError("Invalid model ID format. Expected format: 'organization/model-name'")
+            
+        invalid_methods = [m for m in self.quantization_methods if m not in self.VALID_METHODS]
+        if invalid_methods:
+            raise ValueError(
+                f"Invalid quantization methods: {', '.join(invalid_methods)}.\n"
+                f"Valid methods are: {', '.join(self.VALID_METHODS.keys())}"
+            )
+            
+        if bool(self.username) != bool(self.token):
+            raise ValueError("Both username and token must be provided for upload, or neither.")
+    
+    @staticmethod
+    def check_dependencies() -> Dict[str, bool]:
+        """Check if all required dependencies are installed."""
+        dependencies = {
+            'git': 'Git version control',
+            'pip3': 'Python package installer',
+            'huggingface-cli': 'Hugging Face CLI',
+            'nvcc': 'NVIDIA CUDA Compiler (optional)'
+        }
+        
+        status = {}
+        for cmd, desc in dependencies.items():
+            status[cmd] = subprocess.run(['which', cmd], capture_output=True, text=True).returncode == 0
+            
+        return status
+    
+    def setup_llama_cpp(self) -> None:
+        """Sets up and builds llama.cpp repository."""
+        llama_path = self.workspace / "llama.cpp"
+        
+        with console.status("[bold green]Setting up llama.cpp...") as status:
+            if not llama_path.exists():
+                log.info("Cloning llama.cpp repository...")
+                subprocess.run(['git', 'clone', 'https://github.com/ggerganov/llama.cpp'], check=True)
+            
+            os.chdir(llama_path)
+            log.info("Installing requirements...")
+            subprocess.run(['pip3', 'install', '-r', 'requirements.txt'], check=True)
+            
+            has_cuda = subprocess.run(['nvcc', '--version'], capture_output=True).returncode == 0
+            
+            log.info("Building llama.cpp...")
+            subprocess.run(['make', 'clean'], check=True)
+            if has_cuda:
+                status.update("[bold green]Building with CUDA support...")
+                subprocess.run(['make', 'LLAMA_CUBLAS=1'], check=True)
+            else:
+                status.update("[bold yellow]Building without CUDA support...")
+                subprocess.run(['make'], check=True)
+            
+            os.chdir(self.workspace)
+    
+    def display_config(self) -> None:
+        """Displays the current configuration in a formatted table."""
+        table = Table(title="Configuration", show_header=True, header_style="bold magenta")
+        table.add_column("Setting", style="cyan")
+        table.add_column("Value", style="green")
+        
+        table.add_row("Model ID", self.model_id)
+        table.add_row("Model Name", self.model_name)
+        table.add_row("Username", self.username or "Not provided")
+        table.add_row("Token", "****" if self.token else "Not provided")
+        table.add_row("Quantization Methods", "\n".join(
+            f"{method} ({self.VALID_METHODS[method]})" 
+            for method in self.quantization_methods
+        ))
+        
+        console.print(Panel(table))
     
-    # Validate the selected quantization methods
-    selected_methods_list = quantization_methods.split(',')
-    for method in selected_methods_list:
-        if method not in valid_methods:
-            raise ValueError(f"Invalid method: {method}. Please select from the available methods: {', '.join(valid_methods)}")
+    def convert(self) -> None:
+        """Performs the model conversion process."""
+        try:
+            # Display banner and configuration
+            console.print(f"[bold green]{figlet_format('GGUF Converter')}[/]\n", justify="center")
+            self.display_config()
+            
+            # Validate inputs
+            self.validate_inputs()
+            
+            # Check dependencies
+            deps = self.check_dependencies()
+            missing = [name for name, installed in deps.items() if not installed and name != 'nvcc']
+            if missing:
+                raise ConversionError(f"Missing required dependencies: {', '.join(missing)}")
+            
+            # Setup llama.cpp
+            self.setup_llama_cpp()
+            
+            # Create and execute conversion script
+            script_path = self.workspace / "gguf.sh"
+            if not script_path.exists():
+                self._create_conversion_script(script_path)
+            
+            # Prepare command
+            command = ["bash", str(script_path), "-m", self.model_id]
+            if self.username and self.token:
+                command.extend(["-u", self.username, "-t", self.token])
+            command.extend(["-q", ",".join(self.quantization_methods)])
+            
+            # Execute conversion with progress tracking
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TaskProgressColumn(),
+                console=console
+            ) as progress:
+                task = progress.add_task("Converting model...", total=None)
+                
+                process = subprocess.Popen(
+                    command,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True
+                )
+                
+                while True:
+                    output = process.stdout.readline()
+                    if output == '' and process.poll() is not None:
+                        break
+                    if output:
+                        progress.update(task, description=output.strip())
+                        log.info(output.strip())
+                
+                stderr = process.stderr.read()
+                if stderr:
+                    log.warning(stderr)
+                
+                if process.returncode != 0:
+                    raise ConversionError(f"Conversion failed with return code {process.returncode}")
+                
+                progress.update(task, completed=True)
+            
+            # Display success message
+            console.print(Panel.fit(
+                "[bold green]✓[/] Conversion completed successfully!\n\n"
+                f"[cyan]Output files can be found in: {self.workspace / self.model_name}[/]",
+                title="Success",
+                border_style="green"
+            ))
+            
+        except Exception as e:
+            console.print(Panel.fit(
+                f"[bold red]✗[/] {str(e)}",
+                title="Error",
+                border_style="red"
+            ))
+            raise
     
-   # Construct the absolute path to the shell script
-    script_path = os.path.join(os.getcwd(), "gguf.sh")
-    if not os.path.exists(script_path):
-        # Create autollama.sh with the content provided
-        with open(script_path, "w") as f:
-            f.write("""
-cat << "EOF"
+    def _create_conversion_script(self, script_path: Path) -> None:
+        """Creates the conversion shell script."""
+        script_content = """cat << "EOF"
 Made with love in India
 EOF
 
@@ -143,7 +317,6 @@ fi
 
 
 
-
 # Download model 
 #todo : shall we put condition to check if model has been already downloaded? similar to autogguf?
 echo "Downloading the model..."
@@ -195,32 +368,49 @@ else
 fi
 
 echo "Script completed."
-            """)
-        # Make autollama.sh executable (using chmod)
-        os.chmod(script_path, 0o755)
+            """
+        script_path.write_text(script_content)
+        script_path.chmod(0o755)
+
+def convert(
+    model_id: str,
+    username: Optional[str] = None,
+    token: Optional[str] = None,
+    quantization_methods: str = "q4_k_m,q5_k_m"
+) -> None:
+    """Converts and quantizes a Hugging Face model to GGUF format.
 
-    # Construct the command
-    command = ["bash", script_path, "-m", model_id]
-    
-    if username:
-        command.extend(["-u", username])
-    
-    if token:
-        command.extend(["-t", token])
-    
-    if quantization_methods:
-        command.extend(["-q", quantization_methods])
-    
-    # Execute the command
-    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    Args:
+        model_id (str): The Hugging Face model ID (e.g., 'google/flan-t5-xl').
+        username (str, optional): Your Hugging Face username. Required for uploads.
+        token (str, optional): Your Hugging Face API token. Required for uploads. 
+        quantization_methods (str, optional): Comma-separated quantization methods. 
+                                            Defaults to "q4_k_m,q5_k_m".
 
-    # Print the output and error in real-time
-    for line in process.stdout:
-        print(line, end='')
+    Raises:
+        ConversionError: If any step in the conversion process fails.
+        ValueError: If invalid parameters are provided.
+    """
+    converter = ModelConverter(model_id, username, token, quantization_methods)
+    converter.convert()
 
-    for line in process.stderr:
-        print(line, end='')
+if __name__ == "__main__":
+    import argparse
     
-    process.wait()
-
-
+    parser = argparse.ArgumentParser(description="Convert Hugging Face models to GGUF format")
+    parser.add_argument("model_id", help="The Hugging Face model ID (e.g., 'google/flan-t5-xl')")
+    parser.add_argument("-u", "--username", help="Your Hugging Face username")
+    parser.add_argument("-t", "--token", help="Your Hugging Face API token")
+    parser.add_argument(
+        "-q", "--quantization-methods",
+        default="q4_k_m,q5_k_m",
+        help="Comma-separated quantization methods"
+    )
+    
+    args = parser.parse_args()
+    convert(
+        model_id=args.model_id,
+        username=args.username,
+        token=args.token,
+        quantization_methods=args.quantization_methods
+    )

webscout/Extra/weather.py

@@ -1,67 +1,172 @@
-import requests
-from rich.console import Console
-from rich.table import Table
-from yaspin import yaspin
-from pyfiglet import figlet_format
-
-console = Console()
-
-def get(location):
-    """Fetches weather data for the given location.
-
-    Args:
-        location (str): The location for which to fetch weather data.
-
-    Returns:
-        dict: A dictionary containing weather data if the request is successful,
-              otherwise a string indicating the error.
-    """
-    url = f"https://wttr.in/{location}?format=j1"
-    
-    with yaspin(text="Fetching weather data...") as spinner:
-        response = requests.get(url)
-        spinner.ok("✅ ")
-
-    if response.status_code == 200:
-        return response.json()
-    else:
-        return f"Error: Unable to fetch weather data. Status code: {response.status_code}"
-
-def print_weather(weather_data):
-    """Prints the weather data in a user-friendly format.
-
-    Args:
-        weather_data (dict or str): The weather data returned from get_weather() 
-                                  or an error message.
-    """
-    if isinstance(weather_data, str):
-        console.print(f"[bold red]Error:[/] {weather_data}")
-        return
-
-    current = weather_data['current_condition'][0]
-    location_name = weather_data['nearest_area'][0]['areaName'][0]['value']
-
-    console.print(f"[bold blue]\n{figlet_format('Weather Report')}[/]\n", justify="center")
-    console.print(f"[bold green]Weather in {location_name}:[/]\n")
-
-    table = Table(show_header=False, show_lines=True)
-    table.add_row("Temperature:", f"{current['temp_C']}°C / {current['temp_F']}°F")
-    table.add_row("Condition:", current['weatherDesc'][0]['value'])
-    table.add_row("Humidity:", f"{current['humidity']}%")
-    table.add_row("Wind:", f"{current['windspeedKmph']} km/h, {current['winddir16Point']}")
-    console.print(table)
-
-    console.print(f"\n[bold green]Forecast:[/]")
-    table = Table(show_header=True, header_style="bold cyan")
-    table.add_column("Date", style="dim", width=12)
-    table.add_column("Temperature Range")
-    table.add_column("Description")
-    
-    for day in weather_data['weather']:
-        date = day['date']
-        max_temp = day['maxtempC']
-        min_temp = day['mintempC']
-        desc = day['hourly'][4]['weatherDesc'][0]['value'] 
-        table.add_row(date, f"{min_temp}°C to {max_temp}°C", desc)
-    console.print(table)
-
+import requests
+import json
+from datetime import datetime
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.layout import Layout
+from rich.align import Align
+from rich import box
+from rich.live import Live
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.style import Style
+from rich.text import Text
+from rich.columns import Columns
+
+# Initialize Rich console with force terminal
+console = Console(force_terminal=True)
+
+def get_weather_emoji(condition: str) -> str:
+    """Get appropriate emoji for weather condition"""
+    conditions = {
+        'sunny': '*', 'clear': '*',
+        'partly cloudy': '~', 'cloudy': '=',
+        'rain': 'v', 'light rain': '.',
+        'heavy rain': 'V', 'thunderstorm': 'V',
+        'snow': '*', 'light snow': '*',
+        'mist': '-', 'fog': '-',
+        'overcast': '='
+    }
+    condition = condition.lower()
+    for key, symbol in conditions.items():
+        if key in condition:
+            return symbol
+    return '~'
+
+def get_wind_arrow(degrees: int) -> str:
+    """Convert wind degrees to arrow"""
+    arrows = ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW']
+    index = round(degrees / 45) % 8
+    return arrows[index]
+
+def format_temp(temp: str, scale='C') -> Text:
+    """Format temperature with color based on value"""
+    try:
+        value = float(temp)
+        if scale == 'C':
+            if value <= 0:
+                return Text(f"{temp}°{scale}", style="bold blue")
+            elif value >= 30:
+                return Text(f"{temp}°{scale}", style="bold red")
+            else:
+                return Text(f"{temp}°{scale}", style="bold green")
+    except ValueError:
+        pass
+    return Text(f"{temp}°{scale}")
+
+def create_current_weather_panel(data):
+    """Create panel for current weather"""
+    current = data['current_condition'][0]
+    location = data['nearest_area'][0]
+    location_name = f"{location['areaName'][0]['value']}, {location['country'][0]['value']}"
+    
+    weather_desc = current['weatherDesc'][0]['value']
+    symbol = get_weather_emoji(weather_desc)
+    
+    # Create weather info table
+    table = Table(show_header=False, box=box.ROUNDED, expand=True)
+    table.add_column("Label", style="cyan")
+    table.add_column("Value", justify="right")
+    
+    table.add_row("Location", f"@ {location_name}")
+    table.add_row("Condition", f"{symbol} {weather_desc}")
+    table.add_row("Temperature", 
+                 f"{format_temp(current['temp_C'])} / {format_temp(current['temp_F'], 'F')}")
+    table.add_row("Feels Like",
+                 f"{format_temp(current['FeelsLikeC'])} / {format_temp(current['FeelsLikeF'], 'F')}")
+    table.add_row("Humidity", f"~ {current['humidity']}%")
+    
+    wind_dir = get_wind_arrow(int(current['winddirDegree']))
+    table.add_row("Wind", 
+                 f"> {current['windspeedKmph']} km/h {wind_dir} ({current['winddir16Point']})")
+    table.add_row("Visibility", f"O {current['visibility']} km")
+    table.add_row("Pressure", f"# {current['pressure']} mb")
+    
+    return Panel(table, title="[bold]Current Weather[/]", border_style="blue")
+
+def create_forecast_panel(data):
+    """Create panel for weather forecast"""
+    table = Table(show_header=True, box=box.ROUNDED, expand=True)
+    table.add_column("Date", style="cyan")
+    table.add_column("Condition")
+    table.add_column("Temp (°C)")
+    table.add_column("Rain")
+    table.add_column("Wind")
+    
+    for day in data['weather'][:3]:
+        date = datetime.strptime(day['date'], '%Y-%m-%d').strftime('%a, %b %d')
+        # Get mid-day conditions (noon)
+        noon = day['hourly'][4]
+        condition = noon['weatherDesc'][0]['value']
+        symbol = get_weather_emoji(condition)
+        temp_range = f"{day['mintempC']}° - {day['maxtempC']}°"
+        rain_chance = f"v {noon['chanceofrain']}%"
+        wind = f"> {noon['windspeedKmph']} km/h"
+        
+        table.add_row(
+            date,
+            f"{symbol} {condition}",
+            temp_range,
+            rain_chance,
+            wind
+        )
+    
+    return Panel(table, title="[bold]3-Day Forecast[/]", border_style="blue")
+
+def get_weather(location: str):
+    """Get weather data with progress indicator"""
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task(description="Fetching weather data...", total=None)
+        try:
+            response = requests.get(f"https://wttr.in/{location}?format=j1", timeout=10)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            console.print(f"[red]Error fetching weather data: {str(e)}[/]")
+            return None
+
+def display_weather(data):
+    """Display weather information in a beautiful layout"""
+    if not data:
+        return
+    
+    # Create layout
+    layout = Layout()
+    layout.split_column(
+        Layout(name="current", size=15),
+        Layout(name="forecast", size=10)
+    )
+    
+    # Update layout sections
+    layout["current"].update(create_current_weather_panel(data))
+    layout["forecast"].update(create_forecast_panel(data))
+    
+    # Print layout with a title
+    console.print("\n")
+    console.print(Align.center("[bold blue]Weather Report[/]"))
+    console.print("\n")
+    console.print(layout)
+    console.print("\n")
+
+def main():
+    """Main function to run the weather app"""
+    try:
+        console.clear()
+        console.print("\n[bold cyan]* Weather Information[/]\n")
+        location = console.input("[cyan]Enter location: [/]")
+        
+        weather_data = get_weather(location)
+        if weather_data:
+            display_weather(weather_data)
+            
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Operation cancelled by user[/]")
+    except Exception as e:
+        console.print(f"\n[bold red]Unexpected error:[/] {str(e)}")
+
+if __name__ == "__main__":
+    main()