webscout 2025.10.14.1__py3-none-any.whl → 2025.10.16__py3-none-any.whl

webscout/server/simple_logger.py

@@ -0,0 +1,84 @@
+"""
+Simple logger for no-auth mode.
+"""
+
+import asyncio
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any
+import sys
+from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
+
+# Setup logger
+logger = Logger(
+    name="webscout.api.simple_db",
+    level=LogLevel.INFO,
+    handlers=[ConsoleHandler(stream=sys.stdout)],
+    fmt=LogFormat.DEFAULT
+)
+
+class SimpleRequestLogger:
+    """Simple request logger for no-auth mode."""
+
+    def __init__(self):
+        logger.info("Simple request logger initialized (no database).")
+
+    async def log_request(
+        self,
+        request_id: str,
+        ip_address: str,
+        model: str,
+        question: str,
+        answer: str,
+        **kwargs
+    ) -> bool:
+        """Logs request details to the console."""
+        logger.info(f"Request {request_id}: model={model}, ip={ip_address}")
+        return True
+
+    async def get_recent_requests(self, limit: int = 10) -> Dict[str, Any]:
+        """Returns empty list of recent requests."""
+        logger.info("get_recent_requests called, but no database is configured.")
+        return {"requests": [], "count": 0}
+
+    async def get_stats(self) -> Dict[str, Any]:
+        """Returns empty stats."""
+        logger.info("get_stats called, but no database is configured.")
+        return {"error": "No database configured.", "available": False}
+
+# Global instance
+request_logger = SimpleRequestLogger()
+
+async def log_api_request(
+    request_id: str,
+    ip_address: str,
+    model: str,
+    question: str,
+    answer: str,
+    **kwargs
+) -> bool:
+    """Convenience function to log API requests."""
+    return await request_logger.log_request(
+        request_id=request_id,
+        ip_address=ip_address,
+        model=model,
+        question=question,
+        answer=answer,
+        **kwargs
+    )
+
+def get_client_ip(request) -> str:
+    """Extract client IP address from request."""
+    forwarded_for = request.headers.get("X-Forwarded-For")
+    if forwarded_for:
+        return forwarded_for.split(",")[0].strip()
+    
+    real_ip = request.headers.get("X-Real-IP")
+    if real_ip:
+        return real_ip.strip()
+    
+    return getattr(request.client, "host", "unknown")
+
+def generate_request_id() -> str:
+    """Generate a unique request ID."""
+    import uuid
+    return str(uuid.uuid4())

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "2025.10.14.1"
+__version__ = "2025.10.16"
 __prog__ = "webscout"

webscout/version.py.bak

@@ -1,2 +1,2 @@
-__version__ = "2025.10.14"
+__version__ = "2025.10.15"
 __prog__ = "webscout"

webscout/zeroart/README.md

@@ -11,6 +11,9 @@ ZeroArt is a powerful, lightweight Python library for generating stunning ASCII
   - Slant Font
   - Neon Font
   - Cyber Font
+  - 3D Font
+  - Electronic Font
+  - Isometric Font
 
 - **Zero Dependencies**
   - Completely standalone library
@@ -25,6 +28,8 @@ ZeroArt is a powerful, lightweight Python library for generating stunning ASCII
   - Glitch effect
   - Text wrapping
   - Outline generation
+  - Gradient effect
+  - Bouncing effect
 
 ## 🛠 Installation
 
@@ -55,6 +60,9 @@ print(zeroart.figlet_format("AWESOME", font='block'))   # Block style
 print(zeroart.figlet_format("CODING", font='slant'))    # Slant style
 print(zeroart.figlet_format("NEON", font='neon'))       # Neon style
 print(zeroart.figlet_format("CYBER", font='cyber'))     # Cyber style
+print(zeroart.figlet_format("3D", font='3d'))           # 3D style
+print(zeroart.figlet_format("ELECTRONIC", font='electronic')) # Electronic style
+print(zeroart.figlet_format("ISOMETRIC", font='isometric')) # Isometric style
 ```
 
 ### Text Effects
@@ -70,6 +78,12 @@ print(zeroart.glitch("GLITCH", font='cyber'))
 
 # Outline effect
 print(zeroart.outline("BORDER", font='block'))
+
+# Gradient effect
+print(zeroart.gradient("GRADIENT", font='3d'))
+
+# Bouncing effect
+print(zeroart.bounce("BOUNCE", font='electronic'))
 ```
 
 ## 🎨 Available Fonts
@@ -78,12 +92,6 @@ print(zeroart.outline("BORDER", font='block'))
 2. **Slant Font**: Elegant, slanted text
 3. **Neon Font**: Glowing, pixel-style art
 4. **Cyber Font**: Cyberpunk-inspired rendering
-
-## 🤝 Contributing
-
-Contributions are welcome! 
-
-- Fork the repository
-- Create a new font
-- Add text effects
-- Improve existing code
+5. **3D Font**: Text with a 3D effect
+6. **Electronic Font**: Digital-style text
+7. **Isometric Font**: Text with an isometric perspective

webscout/zeroart/__init__.py

@@ -6,10 +6,10 @@ Create awesome ASCII art text without external dependencies!
 
 from typing import Dict, List, Literal, Optional, Union
 from .base import ZeroArtFont
-from .fonts import BlockFont, SlantFont, NeonFont, CyberFont, DottedFont, ShadowFont
+from .fonts import BlockFont, SlantFont, NeonFont, CyberFont, DottedFont, ShadowFont, ThreeDFont, ElectronicFont, IsometricFont
 from .effects import AsciiArtEffects
 
-FontType = Literal['block', 'slant', 'neon', 'cyber', 'dotted', 'shadow']
+FontType = Literal['block', 'slant', 'neon', 'cyber', 'dotted', 'shadow', '3d', 'electronic', 'isometric']
 
 def figlet_format(text: str, font: Union[str, ZeroArtFont] = 'block') -> str:
     """
@@ -25,7 +25,10 @@ def figlet_format(text: str, font: Union[str, ZeroArtFont] = 'block') -> str:
         'neon': NeonFont(),
         'cyber': CyberFont(),
         'dotted': DottedFont(),
-        'shadow': ShadowFont()
+        'shadow': ShadowFont(),
+        '3d': ThreeDFont(),
+        'electronic': ElectronicFont(),
+        'isometric': IsometricFont()
     }
     
     if isinstance(font, str):
@@ -58,7 +61,10 @@ def rainbow(text: str, font: Union[str, ZeroArtFont] = 'block') -> str:
         'neon': NeonFont(),
         'cyber': CyberFont(),
         'dotted': DottedFont(),
-        'shadow': ShadowFont()
+        'shadow': ShadowFont(),
+        '3d': ThreeDFont(),
+        'electronic': ElectronicFont(),
+        'isometric': IsometricFont()
     }
     
     if isinstance(font, str):
@@ -82,7 +88,10 @@ def glitch(text: str, font: Union[str, ZeroArtFont] = 'block', glitch_intensity:
         'neon': NeonFont(),
         'cyber': CyberFont(),
         'dotted': DottedFont(),
-        'shadow': ShadowFont()
+        'shadow': ShadowFont(),
+        '3d': ThreeDFont(),
+        'electronic': ElectronicFont(),
+        'isometric': IsometricFont()
     }
     
     if isinstance(font, str):
@@ -108,7 +117,10 @@ def outline(text: str, font: Union[str, ZeroArtFont] = 'block', outline_char: st
         'neon': NeonFont(),
         'cyber': CyberFont(),
         'dotted': DottedFont(),
-        'shadow': ShadowFont()
+        'shadow': ShadowFont(),
+        '3d': ThreeDFont(),
+        'electronic': ElectronicFont(),
+        'isometric': IsometricFont()
     }
     
     if isinstance(font, str):
@@ -117,6 +129,61 @@ def outline(text: str, font: Union[str, ZeroArtFont] = 'block', outline_char: st
         selected_font = font
     return AsciiArtEffects.outline_effect(text, selected_font, outline_char)
 
+def gradient(text: str, font: Union[str, ZeroArtFont] = 'block', color1: tuple = (255, 0, 0), color2: tuple = (0, 0, 255)) -> str:
+    """
+    Apply a gradient color effect to ASCII art
+    
+    :param text: Text to render
+    :param font: Font style (default: 'block')
+    :param color1: Starting RGB color
+    :param color2: Ending RGB color
+    :return: Gradient-styled ASCII art
+    """
+    font_map: Dict[str, ZeroArtFont] = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont(),
+        'dotted': DottedFont(),
+        'shadow': ShadowFont(),
+        '3d': ThreeDFont(),
+        'electronic': ElectronicFont(),
+        'isometric': IsometricFont()
+    }
+    
+    if isinstance(font, str):
+        selected_font: ZeroArtFont = font_map.get(font.lower(), BlockFont())
+    else:
+        selected_font = font
+    return AsciiArtEffects.gradient_effect(text, selected_font, color1, color2)
+
+def bounce(text: str, font: Union[str, ZeroArtFont] = 'block', bounce_height: int = 2) -> str:
+    """
+    Create a bouncing text effect
+    
+    :param text: Text to render
+    :param font: Font style (default: 'block')
+    :param bounce_height: Height of the bounce
+    :return: Bouncing ASCII art
+    """
+    font_map: Dict[str, ZeroArtFont] = {
+        'block': BlockFont(),
+        'slant': SlantFont(),
+        'neon': NeonFont(),
+        'cyber': CyberFont(),
+        'dotted': DottedFont(),
+        'shadow': ShadowFont(),
+        '3d': ThreeDFont(),
+        'electronic': ElectronicFont(),
+        'isometric': IsometricFont()
+    }
+    
+    if isinstance(font, str):
+        selected_font: ZeroArtFont = font_map.get(font.lower(), BlockFont())
+    else:
+        selected_font = font
+    return AsciiArtEffects.bouncing_effect(text, selected_font, bounce_height)
+
 __all__ = [
     'figlet_format', 
     'print_figlet', 
@@ -124,12 +191,17 @@ __all__ = [
     'glitch', 
     'wrap_text', 
     'outline',
+    'gradient',
+    'bounce',
     'BlockFont', 
     'SlantFont', 
     'NeonFont', 
     'CyberFont',
     'DottedFont',
     'ShadowFont',
+    'ThreeDFont',
+    'ElectronicFont',
+    'IsometricFont',
     'ZeroArtFont',
     'FontType'
 ]

webscout/zeroart/effects.py

@@ -98,4 +98,54 @@ class AsciiArtEffects:
         
         top_bottom_line: str = outline_char * (len(outlined_lines[0]))
         
-        return '\n'.join([top_bottom_line] + outlined_lines + [top_bottom_line])
+        return '\n'.join([top_bottom_line] + outlined_lines + [top_bottom_line])
+
+    @staticmethod
+    def gradient_effect(text: str, font: ZeroArtFont, color1: tuple = (255, 0, 0), color2: tuple = (0, 0, 255)) -> str:
+        """
+        Apply a gradient color effect to ASCII art
+        
+        :param text: Text to render
+        :param font: Font to use
+        :param color1: Starting RGB color
+        :param color2: Ending RGB color
+        :return: Gradient-styled ASCII art
+        """
+        art: str = font.render(text)
+        art_lines: List[str] = art.split('\n')
+        
+        gradient_lines: List[str] = []
+        num_lines = len(art_lines)
+        
+        for i, line in enumerate(art_lines):
+            # Calculate interpolated color
+            ratio = i / max(1, num_lines - 1)
+            r = int(color1[0] * (1 - ratio) + color2[0] * ratio)
+            g = int(color1[1] * (1 - ratio) + color2[1] * ratio)
+            b = int(color1[2] * (1 - ratio) + color2[2] * ratio)
+            
+            # Apply ANSI color
+            colored_line = f'\033[38;2;{r};{g};{b}m{line}\033[0m'
+            gradient_lines.append(colored_line)
+            
+        return '\n'.join(gradient_lines)
+
+    @staticmethod
+    def bouncing_effect(text: str, font: ZeroArtFont, bounce_height: int = 2) -> str:
+        """
+        Create a bouncing text effect
+        
+        :param text: Text to render
+        :param font: Font to use
+        :param bounce_height: Height of the bounce
+        :return: Bouncing ASCII art
+        """
+        art: str = font.render(text)
+        art_lines: List[str] = art.split('\n')
+        
+        bouncing_lines: List[str] = []
+        for i, line in enumerate(art_lines):
+            offset = abs(bounce_height - i % (2 * bounce_height))
+            bouncing_lines.append(" " * offset + line)
+            
+        return '\n'.join(bouncing_lines)