webscout 7.4__py3-none-any.whl → 7.6__py3-none-any.whl

webscout/Extra/weather.py

@@ -1,172 +1,194 @@
+"""
+Weather information module with a clean, strongly-typed API structure.
+
+This module provides a simple client for fetching weather data
+from the wttr.in service with proper typing and a consistent interface.
+"""
+
 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_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_emoji(weather_desc)
+from typing import List, Dict, Any, Optional
+
+
+class CurrentCondition:
+    """Current weather conditions with strongly typed properties."""
     
-    # 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")
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with current condition data.
+        
+        Args:
+            data: Current condition data dictionary from wttr.in
+        """
+        self.temp_c: Optional[str] = data.get('temp_C')
+        self.temp_f: Optional[str] = data.get('temp_F')
+        self.feels_like_c: Optional[str] = data.get('FeelsLikeC')
+        self.feels_like_f: Optional[str] = data.get('FeelsLikeF')
+        self.weather_desc: str = data.get('weatherDesc', [{}])[0].get('value', '')
+        self.weather_code: Optional[str] = data.get('weatherCode')
+        self.humidity: Optional[str] = data.get('humidity')
+        self.visibility: Optional[str] = data.get('visibility')
+        self.pressure: Optional[str] = data.get('pressure')
+        self.wind_speed_kmph: Optional[str] = data.get('windspeedKmph')
+        self.wind_direction: Optional[str] = data.get('winddir16Point')
+        self.wind_degree: Optional[str] = data.get('winddirDegree')
+
+
+class Location:
+    """Location information with strongly typed properties."""
     
-    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']}%")
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with location data.
+        
+        Args:
+            data: Location data dictionary from wttr.in
+        """
+        self.name: str = data.get('areaName', [{}])[0].get('value', '')
+        self.country: str = data.get('country', [{}])[0].get('value', '')
+        self.region: str = data.get('region', [{}])[0].get('value', '')
+        self.latitude: Optional[str] = data.get('latitude')
+        self.longitude: Optional[str] = data.get('longitude')
+
+
+class HourlyForecast:
+    """Hourly forecast information with strongly typed properties."""
     
-    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")
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with hourly forecast data.
+        
+        Args:
+            data: Hourly forecast data dictionary from wttr.in
+        """
+        self.time: Optional[str] = data.get('time')
+        self.temp_c: Optional[str] = data.get('tempC')
+        self.temp_f: Optional[str] = data.get('tempF')
+        self.weather_desc: str = data.get('weatherDesc', [{}])[0].get('value', '')
+        self.weather_code: Optional[str] = data.get('weatherCode')
+        self.wind_speed_kmph: Optional[str] = data.get('windspeedKmph')
+        self.wind_direction: Optional[str] = data.get('winddir16Point')
+        self.feels_like_c: Optional[str] = data.get('FeelsLikeC')
+        self.feels_like_f: Optional[str] = data.get('FeelsLikeF')
+        self.chance_of_rain: Optional[str] = data.get('chanceofrain')
+        self.chance_of_snow: Optional[str] = data.get('chanceofsnow')
+
+
+class DayForecast:
+    """Daily forecast information with strongly typed properties."""
     
-    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")
+    def __init__(self, data: Dict[str, Any]) -> None:
+        """Initialize with daily forecast data.
+        
+        Args:
+            data: Daily forecast data dictionary from wttr.in
+        """
+        self.date: Optional[str] = data.get('date')
+        self.date_formatted: Optional[str] = None
+        if self.date:
+            try:
+                self.date_formatted = datetime.strptime(self.date, '%Y-%m-%d').strftime('%a, %b %d')
+            except ValueError:
+                pass
+        
+        self.max_temp_c: Optional[str] = data.get('maxtempC')
+        self.max_temp_f: Optional[str] = data.get('maxtempF')
+        self.min_temp_c: Optional[str] = data.get('mintempC')
+        self.min_temp_f: Optional[str] = data.get('mintempF')
+        self.avg_temp_c: Optional[str] = data.get('avgtempC')
+        self.avg_temp_f: Optional[str] = data.get('avgtempF')
+        self.sun_hour: Optional[str] = data.get('sunHour')
+        
+        # Parse astronomy data (simplified)
+        if data.get('astronomy') and len(data.get('astronomy', [])) > 0:
+            astro = data.get('astronomy', [{}])[0]
+            self.sunrise: Optional[str] = astro.get('sunrise')
+            self.sunset: Optional[str] = astro.get('sunset')
+            self.moon_phase: Optional[str] = astro.get('moon_phase')
+        else:
+            self.sunrise = self.sunset = self.moon_phase = None
+        
+        # Parse hourly forecasts
+        self.hourly: List[HourlyForecast] = []
+        for hour_data in data.get('hourly', []):
+            self.hourly.append(HourlyForecast(hour_data))
+
+
+class Weather:
+    """Weather response object with strongly typed properties."""
     
-    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_emoji(condition)
-        temp_range = f"{day['mintempC']}° - {day['maxtempC']}°"
-        rain_chance = f"v {noon['chanceofrain']}%"
-        wind = f"> {noon['windspeedKmph']} km/h"
+    def __init__(self, data: Optional[Dict[str, Any]] = None) -> None:
+        """Initialize with weather data.
         
-        table.add_row(
-            date,
-            f"{symbol} {condition}",
-            temp_range,
-            rain_chance,
-            wind
-        )
+        Args:
+            data: Weather data dictionary from wttr.in
+        """
+        if not data:
+            self.current_condition = None
+            self.location = None
+            self.forecast_days = []
+            return
+            
+        # Parse current condition
+        self.current_condition: Optional[CurrentCondition] = None
+        if data.get('current_condition') and len(data.get('current_condition', [])) > 0:
+            self.current_condition = CurrentCondition(data.get('current_condition', [{}])[0])
+            
+        # Parse location
+        self.location: Optional[Location] = None
+        if data.get('nearest_area') and len(data.get('nearest_area', [])) > 0:
+            self.location = Location(data.get('nearest_area', [{}])[0])
+            
+        # Parse forecast days
+        self.forecast_days: List[DayForecast] = []
+        for day_data in data.get('weather', []):
+            self.forecast_days.append(DayForecast(day_data))
+    
+    @property
+    def today(self) -> Optional[DayForecast]:
+        """Get today's forecast."""
+        return self.forecast_days[0] if self.forecast_days else None
+    
+    @property
+    def tomorrow(self) -> Optional[DayForecast]:
+        """Get tomorrow's forecast."""
+        return self.forecast_days[1] if len(self.forecast_days) > 1 else None
+    
+    @property
+    def summary(self) -> str:
+        """Get a simple text summary of current weather."""
+        if not self.current_condition or not self.location:
+            return "Weather data not available"
+            
+        return f"{self.location.name}, {self.location.country}: {self.current_condition.weather_desc}, {self.current_condition.temp_c}°C ({self.current_condition.temp_f}°F)"
+
+
+class WeatherClient:
+    """Client for fetching weather information."""
     
-    return Panel(table, title="[bold]3-Day Forecast[/]", border_style="blue")
-
-def get(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)
+    def get_weather(self, location: str) -> Weather:
+        """Get weather for the specified location.
+        
+        Args:
+            location: Location to get weather for (city name, zip code, etc.)
+            
+        Returns:
+            Weather object containing all weather data
+        """
         try:
             response = requests.get(f"https://wttr.in/{location}?format=j1", timeout=10)
             response.raise_for_status()
-            return response.json()
+            return Weather(response.json())
         except Exception as e:
-            console.print(f"[red]Error fetching weather data: {str(e)}[/]")
-            return None
+            print(f"Error fetching weather data: {str(e)}")
+            return Weather()
 
-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))
+
+def get(location: str) -> Weather:
+    """Convenience function to get weather for a location.
     
-    # 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: [/]")
+    Args:
+        location: Location to get weather for
         
-        weather_data = get(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()
+    Returns:
+        Weather object containing all weather data
+    """
+    client = WeatherClient()
+    return client.get_weather(location)

webscout/Extra/weather_ascii.py

@@ -1,23 +1,76 @@
+"""
+Weather ASCII art visualization module with a simple, strongly-typed API.
+
+This module provides a clean interface for fetching weather information
+in ASCII art format using the wttr.in service.
+"""
+
 import requests
-from rich.console import Console
-from webscout.zeroart import figlet_format
+from typing import Dict, Optional, Any
 
-console = Console()
-def get(location):
-    """Fetches ASCII art weather data for the given location.
-    Args:
-        location (str): The location for which to fetch weather data.
 
+class WeatherAscii:
+    """Container for ASCII weather data with a simple API."""
+    
+    def __init__(self, content: str) -> None:
+        """Initialize with ASCII weather content.
+        
+        Args:
+            content: ASCII weather data or error message
+        """
+        self._content = content
+        
+    @property
+    def content(self) -> str:
+        """Get the ASCII content, similar to choices.message.content in OpenAI API."""
+        return self._content
+    
+    def __str__(self) -> str:
+        """String representation of ASCII weather."""
+        return self.content
+
+
+class WeatherAsciiClient:
+    """Client for fetching weather information in ASCII art."""
+    
+    def get_weather(self, location: str, params: Optional[Dict[str, Any]] = None) -> WeatherAscii:
+        """Get ASCII weather for a location.
+        
+        Args:
+            location: The location for which to fetch weather data
+            params: Additional parameters for the request
+            
+        Returns:
+            WeatherAscii object containing ASCII art weather data
+        """
+        url = f"https://wttr.in/{location}"
+        headers = {'User-Agent': 'curl'}
+        
+        try:
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            response.raise_for_status()
+            
+            if response.status_code == 200:
+                # Remove the footer line from wttr.in
+                ascii_weather = "\n".join(response.text.splitlines()[:-1])
+                return WeatherAscii(ascii_weather)
+            else:
+                error_msg = f"Error: Unable to fetch weather data. Status code: {response.status_code}"
+                return WeatherAscii(error_msg)
+        except requests.exceptions.RequestException as e:
+            return WeatherAscii(f"Error: {str(e)}")
+
+
+def get(location: str, params: Optional[Dict[str, Any]] = None) -> WeatherAscii:
+    """Convenience function to get ASCII weather for a location.
+    
+    Args:
+        location: Location to get weather for
+        params: Additional parameters for the request
+        
     Returns:
-        str: ASCII art weather report if the request is successful,
-             otherwise an error message.
+        WeatherAscii object containing ASCII art weather data
     """
-    console.print(f"[bold green]{figlet_format('Weather')}")
-    url = f"https://wttr.in/{location}"
-    response = requests.get(url, headers={'User-Agent': 'curl'}) 
-
-    if response.status_code == 200:
-        return "\n".join(response.text.splitlines()[:-1]) 
-    else:
-        return f"Error: Unable to fetch weather data. Status code: {response.status_code}"
+    client = WeatherAsciiClient()
+    return client.get_weather(location, params)
 

webscout/Litlogger/core/logger.py

@@ -4,11 +4,10 @@ import sys
 import threading
 import traceback
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import List, Union
 
 from ..core.level import LogLevel
 from ..styles.formats import LogFormat
-from ..styles.colors import LogColors
 
 class Logger:
     # Emoji mappings for different log levels

webscout/Litlogger/handlers/file.py

@@ -2,7 +2,7 @@ import os
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Union
+from typing import Union
 from ..core.level import LogLevel
 
 class FileHandler:

webscout/Litlogger/styles/formats.py

@@ -1,5 +1,3 @@
-from enum import Enum
-from typing import Dict
 
 class LogFormat:
     # Basic formats with improved styling

webscout/Litlogger/utils/detectors.py

@@ -1,6 +1,5 @@
 import re
 import sys
-import traceback
 from typing import Optional
 from ..core.level import LogLevel
 

webscout/Provider/AISEARCH/DeepFind.py

@@ -1,6 +1,5 @@
 from uuid import uuid4
 import requests
-import json
 import re
 from typing import Any, Dict, Generator, Optional
 

webscout/Provider/AISEARCH/ISou.py

@@ -1,7 +1,7 @@
 import requests
 import json
 import re
-from typing import Dict, Optional, Generator, Union, Any
+from typing import Dict, Optional, Generator, Any
 from webscout import LitAgent
 from webscout import exceptions
 from webscout.AIbase import AISearch

webscout/Provider/AISEARCH/felo_search.py

@@ -1,4 +1,3 @@
-import re
 import requests
 from uuid import uuid4
 import json

webscout/Provider/AllenAI.py

@@ -18,10 +18,10 @@ class AllenAI(Provider):
 
     AVAILABLE_MODELS = [
         'tulu3-405b',
-        'OLMo-2-1124-13B-Instruct',
-        'tulu-3-1-8b',
-        'Llama-3-1-Tulu-3-70B',
-        'olmoe-0125'
+        # 'OLMo-2-1124-13B-Instruct',
+        # 'tulu-3-1-8b',
+        # 'Llama-3-1-Tulu-3-70B',
+        # 'olmoe-0125'
     ]
 
 
@@ -275,8 +275,23 @@ class AllenAI(Provider):
         return response["text"]
 
 if __name__ == "__main__":
-    from rich import print
-    ai = AllenAI(timeout=5000)
-    response = ai.chat("write a poem about AI", stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+
+    for model in AllenAI.AVAILABLE_MODELS:
+        try:
+            test_ai = AllenAI(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word")
+            response_text = response
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"{model:<50} {'✗':<10} {str(e)}")