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

webscout/Extra/weather.py

@@ -1,194 +0,0 @@
-"""
-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
-from datetime import datetime
-from typing import List, Dict, Any, Optional
-
-
-class CurrentCondition:
-    """Current weather conditions with strongly typed properties."""
-    
-    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."""
-    
-    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."""
-    
-    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."""
-    
-    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."""
-    
-    def __init__(self, data: Optional[Dict[str, Any]] = None) -> None:
-        """Initialize with weather data.
-        
-        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."""
-    
-    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 Weather(response.json())
-        except Exception as e:
-            print(f"Error fetching weather data: {str(e)}")
-            return Weather()
-
-
-def get(location: str) -> Weather:
-    """Convenience function to get weather for a location.
-    
-    Args:
-        location: Location to get weather for
-        
-    Returns:
-        Weather object containing all weather data
-    """
-    client = WeatherClient()
-    return client.get_weather(location)

webscout/Extra/weather_ascii.py

@@ -1,76 +0,0 @@
-"""
-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 typing import Dict, Optional, Any
-
-
-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:
-        WeatherAscii object containing ASCII art weather data
-    """
-    client = WeatherAsciiClient()
-    return client.get_weather(location, params)
-

webscout/Litlogger/__init__.py

@@ -1,67 +0,0 @@
-"""
-LitLogger - A feature-rich, colorful logging library with intelligent level detection.
-
-Features:
-- Colorful console output
-- Multiple output formats including JSON
-- File logging with rotation
-- Network logging (HTTP/HTTPS/TCP)
-- Async logging support
-- Intelligent log level detection
-- Context managers
-- Performance metrics
-- Log aggregation
-"""
-
-from .core.logger import Logger
-from .core.level import LogLevel
-from .styles.colors import LogColors
-from .styles.formats import LogFormat
-from .styles.text import TextStyle
-from .handlers.console import ConsoleHandler, ErrorConsoleHandler
-from .handlers.file import FileHandler
-from .handlers.network import NetworkHandler
-from .utils.detectors import LevelDetector
-from .utils.formatters import MessageFormatter
-
-# Create a default logger instance
-default_logger = Logger(
-    name="LitLogger",
-    handlers=[ConsoleHandler()]
-)
-
-# Expose common logging methods at package level
-debug = default_logger.debug
-info = default_logger.info
-warning = default_logger.warning
-error = default_logger.error
-critical = default_logger.critical
-
-__all__ = [
-    # Core
-    "Logger",
-    "LogLevel",
-    
-    # Styles
-    "LogColors",
-    "LogFormat",
-    "TextStyle",
-    
-    # Handlers
-    "ConsoleHandler",
-    "ErrorConsoleHandler", 
-    "FileHandler",
-    "NetworkHandler",
-    
-    # Utils
-    "LevelDetector",
-    "MessageFormatter",
-    
-    # Package-level logging functions
-    "debug",
-    "info",
-    "warning",
-    "error",
-    "critical",
-
-]

webscout/Litlogger/core/__init__.py

@@ -1,6 +0,0 @@
-"""Core logging functionality."""
-
-from .logger import Logger
-from .level import LogLevel
-
-__all__ = ["Logger", "LogLevel"]

webscout/Litlogger/core/level.py

@@ -1,23 +0,0 @@
-from enum import Enum
-
-class LogLevel(Enum):
-    NOTSET = 0
-    DEBUG = 10
-    INFO = 20
-    WARNING = 30
-    ERROR = 40
-    CRITICAL = 50
-
-    @staticmethod
-    def get_level(level_str: str) -> 'LogLevel':
-        if not level_str:
-            return LogLevel.NOTSET
-        try:
-            return LogLevel[level_str.upper()]
-        except KeyError:
-            raise ValueError(f"Invalid log level: {level_str}")
-
-    def __lt__(self, other):
-        if isinstance(other, LogLevel):
-            return self.value < other.value
-        return NotImplemented

webscout/Litlogger/core/logger.py

@@ -1,165 +0,0 @@
-
-import asyncio
-import sys
-import threading
-import traceback
-from datetime import datetime
-from typing import List, Union
-
-from ..core.level import LogLevel
-from ..styles.formats import LogFormat
-
-class Logger:
-    # Emoji mappings for different log levels
-    LEVEL_EMOJIS = {
-        LogLevel.DEBUG: "🔍",
-        LogLevel.INFO: "ℹ️",
-        LogLevel.WARNING: "⚠️",
-        LogLevel.ERROR: "❌",
-        LogLevel.CRITICAL: "🔥"
-    }
-
-    def __init__(
-        self,
-        name: str = "LitLogger",
-        level: Union[str, LogLevel, None] = None,
-        format: Union[str, LogFormat] = LogFormat.MODERN_EMOJI,
-        handlers: List = None,
-        enable_colors: bool = True,
-        async_mode: bool = False,
-        show_thread: bool = True,
-        show_context: bool = True
-    ):
-        self.name = name
-        self.level = LogLevel.NOTSET if level is None else (
-            LogLevel.get_level(level) if isinstance(level, str) else level
-        )
-        self.format = format
-        self.enable_colors = enable_colors
-        self.async_mode = async_mode
-        self.show_thread = show_thread
-        self.show_context = show_context
-        self._context_data = {}
-        
-        # Initialize with default console handler if none provided
-        if handlers is None:
-            from ..handlers.console import ConsoleHandler
-            self.handlers = [ConsoleHandler(level=self.level)]
-        else:
-            self.handlers = handlers
-
-    def _format_message(self, level: LogLevel, message: str, **kwargs) -> str:
-        now = datetime.now()
-        emoji = self.LEVEL_EMOJIS.get(level, "") if self.enable_colors else ""
-        
-        log_data = {
-            "timestamp": now.strftime("%H:%M:%S"),
-            "level": level.name,
-            "name": self.name,
-            "message": str(message),
-            "emoji": emoji,
-            "thread": threading.current_thread().name if self.show_thread else "",
-        }
-        
-        # Add context data
-        if self.show_context and self._context_data:
-            log_data.update(self._context_data)
-        
-        # Add extra kwargs
-        log_data.update(kwargs)
-        
-        # Format exception if present
-        if 'exc_info' in kwargs:
-            exc_info = kwargs['exc_info']
-            if exc_info:
-                exception_text = ''.join(traceback.format_exception(*exc_info))
-                log_data['message'] = f"{message}\n{exception_text}"
-        
-        try:
-            base_message = f"{emoji} [{log_data['timestamp']}] {level.name} {log_data['message']}"
-            return base_message
-        except Exception as e:
-            return f"[{log_data['timestamp']}] {level.name}: {message}"
-
-    def _log(self, level: LogLevel, message: str, **kwargs):
-        if self.async_mode:
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                return asyncio.create_task(self._async_log(level, message, **kwargs))
-            else:
-                return loop.run_until_complete(self._async_log(level, message, **kwargs))
-        return self._sync_log(level, message, **kwargs)
-
-    def debug(self, message: str, **kwargs):
-        self._log(LogLevel.DEBUG, message, **kwargs)
-
-    def info(self, message: str, **kwargs):
-        self._log(LogLevel.INFO, message, **kwargs)
-
-    def warning(self, message: str, **kwargs):
-        self._log(LogLevel.WARNING, message, **kwargs)
-
-    def error(self, message: str, **kwargs):
-        self._log(LogLevel.ERROR, message, **kwargs)
-
-    def critical(self, message: str, **kwargs):
-        self._log(LogLevel.CRITICAL, message, **kwargs)
-
-    def exception(self, message: str, exc_info=True, **kwargs):
-        """
-        Log an exception with traceback.
-        
-        Args:
-            message: The message to log
-            exc_info: If True, adds exception info to the message. Can also be a tuple (type, value, traceback)
-            **kwargs: Additional key-value pairs to log
-        """
-        if exc_info:
-            if not isinstance(exc_info, tuple):
-                exc_info = sys.exc_info()
-        kwargs['exc_info'] = exc_info
-        self.error(message, **kwargs)
-
-    def _sync_log(self, level: LogLevel, message: str, **kwargs):
-        if self._should_log(level):
-            formatted_message = self._format_message(level, message, **kwargs)
-            for handler in self.handlers:
-                if handler.level == LogLevel.NOTSET or level.value >= handler.level.value:
-                    handler.emit(formatted_message, level)
-
-    async def _async_log(self, level: LogLevel, message: str, **kwargs):
-        if self._should_log(level):
-            formatted_message = self._format_message(level, message, **kwargs)
-            tasks = []
-            for handler in self.handlers:
-                if handler.level == LogLevel.NOTSET or level.value >= handler.level.value:
-                    if hasattr(handler, 'async_emit'):
-                        tasks.append(handler.async_emit(formatted_message, level))
-                    else:
-                        tasks.append(asyncio.to_thread(handler.emit, formatted_message, level))
-            await asyncio.gather(*tasks)
-
-    def _should_log(self, level: LogLevel) -> bool:
-        return self.level == LogLevel.NOTSET or level.value >= self.level.value
-
-    def set_context(self, **kwargs):
-        self._context_data.update(kwargs)
-
-    def clear_context(self):
-        self._context_data.clear()
-
-    def set_style(self, style: str):
-        """Set logger style format."""
-        if style in LogFormat.TEMPLATES:
-            self.format = LogFormat.TEMPLATES[style]
-        else:
-            raise ValueError(f"Unknown style: {style}")
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is not None:
-            self.error(f"Context exited with error: {exc_val}")
-            return False
-        return True

webscout/Litlogger/handlers/__init__.py

@@ -1,12 +0,0 @@
-"""Log output handlers for different destinations."""
-
-from .console import ConsoleHandler, ErrorConsoleHandler
-from .file import FileHandler
-from .network import NetworkHandler
-
-__all__ = [
-    "ConsoleHandler",
-    "ErrorConsoleHandler",
-    "FileHandler",
-    "NetworkHandler"
-]

webscout/Litlogger/handlers/console.py

@@ -1,33 +0,0 @@
-import sys
-from ..core.level import LogLevel
-from ..styles.colors import LogColors
-
-class ConsoleHandler:
-    def __init__(self, level: LogLevel = LogLevel.DEBUG, stream=sys.stdout):
-        self.level = level
-        self.stream = stream
-        self.colors = LogColors()
-
-    def emit(self, message: str, level: LogLevel):
-        """Write the colored message to the console."""
-        try:
-            # Apply color based on log level
-            color = LogColors.LEVEL_COLORS.get(level, LogColors.RESET)
-            colored_message = f"{color}{message}{LogColors.RESET}"
-            print(colored_message, file=self.stream, flush=True)
-        except Exception as e:
-            # Fallback to plain printing if coloring fails
-            print(message, file=self.stream, flush=True)
-
-    async def async_emit(self, message: str, level: LogLevel):
-        """
-        Asynchronously write log message to console.
-        Just calls emit() since console output is generally fast enough.
-        """
-        self.emit(message, level)
-
-class ErrorConsoleHandler(ConsoleHandler):
-    """Specialized handler that writes to stderr."""
-    
-    def __init__(self, level: LogLevel = LogLevel.ERROR):
-        super().__init__(stream=sys.stderr, level=level)