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

webscout/update_checker.py

@@ -1,125 +1,125 @@
-"""
-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)}")
+"""
+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 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)}")

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "6.4"
+__version__ = "6.5"
 __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,61 @@
+"""
+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):
+        """
+        Render text as ASCII art
+        
+        :param text: Text to convert
+        :return: Rendered ASCII art as a string
+        """
+        # Ensure text is uppercase
+        text = text.upper()
+        
+        # Initialize lines for rendering
+        art_lines = [''] * 5  # Assuming 5-line height
+        
+        for char in text:
+            # Get character's art or use space if not found
+            char_art = self.get_letter(char)
+            
+            # Combine lines
+            for i in range(len(char_art)):
+                art_lines[i] += char_art[i] + " "
+        
+        # Join lines and remove trailing space
+        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])