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

webscout/update_checker.py

@@ -1,125 +1,184 @@
-"""
-Webscout Update Checker
-A utility to check and compare Webscout versions
-"""
-
-import requests
-import re
-import subprocess
-import sys
-import os
-from packaging import version
-from typing import Optional
-
-from webscout.Litlogger import LitLogger, LogFormat, ColorScheme
-
-# Initialize logger with custom format
-CUSTOM_FORMAT = """{message}"""
-
-logger = LitLogger(
-    name="WebscoutUpdate",
-    format=CUSTOM_FORMAT,
-    color_scheme=ColorScheme.OCEAN,
-    level_styles={
-        "TRACE": "DIM",
-        "DEBUG": "NORMAL",
-        "INFO": "BOLD",
-        "SUCCESS": "BOLD",
-        "WARNING": "BOLD",
-        "ERROR": "BOLD",
-        "CRITICAL": "BOLD"
-    }
-)
-
-def get_installed_version() -> Optional[str]:
-    """Get the installed version of webscout"""
-    try:
-        import importlib.metadata
-        return importlib.metadata.version('webscout')
-    except ImportError:
-        try:
-            import pkg_resources
-            return pkg_resources.get_distribution('webscout').version
-        except Exception:
-            logger.error("Could not determine installed version using pkg_resources")
-            return None
-    except Exception:
-        logger.error("Could not determine installed version using importlib.metadata")
-        return None
-
-def get_webscout_version() -> Optional[str]:
-    """Get the current webscout version from CLI"""
-    try:
-        result = subprocess.run(['webscout', '--version'], 
-                              capture_output=True, 
-                              text=True, 
-                              timeout=5)
-        if result.returncode == 0:
-            version_match = re.search(r'\d+\.\d+\.\d+', result.stdout)
-            if version_match:
-                return version_match.group(0)
-    except (subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError) as e:
-        logger.error(f"Failed to get version from CLI: {str(e)}")
-    return None
-
-def get_pypi_version() -> Optional[str]:
-    """Get the latest version from PyPI"""
-    try:
-        response = requests.get(
-            "https://pypi.org/pypi/webscout/json",
-            timeout=10
-        )
-        response.raise_for_status()
-        return response.json()['info']['version']
-    except requests.RequestException as e:
-        logger.error(f"Failed to fetch PyPI version: {str(e)}")
-    except (KeyError, ValueError) as e:
-        logger.error(f"Failed to parse PyPI response: {str(e)}")
-    return None
-
-def version_compare(v1: str, v2: str) -> int:
-    """Compare two version strings"""
-    try:
-        return -1 if version.parse(v1) < version.parse(v2) else 1
-    except version.InvalidVersion:
-        return 0
-
-def display_version_info(installed: Optional[str], current: Optional[str], latest: Optional[str]) -> None:
-    """Display version information"""
-    if installed:
-        logger.info(f"Currently using Webscout version {installed}")
-    
-    if latest and installed:
-        if version_compare(installed, latest) < 0:
-            logger.warning(
-                f"A new version of Webscout is available: {latest}\n"
-                f"To update, run: pip install --upgrade webscout"
-            )
-        else:
-            logger.success("You're running the latest version!")
-
-def check_for_updates() -> None:
-    """Check for Webscout updates"""
-    logger.info("Checking for Webscout updates...")
-    
-    installed_version = get_installed_version()
-    current_version = get_webscout_version()
-    latest_version = get_pypi_version()
-    
-    if not installed_version:
-        logger.error("Could not determine installed Webscout version")
-        return
-        
-    if not latest_version:
-        logger.error("Could not determine latest Webscout version from PyPI")
-        return
-    
-    display_version_info(installed_version, current_version, latest_version)
-
-if __name__ == "__main__":
-    try:
-        check_for_updates()
-    except KeyboardInterrupt:
-        logger.warning("Update check cancelled by user")
-    except Exception as e:
-        logger.error(f"An unexpected error occurred: {str(e)}")
+"""
+Ayy, check it out! 👀
+>>> from webscout import check_for_updates
+>>> check_for_updates()
+'Yo, new Webscout version just dropped: 2.0.0! 🔥
+Level up with: `pip install --upgrade webscout`'
+"""
+
+import subprocess
+import sys
+import os
+from typing import Optional
+
+import requests
+from packaging import version
+import re
+
+from webscout import LitLogger, ColorScheme
+from importlib.metadata import version as get_package_version
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import metadata as get_package_metadata
+
+# Setting up that clean logger format, no cap! 💯
+CUSTOM_FORMAT = """{message}"""
+
+logger = LitLogger(
+    name="WebscoutUpdate",
+    format=CUSTOM_FORMAT,
+    color_scheme=ColorScheme.OCEAN,
+    level_styles={
+        "TRACE": "DIM",
+        "DEBUG": "NORMAL", 
+        "INFO": "BOLD",
+        "SUCCESS": "BOLD",
+        "WARNING": "BOLD",
+        "ERROR": "BOLD",
+        "CRITICAL": "BOLD"
+    }
+)
+
+def get_installed_version() -> Optional[str]:
+    """Yo, let's check what version you're running! 🔍
+
+    What this function's all about:
+    - Checking your setup real quick 💨
+    - Getting them version deets 📱
+    - Handling any problems like a boss 💪
+
+    Returns:
+        Optional[str]: Your version number or None if we can't find it
+
+    Examples:
+        >>> version = get_installed_version()
+        >>> print(version)
+        '1.2.3'
+    """
+    try:
+        return get_package_version('webscout')
+    except PackageNotFoundError:
+        return None
+    except Exception as e:
+        return None
+
+def get_pypi_version() -> Optional[str]:
+    """Let's see what's fresh on PyPI! 🚀
+
+    This function's vibe:
+    - Hitting up PyPI for the latest drop 🌐
+    - Keeping it smooth with timeout handling ⚡
+    - Making sure we get good data fr fr 💯
+
+    Returns:
+        Optional[str]: Latest version or None if something's not right
+
+    Examples:
+        >>> latest = get_pypi_version()
+        >>> print(latest)
+        '2.0.0'
+    """
+    try:
+        response = requests.get(
+            "https://pypi.org/pypi/webscout/json",
+            timeout=10
+        )
+        response.raise_for_status()
+        return response.json()['info']['version']
+    except requests.RequestException as e:
+        pass
+    except (KeyError, ValueError) as e:
+        pass
+    except Exception as e:
+        pass
+    return None
+
+def version_compare(v1: str, v2: str) -> int:
+    """Time to compare these versions! 💪
+
+    Args:
+        v1: First version we checking
+        v2: Second version to compare with
+
+    Returns:
+        int: -1 if v1's older, 1 if v1's newer, 0 if they twins
+
+    Examples:
+        >>> version_compare('1.0.0', '2.0.0')
+        -1
+    """
+    try:
+        version1 = version.parse(v1)
+        version2 = version.parse(v2)
+        if version1 < version2:
+            return -1
+        if version1 > version2:
+            return 1
+        return 0
+    except version.InvalidVersion as e:
+        pass
+        return 0
+    except Exception as e:
+        pass
+        return 0
+
+def display_version_info(installed: Optional[str], latest: Optional[str]) -> None:
+    """Let's break down your version status! 📱
+
+    What we doing here:
+    - Comparing your version with the latest drop 🔄
+    - Letting you know if you need to level up ⬆️
+    - Keeping you in the loop with style 💯
+
+    Args:
+        installed: What you running rn
+        latest: What's fresh out there
+
+    Examples:
+        >>> display_version_info('1.0.0', '2.0.0')
+        'Yo, new Webscout version just dropped: 2.0.0! 🔥'
+    """
+    if installed:
+        pass
+    
+    if latest and installed:
+        comparison_result = version_compare(installed, latest)
+        if comparison_result < 0:
+            logger.warning(
+                f"Yo, new Webscout version just dropped: {latest}! 🔥\n"
+                f"Level up with: `pip install --upgrade webscout`"
+            )
+        elif comparison_result > 0:
+            logger.success("You already got the latest version, no cap! 💯")
+
+def check_for_updates() -> None:
+    """Time to check if you're running the latest! 🚀
+
+    What we doing:
+    - Peeking at your current setup 📱
+    - Checking what's new out there 🌐
+    - Keeping you updated fr fr ⚡
+
+    Examples:
+        >>> check_for_updates()
+        # We got you with them version checks fam!
+    """
+    installed_version = get_installed_version()
+    latest_version = get_pypi_version()
+    
+    if not installed_version:
+        pass
+        return
+        
+    if not latest_version:
+        pass
+        return
+    
+    display_version_info(installed_version, latest_version)
+
+if __name__ == "__main__":
+    try:
+        check_for_updates()
+    except KeyboardInterrupt:
+        logger.warning("Update check got cancelled, no worries fam! 🤚")
+    except Exception as e:
+        logger.error(f"Uh oh, something went wrong: {str(e)} 😔")

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "6.4"
+__version__ = "6.6"
 __prog__ = "webscout"

webscout/zeroart/__init__.py

@@ -0,0 +1,55 @@
+"""
+ZeroArt: A zero-dependency ASCII art text generator
+
+Create awesome ASCII art text without external dependencies!
+"""
+
+from .base import ZeroArtFont
+from .fonts import BlockFont, SlantFont, NeonFont, CyberFont
+from .effects import AsciiArtEffects
+
+def figlet_format(text, font='block'):
+    """
+    Generate ASCII art text
+    
+    :param text: Text to convert
+    :param font: Font style (default: 'block')
+    :return: ASCII art representation of text
+    """
+    font_map = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont()
+    }
+    
+    selected_font = font_map.get(font.lower(), BlockFont())
+    return selected_font.render(text)
+
+def print_figlet(text, font='block'):
+    """
+    Print ASCII art text directly
+    
+    :param text: Text to convert and print
+    :param font: Font style (default: 'block')
+    """
+    print(figlet_format(text, font))
+
+# Expose additional effects
+rainbow = AsciiArtEffects.rainbow_effect
+glitch = AsciiArtEffects.glitch_effect
+wrap_text = AsciiArtEffects.wrap_text
+outline = AsciiArtEffects.outline_effect
+
+__all__ = [
+    'figlet_format', 
+    'print_figlet', 
+    'rainbow', 
+    'glitch', 
+    'wrap_text', 
+    'outline',
+    'BlockFont', 
+    'SlantFont', 
+    'NeonFont', 
+    'CyberFont'
+]

webscout/zeroart/base.py

@@ -0,0 +1,60 @@
+"""
+ZeroArt Base: Core classes and utilities for ASCII art generation
+"""
+
+class ZeroArtFont:
+    """Base class for ASCII art fonts"""
+    def __init__(self, name):
+        self.name = name
+        self.letters = {}
+        self.special_chars = {}
+
+    def add_letter(self, char, art_lines):
+        """
+        Add a custom letter to the font
+        
+        :param char: Character to add
+        :param art_lines: List of art lines representing the character
+        """
+        self.letters[char.upper()] = art_lines
+
+    def add_special_char(self, name, art_lines):
+        """
+        Add a special ASCII art character or design
+        
+        :param name: Name of the special character
+        :param art_lines: List of art lines representing the character
+        """
+        self.special_chars[name] = art_lines
+
+    def get_letter(self, char):
+        """
+        Get ASCII art for a specific character
+        
+        :param char: Character to retrieve
+        :return: List of art lines or default space
+        """
+        return self.letters.get(char.upper(), self.letters.get(' ', [' ']))
+
+    def render(self, text):
+        if not text:
+            return ""
+            
+        # Get the maximum height of any character in the font
+        max_height = max(len(self.get_letter(c)) for c in text)
+        
+        # Initialize art_lines with empty strings
+        art_lines = ["" for _ in range(max_height)]
+        
+        # Process each character
+        for char in text:
+            char_art = self.get_letter(char)
+            # Pad shorter characters with empty lines to match max_height
+            while len(char_art) < max_height:
+                char_art.append(" " * len(char_art[0]))
+                
+            # Add character art to each line
+            for i in range(max_height):
+                art_lines[i] += char_art[i] + " "
+                
+        return "\n".join(art_lines)

webscout/zeroart/effects.py

@@ -0,0 +1,99 @@
+"""
+ZeroArt Effects: ASCII art text effects and transformations
+"""
+
+import random
+import textwrap
+ 
+class AsciiArtEffects:
+    """Collection of ASCII art text effects"""
+    
+    @staticmethod
+    def rainbow_effect(text, font):
+        """
+        Apply a rainbow-like color effect to ASCII art
+        
+        :param text: Text to render
+        :param font: Font to use
+        :return: Rainbow-styled ASCII art
+        """
+        colors = [
+            '\033[91m',  # Red
+            '\033[93m',  # Yellow
+            '\033[92m',  # Green
+            '\033[94m',  # Blue
+            '\033[95m',  # Magenta
+        ]
+        
+        art = font.render(text)
+        art_lines = art.split('\n')
+        
+        colored_lines = []
+        for line in art_lines:
+            colored_line = ''
+            for char in line:
+                color = random.choice(colors)
+                colored_line += color + char
+            colored_lines.append(colored_line + '\033[0m')  # Reset color
+        
+        return '\n'.join(colored_lines)
+
+    @staticmethod
+    def glitch_effect(text, font, glitch_intensity=0.1):
+        """
+        Apply a glitch-like distortion to ASCII art
+        
+        :param text: Text to render
+        :param font: Font to use
+        :param glitch_intensity: Probability of character distortion
+        :return: Glitched ASCII art
+        """
+        art = font.render(text)
+        art_lines = art.split('\n')
+        
+        glitched_lines = []
+        glitch_chars = ['~', '^', '`', '¯', '±']
+        
+        for line in art_lines:
+            glitched_line = ''
+            for char in line:
+                if random.random() < glitch_intensity:
+                    glitched_line += random.choice(glitch_chars)
+                else:
+                    glitched_line += char
+            glitched_lines.append(glitched_line)
+        
+        return '\n'.join(glitched_lines)
+
+    @staticmethod
+    def wrap_text(text, width=20):
+        """
+        Wrap ASCII art text to a specific width
+        
+        :param text: Text to wrap
+        :param width: Maximum line width
+        :return: Wrapped text
+        """
+        return textwrap.fill(text, width=width)
+
+    @staticmethod
+    def outline_effect(text, font, outline_char='*'):
+        """
+        Add an outline effect to ASCII art
+        
+        :param text: Text to render
+        :param font: Font to use
+        :param outline_char: Character to use for outline
+        :return: ASCII art with outline
+        """
+        art = font.render(text)
+        art_lines = art.split('\n')
+        
+        outlined_lines = []
+        for line in art_lines:
+            outlined_line = outline_char + line + outline_char
+            outlined_lines.append(outlined_line)
+        
+        top_bottom_line = outline_char * (len(outlined_lines[0]))
+        
+        return '\n'.join([top_bottom_line] + outlined_lines + [top_bottom_line])