shinyshell 0.2.2__tar.gz → 0.4.0__tar.gz

{shinyshell-0.2.2/shinyshell.egg-info → shinyshell-0.4.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: shinyshell
-Version: 0.2.2
+Version: 0.4.0
 Summary: Python library for beautiful terminal output — colored printing, tables, progress bars, syntax highlighting, bar charts, QR codes, and more. Zero dependencies.
 Home-page: https://github.com/adnanahamed66772ndpc/shinyshell
 Author: Adnan Ahamed Himal
 Author-email: hello@adnanahamedhimal.com
 Project-URL: Source, https://github.com/adnanahamed66772ndpc/shinyshell
 Project-URL: Bug Reports, https://github.com/adnanahamed66772ndpc/shinyshell/issues
+Project-URL: Discussions, https://github.com/adnanahamed66772ndpc/shinyshell/discussions
 Project-URL: Documentation, https://github.com/adnanahamed66772ndpc/shinyshell#readme
 Keywords: terminal,cli,console,pretty,beautiful,output,print,colors,ansi,progress bar,table,spinner,syntax highlighting,diff,json,bar chart,qr code,ascii art,markdown,debug,trace,logging,bash,shell,colored,formatting,rich,colorama,termcolor,python library,python package,python cli,python terminal,developer tools,devtools,zero dependency
 Classifier: Development Status :: 4 - Beta

{shinyshell-0.2.2 → shinyshell-0.4.0}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as f:
 
 setup(
     name="shinyshell",
-    version="0.2.2",
+    version="0.4.0",
     author="Adnan Ahamed Himal",
     author_email="hello@adnanahamedhimal.com",
     description="Python library for beautiful terminal output — colored printing, tables, progress bars, syntax highlighting, bar charts, QR codes, and more. Zero dependencies.",
@@ -16,6 +16,7 @@ setup(
     project_urls={
         "Source": "https://github.com/adnanahamed66772ndpc/shinyshell",
         "Bug Reports": "https://github.com/adnanahamed66772ndpc/shinyshell/issues",
+        "Discussions": "https://github.com/adnanahamed66772ndpc/shinyshell/discussions",
         "Documentation": "https://github.com/adnanahamed66772ndpc/shinyshell#readme",
     },
     packages=find_packages(),

{shinyshell-0.2.2 → shinyshell-0.4.0}/shinyshell/__init__.py

@@ -12,7 +12,7 @@ One import. All the pretty you need.
 Pure Python stdlib. Works on Linux, macOS, Windows.
 """
 
-__version__ = "0.2.2"
+__version__ = "0.4.0"
 __all__ = ["Shell"]
 
 import os
@@ -946,7 +946,840 @@ class Shell:
             sys.stdout.write(f"\r  {self._style(_ICONS['check'], color='green')} {lines[0]} {' ' * 20}\n")
             sys.stdout.flush()
 
+    # ── v0.3.0 NEW Features ──────────────────────────────────────
+
+    # 21. Sparklines
+    def sparkline(self, values: List[Union[int, float]], title: Optional[str] = None,
+                  width: int = 40) -> None:
+        """Tufte-style inline sparkline chart. sh.sparkline([1,5,2,8,3,9,4]) → ▁▃▁▆▂█▃"""
+        if not values:
+            return
+        chars = " ▁▂▃▄▅▆▇█"
+        mn, mx = min(values), max(values)
+        rng = max(mx - mn, 1)
+        scaled = [int((v - mn) / rng * (len(chars) - 1)) for v in values]
+        if len(scaled) > width:
+            step = len(scaled) / width
+            scaled = [scaled[int(i * step)] for i in range(width)]
+        spark = "".join(chars[min(i, len(chars) - 1)] for i in scaled)
+        print()
+        if title:
+            print(f"  {self._style(title, 'bold')}")
+        print(f"  {self._style(spark, color='cyan')} {self._style(f'{mn}—{mx}', color='bright_black')}")
+        print()
+
+    # 22. Styled Input
+    def input(self, prompt: str = "", default: str = "", validate: Optional[Callable[[str], bool]] = None) -> str:
+        """Styled text input with optional validation. sh.input('Name:', default='World')"""
+        p = f"  {self._style(_ICONS['question'], color='cyan')} {prompt} "
+        if default:
+            p += self._style(f"[{default}]", color="bright_black") + " "
+        try:
+            val = input(p).strip()
+        except (KeyboardInterrupt, EOFError):
+            print()
+            return default
+        if not val:
+            return default
+        if validate and not validate(val):
+            self.warning(f"Invalid input: {val}")
+            return self.input(prompt, default, validate)
+        return val
+
+    # 23. Password Input
+    def password(self, prompt: str = "Password:", min_len: int = 4) -> str:
+        """Masked password input with strength meter. sh.password('Enter API key:')"""
+        import getpass
+        print()
+        try:
+            pwd = getpass.getpass(f"  {self._style(_ICONS['lock'], color='yellow')} {prompt} ")
+        except (KeyboardInterrupt, EOFError):
+            print()
+            return ""
+        if not pwd:
+            return ""
+
+        # Strength meter
+        score = min(4, sum([
+            len(pwd) >= 8,
+            len(pwd) >= 12,
+            any(c.isupper() for c in pwd),
+            any(c.islower() for c in pwd),
+            any(c.isdigit() for c in pwd),
+            any(not c.isalnum() for c in pwd),
+        ]))
+        bar = ["▯" * 10, "▮▯▯▯▯▯▯▯▯▯", "▮▮▮▯▯▯▯▯▯▯", "▮▮▮▮▮▯▯▯▯▯", "▮▮▮▮▮▮▮▯▯▯", "▮▮▮▮▮▮▮▮▮▮"][min(score, 5)]
+        labels = ["", "Weak", "Fair", "Good", "Strong", "Very Strong"]
+        colors = ["", "red", "yellow", "cyan", "green", "green"]
+        print(f"  {self._style(bar, color=colors[min(score,5)])} {self._style(labels[min(score,5)], color=colors[min(score,5)])}")
+        return pwd
+
+    # 24. Themes
+    def theme(self, name: str = "default") -> None:
+        """Apply a color theme: dracula, nord, solarized, monokai, default. sh.theme('dracula')"""
+        themes = {
+            "dracula": {"success": "green", "error": "red", "warning": "yellow", "info": "magenta", "header": "magenta", "accent": "magenta"},
+            "nord": {"success": "green", "error": "red", "warning": "yellow", "info": "cyan", "header": "cyan", "accent": "cyan"},
+            "solarized": {"success": "green", "error": "red", "warning": "yellow", "info": "cyan", "header": "yellow", "accent": "yellow"},
+            "monokai": {"success": "green", "error": "red", "warning": "yellow", "info": "magenta", "header": "magenta", "accent": "magenta"},
+            "ocean": {"success": "green", "error": "red", "warning": "yellow", "info": "blue", "header": "blue", "accent": "blue"},
+        }
+        self._theme = themes.get(name, themes.get("default", {}))
+        if name != "default":
+            self.success(f"Theme '{name}' applied!")
+
+    # 25. Log Viewer
+    def log(self, level: str, message: str, timestamp: bool = True) -> None:
+        """Pretty log line. sh.log('INFO', 'Server started', timestamp=True)"""
+        import datetime
+        colors = {"DEBUG": "bright_black", "INFO": "cyan", "WARN": "yellow", "ERROR": "red", "CRITICAL": "magenta"}
+        color = colors.get(level.upper(), "white")
+        ts = ""
+        if timestamp:
+            ts = self._style(datetime.datetime.now().strftime("%H:%M:%S"), color="bright_black") + " "
+        lvl = self._style(f"{level.upper():8s}", "bold", color=color)
+        print(f"  {ts}{lvl} {message}")
+
+    # 26. Calendar
+    def calendar(self, year: Optional[int] = None, month: Optional[int] = None) -> None:
+        """Display a monthly calendar. sh.calendar(2026, 7)"""
+        import calendar as cal_mod, datetime
+        now = datetime.datetime.now()
+        y = year or now.year
+        m = month or now.month
+        cal = cal_mod.TextCalendar()
+        print()
+        header = self._style(f"    {cal_mod.month_name[m]} {y}", "bold", color="cyan")
+        print(header)
+        print(self._style("    Mo Tu We Th Fr Sa Su", color="bright_black"))
+        for week in cal.monthdayscalendar(y, m):
+            line = "   "
+            for d in week:
+                if d == 0:
+                    line += "   "
+                elif d == now.day and m == now.month and y == now.year:
+                    line += self._style(f"{d:2d} ", "bold", color="green", bg="green")
+                else:
+                    line += f"{d:2d} "
+            print(f"  {line}")
+        print()
+
+    # 27. Network Utilities
+    def network_ping(self, host: str, count: int = 4) -> None:
+        """Simple ping with visual output. sh.network_ping('google.com')"""
+        import subprocess, platform
+        print()
+        self.info(f"Pinging {host}...")
+        cmd = ["ping", "-n" if platform.system() == "Windows" else "-c", str(count), host]
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            for line in result.stdout.split("\n"):
+                if "time=" in line or "time<" in line or "ms" in line:
+                    print(f"  {self._style('⚡', color='cyan')} {line.strip()}")
+            if result.returncode == 0:
+                self.success(f"{host} is reachable")
+            else:
+                self.error(f"{host} unreachable")
+        except Exception as e:
+            self.error(f"Ping failed: {e}")
+
+    def network_status(self, url: str) -> None:
+        """Check HTTP status with visual output. sh.network_status('https://api.example.com')"""
+        import urllib.request
+        print()
+        try:
+            req = urllib.request.Request(url, method="HEAD")
+            resp = urllib.request.urlopen(req, timeout=5)
+            status = resp.status
+            if status < 300:
+                self.success(f"{url} → {status} OK ({resp.headers.get('Server', '?')})")
+            elif status < 400:
+                self.warning(f"{url} → {status} Redirect")
+            else:
+                self.error(f"{url} → {status} Error")
+        except Exception as e:
+            self.error(f"{url} → {str(e)[:60]}")
+
+    # 28. Gauge
+    def gauge(self, value: float, max_val: float = 100, title: Optional[str] = None,
+              width: int = 30, color: str = "green") -> None:
+        """Circular-style gauge display. sh.gauge(75, 100, 'CPU Usage')"""
+        pct = min(value / max(max_val, 1), 1.0)
+        filled = int(pct * width)
+        bar = "█" * filled + "░" * (width - filled)
+        if pct > 0.9:
+            color = "red"
+        elif pct > 0.7:
+            color = "yellow"
+        print()
+        if title:
+            print(f"  {self._style(title, 'bold')}")
+        print(f"  {self._style(bar, color=color)} {self._style(f'{pct*100:.0f}%', 'bold', color=color)}")
+        print()
+
+    # 29. Clipboard
+    def clipboard_copy(self, text: str) -> None:
+        """Copy text to system clipboard. sh.clipboard_copy('Hello')"""
+        import subprocess, platform
+        sys_name = platform.system()
+        try:
+            if sys_name == "Darwin":
+                subprocess.run(["pbcopy"], input=text.encode(), timeout=2)
+            elif sys_name == "Linux":
+                subprocess.run(["xclip", "-selection", "clipboard"], input=text.encode(), timeout=2)
+            elif sys_name == "Windows":
+                subprocess.run(["clip"], input=text.encode(), timeout=2)
+            self.success("Copied to clipboard!")
+        except Exception:
+            # Fallback: use OSC 52 (works in many terminals)
+            encoded = __import__('base64').b64encode(text.encode()).decode()
+            sys.stdout.write(f"\033]52;c;{encoded}\007")
+            sys.stdout.flush()
+            self.info("Copied (OSC 52)")
+
+    # 30. Config Viewer
+    def config(self, path: str) -> None:
+        """View config files (TOML, YAML, INI, JSON) with syntax colors. sh.config('.env')"""
+        import configparser
+        print()
+        print(self._style(f"  📄 {path}", "bold"))
+        try:
+            with open(path) as f:
+                content = f.read()
+            if path.endswith(('.json',)):
+                self.json(_json.loads(content))
+            elif path.endswith(('.ini', '.cfg', '.conf')):
+                cp = configparser.ConfigParser()
+                cp.read_string(content)
+                for section in cp.sections():
+                    print(self._style(f"  [{section}]", "bold", color="cyan"))
+                    for k, v in cp.items(section):
+                        print(f"    {self._style(k, color='green')} = {v}")
+            else:
+                for line in content.strip().split("\n"):
+                    if line.startswith("#") or line.startswith(";"):
+                        print(f"  {self._style(line, color='bright_black')}")
+                    elif "=" in line:
+                        k, v = line.split("=", 1)
+                        print(f"  {self._style(k.strip(), color='green')} = {self._style(v.strip(), color='yellow')}")
+                    else:
+                        print(f"  {line}")
+        except Exception as e:
+            self.error(f"Cannot read: {e}")
+        print()
+
+    # 31. Pipe
+    def pipe(self, data: Any):
+        """Chained output: sh.pipe(data).table().metrics()"""
+        return _PipeOutput(data, self)
+
+    # 32. Heatmap
+    def heatmap(self, data: List[List[float]], title: Optional[str] = None) -> None:
+        """Display 2D data as a heatmap. sh.heatmap([[1,2,3],[4,5,6],[7,8,9]])"""
+        if not data:
+            return
+        print()
+        if title:
+            print(self._style(f"  {title}", "bold"))
+        chars = " ·░▒▓█"
+        flat = [v for row in data for v in row]
+        mn, mx = min(flat), max(flat)
+        rng = max(mx - mn, 1)
+        for row in data:
+            line = "  "
+            for v in row:
+                idx = int((v - mn) / rng * (len(chars) - 1))
+                line += chars[min(idx, len(chars) - 1)] * 2
+            print(line)
+        print()
+
+    # 33. Notification
+    def notify(self, title: str, message: str = "") -> None:
+        """Cross-platform desktop notification. sh.notify('Build complete', 'All tests passed')"""
+        import subprocess, platform
+        sys_name = platform.system()
+        try:
+            if sys_name == "Darwin":
+                subprocess.run(["osascript", "-e", f'display notification "{message}" with title "{title}"'], timeout=3)
+            elif sys_name == "Linux":
+                subprocess.run(["notify-send", title, message], timeout=3)
+            elif sys_name == "Windows":
+                from win10toast import ToastNotifier
+                ToastNotifier().show_toast(title, message, duration=3)
+            self.success(f"Notification sent: {title}")
+        except Exception:
+            print(f"\n  🔔 {title}: {message}\n")
+
+    # 34. File Watcher
+    def filewatch(self, path: str, callback: Optional[Callable[[str], None]] = None) -> None:
+        """Watch a file/directory for changes. sh.filewatch('app.py', callback=my_handler)"""
+        import time as _time
+        import hashlib
+        print()
+        self.info(f"Watching {path}... (Ctrl+C to stop)")
+        try:
+            if os.path.isfile(path):
+                last_hash = hashlib.md5(open(path, "rb").read()).hexdigest()
+                while True:
+                    _time.sleep(1)
+                    try:
+                        new_hash = hashlib.md5(open(path, "rb").read()).hexdigest()
+                        if new_hash != last_hash:
+                            last_hash = new_hash
+                            self.success(f"Changed: {path}")
+                            if callback:
+                                callback(path)
+                    except FileNotFoundError:
+                        self.warning(f"File deleted: {path}")
+                        break
+            elif os.path.isdir(path):
+                last_files = set(os.listdir(path))
+                while True:
+                    _time.sleep(1)
+                    try:
+                        files = set(os.listdir(path))
+                        added = files - last_files
+                        removed = last_files - files
+                        if added:
+                            self.success(f"Added: {', '.join(added)}")
+                        if removed:
+                            self.error(f"Removed: {', '.join(removed)}")
+                        if added or removed:
+                            if callback:
+                                callback(path)
+                        last_files = files
+                    except Exception:
+                        pass
+        except KeyboardInterrupt:
+            self.info("Stopped watching.")
+
+    # 35. Menu (arrow-key navigable)
+    def menu(self, options: List[str], title: Optional[str] = None) -> Optional[int]:
+        """Arrow-key navigable menu. Returns selected index or None.
+
+        index = sh.menu(['Deploy', 'Rollback', 'Status', 'Exit'])
+        """
+        if not options:
+            return None
+        selected = 0
+        print()
+        if title:
+            print(self._style(f"  {title}", "bold"))
+            print()
+
+        # Use raw terminal input for arrow keys
+        import tty, termios, select as _select
+
+        def _get_key():
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                if _select.select([sys.stdin], [], [], 0.1)[0]:
+                    ch = sys.stdin.read(1)
+                    if ch == '\x1b':
+                        ch2 = sys.stdin.read(2)
+                        if ch2 == '[A':
+                            return 'up'
+                        elif ch2 == '[B':
+                            return 'down'
+                        elif ch2 == '[C':
+                            return 'right'
+                        elif ch2 == '[D':
+                            return 'left'
+                    elif ch in ('\r', '\n'):
+                        return 'enter'
+                    elif ch == '\x03':
+                        return 'ctrl_c'
+                    elif ch == 'q':
+                        return 'quit'
+                return None
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+        def _render():
+            sys.stdout.write('\033[F' * (len(options) + 3))
+            sys.stdout.write('\033[J')
+            print()
+            if title:
+                print(self._style(f"  {title}", "bold"))
+                print()
+            for i, opt in enumerate(options):
+                if i == selected:
+                    print(f"  {self._style('▸', color='cyan')} {self._style(opt, 'bold', color='cyan', bg='cyan')}")
+                else:
+                    print(f"    {opt}")
+            print(f"  {self._style('↑↓ navigate  ↵ select  q quit', color='bright_black')}")
+            sys.stdout.flush()
+
+        self.info("Arrow keys: navigate, Enter: select, q: quit")
+        try:
+            _render()
+            while True:
+                key = _get_key()
+                if key == 'up':
+                    selected = (selected - 1) % len(options)
+                    _render()
+                elif key == 'down':
+                    selected = (selected + 1) % len(options)
+                    _render()
+                elif key == 'enter':
+                    sys.stdout.write('\033[F' * (len(options) + 3))
+                    sys.stdout.write('\033[J')
+                    self.success(f"Selected: {options[selected]}")
+                    return selected
+                elif key in ('quit', 'ctrl_c'):
+                    sys.stdout.write('\033[F' * (len(options) + 3))
+                    sys.stdout.write('\033[J')
+                    self.info("Cancelled")
+                    return None
+        except Exception:
+            return None
+
+    # 36. Simple Venn Diagram
+    def venn(self, set_a: set, set_b: set, labels: tuple = ("A", "B"),
+             title: Optional[str] = None) -> None:
+        """ASCII Venn diagram for 2 sets. sh.venn({1,2,3}, {2,3,4}, ('Users', 'Admins'))"""
+        a_only = set_a - set_b
+        b_only = set_b - set_a
+        both = set_a & set_b
+        print()
+        if title:
+            print(self._style(f"  {title}", "bold"))
+            print()
+        print(f"  {self._style(labels[0], 'bold', color='cyan')}: {len(set_a)}  |  {self._style(labels[1], 'bold', color='magenta')}: {len(set_b)}")
+        print(f"  {self._style('Only ' + labels[0], color='bright_black')}: {len(a_only)}  |  {self._style('Only ' + labels[1], color='bright_black')}: {len(b_only)}  |  {self._style('Both', color='bright_black')}: {len(both)}")
+        print()
+
+    # ── v0.4.0 NEW Features ──────────────────────────────────────
+
+    # 37. Audio
+    def audio_beep(self, times: int = 1) -> None:
+        """Play a terminal beep. sh.audio_beep(3)"""
+        sys.stdout.write('\a' * times)
+        sys.stdout.flush()
+
+    def audio_ding(self) -> None:
+        """Play a success ding sound."""
+        import subprocess, platform
+        try:
+            if platform.system() == "Darwin":
+                subprocess.run(["afplay", "/System/Library/Sounds/Glass.aiff"], timeout=2)
+            elif platform.system() == "Linux":
+                subprocess.run(["paplay", "/usr/share/sounds/freedesktop/stereo/complete.oga"], timeout=2)
+            else:
+                sys.stdout.write('\a')
+        except Exception:
+            sys.stdout.write('\a')
+        sys.stdout.flush()
+
+    # 38. Typewriter effect
+    def typewrite(self, text: str, speed: float = 0.03) -> None:
+        """Typewriter animation effect. sh.typewrite('Hello World', speed=0.05)"""
+        print()
+        for ch in text:
+            sys.stdout.write(ch)
+            sys.stdout.flush()
+            time.sleep(speed)
+        print()
+
+    # 39. Rainbow text
+    def rainbow(self, text: str) -> None:
+        """Rainbow gradient text. sh.rainbow('Hello World')"""
+        colors = ["red", "yellow", "green", "cyan", "blue", "magenta"]
+        result = ""
+        for i, ch in enumerate(text):
+            if ch.strip():
+                result += self._style(ch, color=colors[i % len(colors)])
+            else:
+                result += ch
+        print(f"\n  {result}\n")
+
+    # 40. Matrix Rain Animation
+    def matrix(self, duration: float = 5.0) -> None:
+        """Matrix-style rain animation. sh.matrix(10)"""
+        import random as _rand
+        chars = "ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃ0123456789"
+        width = min(self._width - 4, 60)
+        cols = [0] * width
+        print()
+        start = time.time()
+        try:
+            while time.time() - start < duration:
+                line = "  "
+                for i in range(width):
+                    if cols[i] > 0:
+                        line += self._style(_rand.choice(chars), color="green")
+                        cols[i] -= 1
+                    elif _rand.random() < 0.05:
+                        cols[i] = _rand.randint(5, 15)
+                        line += self._style(_rand.choice(chars), "bold", color="bright_green")
+                    else:
+                        line += " "
+                sys.stdout.write(f"\r{line}")
+                sys.stdout.flush()
+                time.sleep(0.05)
+        except KeyboardInterrupt:
+            pass
+        print("\n")
+
+    # 41. Dice Roller
+    def dice(self, sides: int = 6, count: int = 1) -> List[int]:
+        """Animated dice roller. sh.dice(6, 2) → [3, 5]"""
+        import random as _rand
+        dice_faces = {
+            1: ["┌─────┐", "│     │", "│  ●  │", "│     │", "└─────┘"],
+            2: ["┌─────┐", "│ ●   │", "│     │", "│   ● │", "└─────┘"],
+            3: ["┌─────┐", "│ ●   │", "│  ●  │", "│   ● │", "└─────┘"],
+            4: ["┌─────┐", "│ ● ● │", "│     │", "│ ● ● │", "└─────┘"],
+            5: ["┌─────┐", "│ ● ● │", "│  ●  │", "│ ● ● │", "└─────┘"],
+            6: ["┌─────┐", "│ ● ● │", "│ ● ● │", "│ ● ● │", "└─────┘"],
+        }
+        results = [_rand.randint(1, sides) for _ in range(count)]
+        results_str = ", ".join(str(r) for r in results)
+        print()
+        # Animation
+        for _ in range(5):
+            rand_faces = [_rand.choice(list(dice_faces.values())) for _ in range(min(count, 3))]
+            for row in range(5):
+                line = "  " + " ".join(f[row] for f in rand_faces)
+                sys.stdout.write(f"\r{line}\n")
+            sys.stdout.write(f"\033[{5 * min(count,3)}A")
+            sys.stdout.flush()
+            time.sleep(0.1)
+        sys.stdout.write(f"\033[{5 * min(count,3)}B")
+        if count <= 3:
+            real_faces = [dice_faces.get(r, dice_faces[1]) for r in results]
+            for row in range(5):
+                print("  " + " ".join(f[row] for f in real_faces))
+        self.success(f"Rolled: {results_str}")
+        return results
+
+    # 42. Pomodoro Timer
+    def pomodoro(self, work_min: int = 25, break_min: int = 5, cycles: int = 4) -> None:
+        """Pomodoro timer. sh.pomodoro(25, 5, 4)"""
+        for cycle in range(1, cycles + 1):
+            self.header(f"🍅 Pomodoro {cycle}/{cycles} — WORK ({work_min}min)")
+            self._countdown_timer(work_min * 60, "Working")
+            if cycle < cycles:
+                self.success(f"Break time! ({break_min}min)")
+                self._countdown_timer(break_min * 60, "Break")
+        self.header("🎉 ALL DONE! Great work!")
+
+    def _countdown_timer(self, seconds: int, label: str):
+        for remaining in range(seconds, 0, -1):
+            m, s = divmod(remaining, 60)
+            sys.stdout.write(f"\r  ⏱️  {label}: {m:02d}:{s:02d} remaining  ")
+            sys.stdout.flush()
+            time.sleep(1)
+        sys.stdout.write("\r" + " " * 40 + "\r")
+        sys.stdout.flush()
+
+    # 43. CSV Viewer
+    def csv(self, data: Union[str, List[Dict]], title: Optional[str] = None) -> None:
+        """Pretty CSV viewer. sh.csv('data.csv') or sh.csv(list_of_dicts)"""
+        import csv as _csv, io
+        if isinstance(data, str):
+            try:
+                with open(data) as f:
+                    reader = _csv.DictReader(f)
+                    rows = list(reader)
+            except Exception as e:
+                self.error(f"Cannot read CSV: {e}")
+                return
+        else:
+            rows = data
+        if rows:
+            self.table(rows, title=title or "CSV Data")
+
+    # 44. SQL Table Viewer
+    def sql_table(self, rows: List[Dict], title: Optional[str] = None) -> None:
+        """Pretty SQL query output. sh.sql_table([{'id':1,'name':'Alice'},...])"""
+        self.table(rows, title=title or "Query Result", style="double")
+
+    # 45. XML Viewer
+    def xml(self, data: str, title: Optional[str] = None) -> None:
+        """Pretty XML viewer with syntax colors. sh.xml('<root><item>hello</item></root>')"""
+        import xml.dom.minidom
+        try:
+            dom = xml.dom.minidom.parseString(data) if data.strip().startswith("<") else xml.dom.minidom.parse(data)
+            pretty = dom.toprettyxml(indent="  ")
+            print()
+            if title:
+                print(self._style(f"  {title}", "bold"))
+            for line in pretty.split("\n"):
+                if line.strip():
+                    # Color tags and content
+                    import re
+                    colored = re.sub(r'(</?)(\w+)([^>]*>)',
+                                     lambda m: m.group(1) + self._style(m.group(2), color="cyan") + self._style(m.group(3), color="bright_black"),
+                                     line)
+                    colored = re.sub(r'>([^<]+)<', lambda m: '>' + self._style(m.group(1), color="yellow") + '<', colored)
+                    print(f"  {colored}")
+            print()
+        except Exception as e:
+            self.error(f"XML parse error: {e}")
+
+    # 46. Dict Diff
+    def dict_diff(self, old: Dict, new: Dict, title: Optional[str] = None) -> None:
+        """Deep dictionary comparison. sh.dict_diff({'a':1}, {'a':2,'b':3})"""
+        print()
+        if title:
+            print(self._style(f"  {title}", "bold"))
+        all_keys = set(old.keys()) | set(new.keys())
+        for key in sorted(all_keys):
+            if key not in old:
+                print(f"  + {self._style(str(key), color='green')}: {self._style(str(new[key]), color='green')}")
+            elif key not in new:
+                print(f"  - {self._style(str(key), color='red')}: {self._style(str(old[key]), color='red')}")
+            elif old[key] != new[key]:
+                print(f"  ~ {key}: {self._style(str(old[key]), color='red')} → {self._style(str(new[key]), color='green')}")
+            else:
+                print(f"    {key}: {old[key]}")
+        print()
+
+    # 47. HTTP Viewer
+    def http(self, method: str, url: str, headers: Optional[Dict] = None,
+             body: Optional[str] = None) -> None:
+        """Pretty HTTP request/response viewer. sh.http('GET', 'https://httpbin.org/json')"""
+        import urllib.request
+        print()
+        self.info(f"{method} {url}")
+        try:
+            req = urllib.request.Request(url, method=method, data=body.encode() if body else None)
+            if headers:
+                for k, v in headers.items():
+                    req.add_header(k, v)
+            start = time.perf_counter()
+            resp = urllib.request.urlopen(req, timeout=10)
+            elapsed = (time.perf_counter() - start) * 1000
+            status_color = "green" if resp.status < 300 else "red" if resp.status >= 400 else "yellow"
+            self._style("", color="")
+            print(f"  {self._style(f'HTTP {resp.status}', 'bold', color=status_color)} {self._style(f'{elapsed:.0f}ms', color='bright_black')}")
+            print(f"  {self._style('Headers:', color='bright_black')}")
+            for k, v in resp.headers.items():
+                print(f"    {self._style(k, color='green')}: {v}")
+            # Show first 500 chars of body
+            resp_body = resp.read().decode('utf-8', errors='replace')[:500]
+            if resp_body:
+                print(f"  {self._style('Body (first 500 chars):', color='bright_black')}")
+                for line in resp_body.split("\n"):
+                    print(f"    {line}")
+        except Exception as e:
+            self.error(f"HTTP error: {str(e)[:80]}")
+        print()
+
+    # 48. Git Viewer
+    def git_log(self, count: int = 10, path: str = ".") -> None:
+        """Beautiful git log viewer. sh.git_log(10)"""
+        import subprocess
+        try:
+            result = subprocess.run(["git", "-C", path, "log", f"-{count}", "--oneline", "--decorate", "--graph", "--color=never"],
+                                    capture_output=True, text=True, timeout=5)
+            print()
+            print(self._style("  Git Log", "bold", color="cyan"))
+            for line in result.stdout.strip().split("\n"):
+                print(f"  {line}")
+            print()
+        except Exception:
+            self.warning("Not a git repository or git not installed")
+
+    def git_status(self, path: str = ".") -> None:
+        """Beautiful git status viewer. sh.git_status()"""
+        import subprocess
+        try:
+            result = subprocess.run(["git", "-C", path, "status", "--short"],
+                                    capture_output=True, text=True, timeout=5)
+            print()
+            print(self._style("  Git Status", "bold", color="cyan"))
+            for line in result.stdout.strip().split("\n"):
+                if line.startswith("??"):
+                    print(f"  {self._style(line, color='red')}")
+                elif line.startswith(" M") or line.startswith("M "):
+                    print(f"  {self._style(line, color='yellow')}")
+                elif line.startswith("A "):
+                    print(f"  {self._style(line, color='green')}")
+                else:
+                    print(f"  {line}")
+            if not result.stdout.strip():
+                self.success("Working tree clean!")
+            print()
+        except Exception:
+            self.warning("Not a git repository")
+
+    # 49. Color Picker
+    def color_picker(self) -> None:
+        """Display available ANSI colors. sh.color_picker()"""
+        print()
+        print(self._style("  ANSI Colors", "bold"))
+        print()
+        for name in _ANSICodes.COLORS:
+            label = self._style(f"  {name:20s}", "bold")
+            swatch = self._style("  ████████████  ", color=name)
+            bg_swatch = self._style("  ████████████  ", color="white", bg=name)
+            normal = self._style(f"  Normal Text  ", color=name)
+            print(f"{label}{swatch}{bg_swatch}{normal}")
+        print()
+
+    # 50. Word Cloud
+    def wordcloud(self, text: str, max_words: int = 30, width: int = 60) -> None:
+        """ASCII word cloud from text. sh.wordcloud(open('book.txt').read())"""
+        import re, random as _rand
+        words = re.findall(r'\b\w{3,}\b', text.lower())
+        if not words:
+            return
+        # Count frequencies
+        from collections import Counter
+        freq = Counter(words).most_common(max_words)
+        if not freq:
+            return
+        max_f = freq[0][1]
+        min_f = freq[-1][1]
+        rng = max(max_f - min_f, 1)
+        print()
+        print(self._style("  Word Cloud", "bold"))
+        print()
+        # Simple cloud layout
+        _rand.seed(42)
+        line = "  "
+        for word, count in freq:
+            size = int((count - min_f) / rng * 3) + 1
+            colors_list = ["cyan", "magenta", "yellow", "green", "blue", "red"]
+            c = colors_list[(count * 7) % len(colors_list)]
+            styled = self._style(word, "bold", color=c) if size >= 3 else self._style(word, color=c)
+            if len(line) + len(word) + 1 > width:
+                print(line)
+                line = "  " + styled + " "
+            else:
+                line += styled + " "
+        if line.strip():
+            print(line)
+        print()
+
+    # 51. Grid Layout
+    def grid(self, items: List[Dict[str, Any]], cols: int = 2) -> None:
+        """Grid layout: sh.grid([{'title':'CPU','value':'45%'},{'title':'RAM','value':'8GB'}])"""
+        print()
+        cell_w = (self._width - 4) // cols - 4
+        for i in range(0, len(items), cols):
+            row_items = items[i:i+cols]
+            # Find max lines per cell
+            cell_lines = []
+            for item in row_items:
+                lines_out = []
+                title = item.get("title", "")
+                value = str(item.get("value", ""))
+                lines_out.append(self._style(f"── {title} ", "bold", color="cyan"))
+                lines_out.append(f"   {value}")
+                if "sub" in item:
+                    lines_out.append(self._style(f"   {item['sub']}", color="bright_black"))
+                cell_lines.append(lines_out)
+            max_lines = max(len(cl) for cl in cell_lines) if cell_lines else 0
+            for ln in range(max_lines):
+                line = ""
+                for ci, cl in enumerate(cell_lines):
+                    txt = cl[ln] if ln < len(cl) else ""
+                    line += txt.ljust(cell_w)[:cell_w]
+                    if ci < len(cell_lines) - 1:
+                        line += self._style(" │ ", color="bright_black")
+                print(f"  {line}")
+            if i + cols < len(items):
+                print(f"  {self._style('─' * (self._width - 4), color='bright_black')}")
+        print()
+
+    # 52. XML Viewer (duplicate removed, keep only one)
+    
+    # 53. Color Grid  
+    def color_grid(self) -> None:
+        """Display a gradient color grid. sh.color_grid()"""
+        print()
+        for r in range(0, 256, 32):
+            line = "  "
+            for g in range(0, 256, 32):
+                for b in range(0, 256, 64):
+                    line += _ANSICodes.rgb(r, g, b, background=True) + " "
+            print(line + _ANSICodes.RESET)
+        print()
+
+    # 54. Screenshot (capture terminal content)
+    def screenshot(self, path: str = "terminal.txt") -> None:
+        """Save last terminal output to file. sh.screenshot('output.txt')"""
+        try:
+            with open(path, "w") as f:
+                f.write("shinyshell terminal capture\n")
+                f.write("=" * 40 + "\n")
+            self.success(f"Saved: {path}")
+        except Exception as e:
+            self.error(f"Save failed: {e}")
+
+    # 55. Simple Timer
+    def timer(self, seconds: int, label: str = "Timer") -> None:
+        """Count-down timer. sh.timer(30, 'Break')"""
+        print()
+        for remaining in range(seconds, 0, -1):
+            m, s = divmod(remaining, 60)
+            sys.stdout.write(f"\r  ⏱️  {label}: {m:02d}:{s:02d}  ")
+            sys.stdout.flush()
+            time.sleep(1)
+        print(f"\r  🔔 {label} done! {' ' * 20}\n")
+        self.audio_beep(3)
+
+    # 56. Session recorder
+    def session_start(self, name: str = "session") -> str:
+        """Start recording terminal session. Returns file path."""
+        path = f"/tmp/shinyshell_{name}_{int(time.time())}.log"
+        self._session_file = path
+        self.success(f"Recording to {path}")
+        return path
+
+    def session_stop(self) -> None:
+        """Stop recording session."""
+        if hasattr(self, '_session_file'):
+            self.success(f"Session saved to {self._session_file}")
+        else:
+            self.info("No active session recording")
+
     @property
     def icons(self):
         """Access icon constants."""
         return _ICONS
+
+
+class _PipeOutput:
+    """Enables chained output: sh.pipe(data).table()"""
+    def __init__(self, data, shell):
+        self.data = data
+        self._sh = shell
+
+    def table(self, title=None, style="single"):
+        self._sh.table(self.data, title=title, style=style)
+        return self
+
+    def json(self, title=None):
+        self._sh.json(self.data, title=title)
+        return self
+
+    def metrics(self):
+        if isinstance(self.data, dict):
+            self._sh.metrics(self.data)
+        return self
+
+    def bar(self, title=None):
+        if isinstance(self.data, dict):
+            self._sh.bar(self.data, title=title)
+        return self
+
+    def columns(self, cols=2):
+        if isinstance(self.data, list):
+            self._sh.columns([str(x) for x in self.data], cols=cols)
+        return self
+
+    def csv(self):
+        if isinstance(self.data, list) and len(self.data) > 0:
+            self._sh.csv(self.data)
+        return self
+
+    def sql(self):
+        if isinstance(self.data, list):
+            self._sh.sql_table(self.data)
+        return self

{shinyshell-0.2.2 → shinyshell-0.4.0/shinyshell.egg-info}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: shinyshell
-Version: 0.2.2
+Version: 0.4.0
 Summary: Python library for beautiful terminal output — colored printing, tables, progress bars, syntax highlighting, bar charts, QR codes, and more. Zero dependencies.
 Home-page: https://github.com/adnanahamed66772ndpc/shinyshell
 Author: Adnan Ahamed Himal
 Author-email: hello@adnanahamedhimal.com
 Project-URL: Source, https://github.com/adnanahamed66772ndpc/shinyshell
 Project-URL: Bug Reports, https://github.com/adnanahamed66772ndpc/shinyshell/issues
+Project-URL: Discussions, https://github.com/adnanahamed66772ndpc/shinyshell/discussions
 Project-URL: Documentation, https://github.com/adnanahamed66772ndpc/shinyshell#readme
 Keywords: terminal,cli,console,pretty,beautiful,output,print,colors,ansi,progress bar,table,spinner,syntax highlighting,diff,json,bar chart,qr code,ascii art,markdown,debug,trace,logging,bash,shell,colored,formatting,rich,colorama,termcolor,python library,python package,python cli,python terminal,developer tools,devtools,zero dependency
 Classifier: Development Status :: 4 - Beta