Siphon-TUI 2.1.0__py3-none-any.whl

siphon_tui/__init__.py

@@ -0,0 +1,5 @@
+from .tui.app import SiphonTUI
+from .utils import configer
+from .utils.download import Download
+
+__all__ = ["SiphonTUI", "Download", "configer"]

siphon_tui/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

siphon_tui/cli.py

@@ -0,0 +1,18 @@
+def run_cli():
+    from cliss import CLI
+
+    from .tui.app import get_version
+
+    app = CLI(
+        name="Siphon-TUI",
+        description="Siphon-TUI is a TUI audio/video downloader based on yt-dlp",
+        version=get_version(),
+    )
+
+    @app.command()
+    def config(path: str):
+        from .utils.configer import set_path
+
+        print(set_path(path))
+
+    app.run()

siphon_tui/main.py

@@ -0,0 +1,26 @@
+def main():
+    import sys
+
+    from color_kiss import GREEN, RESET
+    from color_kiss.utils import error
+
+    if len(sys.argv) <= 1:
+        from .tui.app import run_tui
+
+        try:
+            run_tui()
+        except KeyboardInterrupt:
+            print(f"{GREEN}Goodbye!{RESET}")
+            sys.exit(0)
+        except Exception as e:
+            sys.exit(error(str(e)))
+    else:
+        from .cli import run_cli
+
+        try:
+            run_cli()
+        except KeyboardInterrupt:
+            print(f"{GREEN}Goodbye!{RESET}")
+            sys.exit(0)
+        except Exception as e:
+            sys.exit(error(str(e)))

siphon_tui/tui/app.py

@@ -0,0 +1,234 @@
+from threading import Thread
+
+from textual import on
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import Button, Footer, Header, Input, Select
+
+from siphon_tui.utils.configer import get_path
+
+AUDIO_CODECS = ["M4A", "MP3", "FLAC", "Opus", "Vorbis", "WAV"]
+VIDEO_CONTAINERS = ["MP4", "MKV", "WebM", "MOV", "AVI", "FLV"]
+LINES_KBPS = ["320", "256", "128", "64"]
+
+VIDEO_CONTAINER_AUDIO_MAP = {
+    "mp4": "m4a",
+    "mov": "m4a",
+    "mkv": "opus",
+    "webm": "opus",
+    "avi": "mp3",
+    "flv": "aac",
+}
+
+SELECT_IDS = {
+    "codec": "audio_codec_select",
+    "container": "video_container_select",
+    "kbps": "kbps_select",
+}
+
+
+def get_version() -> str:
+    """Get version from installed package metadata."""
+    try:
+        from importlib.metadata import version
+
+        return version("Siphon-TUI")
+    except Exception:
+        return "unknown"
+
+
+class SiphonTUI(App):
+    CSS_PATH = "style.tcss"
+
+    def __init__(self):
+        super().__init__()
+        self.theme = "rose-pine"
+        self.codec = None
+        self.container = None
+        self.kbps = 256
+
+        path, error_msg = get_path()
+        self.download_path = path
+
+        self.downloading = False
+        self.cancelled = False
+        self._path_error = error_msg
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Container(id="main_container"):
+            yield Input(id="url_input", placeholder="Enter your URL", type="text")
+            with Vertical(id="select_section"):
+                with Horizontal(id="codecs_row"):
+                    yield Select(
+                        ((c, c.lower()) for c in AUDIO_CODECS),
+                        id=SELECT_IDS["codec"],
+                        prompt="Audio codec",
+                    )
+                    yield Select(
+                        ((c, c.lower()) for c in VIDEO_CONTAINERS),
+                        id=SELECT_IDS["container"],
+                        prompt="Container (optional)",
+                    )
+                yield Select(
+                    ((k, k) for k in LINES_KBPS),
+                    id=SELECT_IDS["kbps"],
+                    prompt="Bitrate (kbps)",
+                )
+            with Horizontal(id="button_row"):
+                yield Button("Download", variant="success", id="accept_button")
+                yield Button(
+                    "Cancel", variant="error", id="cancel_button", disabled=True
+                )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.title = "Siphon-TUI"
+        self.sub_title = f"v{get_version()}"
+
+        if self._path_error:
+            self.notify(
+                f"⚠️ {self._path_error}\nUsing: {self.download_path}",
+                severity="warning",
+                timeout=10,
+            )
+
+    @on(Select.Changed)
+    def select_changed(self, event: Select.Changed) -> None:
+        if event.value in (Select.BLANK, Select.NULL):
+            setattr(
+                self,
+                {
+                    "audio_codec_select": "codec",
+                    "video_container_select": "container",
+                    "kbps_select": "kbps",
+                }[event.select.id],
+                None,
+            )
+            return
+
+        if event.select.id == SELECT_IDS["codec"]:
+            self.codec = str(event.value).lower()
+        elif event.select.id == SELECT_IDS["container"]:
+            self.container = str(event.value).lower()
+            if self.container:
+                audio_codec = VIDEO_CONTAINER_AUDIO_MAP.get(self.container)
+                if audio_codec:
+                    self.codec = audio_codec
+                    codec_select = self.query_one(f"#{SELECT_IDS['codec']}", Select)
+                    for option in codec_select._options:
+                        if (
+                            option[1] not in (Select.BLANK, Select.NULL)
+                            and str(option[1]).lower() == audio_codec
+                        ):
+                            codec_select.value = option[1]
+                            break
+        elif event.select.id == SELECT_IDS["kbps"]:
+            self.kbps = int(event.value)
+
+    @on(Button.Pressed, "#accept_button")
+    def action_download(self) -> None:
+        url = self.query_one("#url_input", Input).value.strip()
+        if not url:
+            return self.notify("❌ Please enter a URL", severity="warning")
+        if not url.startswith(("http://", "https://")):
+            return self.notify("❌ Invalid URL", severity="error")
+        if not self._validate_settings():
+            return
+
+        self.cancelled = False
+        self.downloading = True
+        self.query_one("#accept_button", Button).disabled = True
+        self.query_one("#cancel_button", Button).disabled = False
+        self.query_one("#url_input", Input).disabled = True
+
+        msg = (
+            f"⬇️ Downloading {self.codec.upper()} -> {self.container.upper()} @ {self.kbps}kbps..."
+            if self.container
+            else f"⬇️ Downloading {self.codec.upper()} @ {self.kbps}kbps (audio only)..."
+        )
+        self.notify(msg)
+
+        self.download_thread = Thread(
+            target=self._start_download, args=(url,), daemon=True
+        )
+        self.download_thread.start()
+
+    @on(Button.Pressed, "#cancel_button")
+    def action_cancel(self) -> None:
+        if self.downloading:
+            self.cancelled = True
+            self.notify("Cancelling...", severity="warning")
+        else:
+            self.notify("Nothing to cancel", severity="warning")
+            self._reset_ui()
+
+    def _start_download(self, url: str) -> None:
+        from siphon_tui.utils.download import (
+            Download,
+            DownloadCancelledError,
+            DownloadError,
+        )
+
+        try:
+            downloader = Download(
+                url=url,
+                codec=self.container or self.codec,
+                kbps=self.kbps,
+                download_path=self.download_path,
+            )
+            downloader.set_cancel_check(lambda: self.cancelled)
+            downloader.download()
+            self.call_from_thread(
+                self._download_complete,
+                True,
+                f"Download completed on {self.download_path}",
+            )
+        except DownloadCancelledError:
+            self.call_from_thread(self._download_complete, False, "Download cancelled")
+        except DownloadError as e:
+            self.call_from_thread(self._download_complete, False, str(e))
+        except Exception as e:
+            self.call_from_thread(self._download_complete, False, f"Error: {e}")
+
+    def _download_complete(self, success: bool, message: str) -> None:
+        self.downloading = False
+        self.cancelled = False
+        self._reset_ui()
+        self.notify(
+            f"{'✅' if success else '❌'} {message}",
+            severity="information" if success else "error",
+        )
+
+    def _reset_ui(self) -> None:
+        self.query_one("#accept_button", Button).disabled = False
+        self.query_one("#cancel_button", Button).disabled = True
+        url_input = self.query_one("#url_input", Input)
+        url_input.disabled = False
+        url_input.value = ""
+        url_input.focus()
+
+    def _validate_settings(self) -> bool:
+        if self.container:
+            if not self.codec:
+                self.notify(
+                    "❌ Failed to set audio codec for container", severity="error"
+                )
+                return False
+        elif not self.codec:
+            codec_select = self.query_one(f"#{SELECT_IDS['codec']}", Select)
+            if codec_select.value not in (Select.BLANK, Select.NULL):
+                self.codec = str(codec_select.value).lower()
+            else:
+                self.notify(
+                    "❌ Please select audio codec or video container",
+                    severity="warning",
+                )
+                return False
+        self.kbps = self.kbps or 256
+        return True
+
+
+def run_tui():
+    app = SiphonTUI()
+    app.run()

siphon_tui/utils/configer.py

@@ -0,0 +1,89 @@
+import json
+import sys
+from pathlib import Path
+
+from color_kiss.utils import error, success
+from platformdirs import user_config_dir
+
+# Cross-platform paths:
+# Windows: %APPDATA%/Siphon/
+# macOS:   ~/Library/Application Support/Siphon/
+# Linux:   ~/.config/Siphon/
+CONFIG_DIR = Path(user_config_dir("Siphon"))
+CONFIG_FILE = CONFIG_DIR / "config.json"
+HOME_PATH = str(Path.home())
+
+KEY_NAME = "path"
+
+
+def _ensure_config_dir() -> None:
+    """Create config directory if it doesn't exist."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _load_config() -> dict:
+    """Load config file or return empty dict if not exists."""
+    if not CONFIG_FILE.exists():
+        return {}
+
+    try:
+        return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, FileNotFoundError):
+        error("Config file is corrupted. Creating new one...")
+        return {}
+
+
+def _save_config(data: dict) -> None:
+    """Save config data to file."""
+    _ensure_config_dir()
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=4)
+
+
+def set_path(path: str) -> str:
+    """
+    Manage download directory storage.
+    - With path: saves to config.json
+    - Without path: displays current config
+    """
+    try:
+        input_path = Path(path).expanduser().resolve()
+        if not input_path.is_dir():
+            sys.exit(error("Please enter the correct path!"))
+
+        path_str = str(input_path)
+
+        _ensure_config_dir()
+        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+            json.dump({KEY_NAME: path_str}, f, ensure_ascii=False, indent=4)
+
+        return success(f"\nPath: {path_str}\nConfig file: {CONFIG_FILE}")
+    except PermissionError:
+        return error(f"\nPermission denied! Cannot write to {CONFIG_FILE}")
+    except OSError as e:
+        return error(f"\nError saving configuration: {e}")
+
+
+def get_path() -> tuple[str, str | None]:
+    """
+    Read download path from config.json.
+    Returns (path, error_message).
+    If error_message is None, path is valid.
+    """
+    if not CONFIG_FILE.exists():
+        return HOME_PATH, None
+
+    try:
+        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+            config = json.load(f)
+
+        if not config or KEY_NAME not in config:
+            return HOME_PATH, "Download path not set in config"
+
+        path = config[KEY_NAME]
+        if not Path(path).is_dir():
+            return HOME_PATH, f"Download path does not exist: {path}"
+
+        return path, None
+    except (json.JSONDecodeError, FileNotFoundError):
+        return HOME_PATH, "Config file is corrupted! Run: siphon-tui set /path"

siphon_tui/utils/download.py

@@ -0,0 +1,133 @@
+"""
+Sync YouTube downloader with cancellation support for Rhythmer TUI.
+"""
+
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Optional
+
+AUDIO_CODECS = frozenset({"mp3", "aac", "flac", "m4a", "opus", "vorbis", "wav"})
+
+VIDEO_CONTAINER_AUDIO_MAP = {
+    "mp4": "m4a",
+    "mov": "m4a",
+    "mkv": "opus",
+    "webm": "opus",
+    "avi": "mp3",
+    "flv": "aac",
+}
+
+
+class DownloadError(Exception):
+    pass
+
+
+class DownloadCancelledError(DownloadError):
+    pass
+
+
+@dataclass
+class Download:
+    """Synchronous audio/video downloader using yt-dlp with cancellation support."""
+
+    url: str
+    codec: str
+    kbps: int
+    download_path: str
+    max_concurrent: int = 3
+
+    _cancel_callback: Optional[Callable[[], bool]] = field(default=None, repr=False)
+    _cancelled: bool = field(default=False, init=False, repr=False)
+
+    def __post_init__(self):
+        """Validate inputs on instantiation."""
+        self.codec = self.codec.lower()
+        self.is_audio = self.codec in AUDIO_CODECS
+
+        if shutil.which("ffmpeg") is None:
+            raise DownloadError(
+                "FFmpeg not found in PATH! Please install FFmpeg first."
+            )
+        if not Path(self.download_path).exists():
+            raise DownloadError(f"Download path does not exist: {self.download_path}")
+
+    def set_cancel_check(self, callback: Callable[[], bool]) -> None:
+        """Set a callback that returns True if download should be cancelled."""
+        self._cancel_callback = callback
+
+    def cancel(self) -> None:
+        """Mark the download as cancelled."""
+        self._cancelled = True
+
+    def _check_cancelled(self) -> bool:
+        """Check if download has been cancelled via callback or flag."""
+        if self._cancelled:
+            return True
+        if self._cancel_callback and self._cancel_callback():
+            self._cancelled = True
+            return True
+        return False
+
+    def _get_opts(self) -> dict:
+        """Build yt-dlp options dict based on codec type (audio or video)."""
+        base_opts = {
+            "quiet": True,
+            "no_warnings": True,
+            "nooverwrites": True,
+            "outtmpl": str(Path(self.download_path) / "%(title)s.%(ext)s"),
+            "concurrent_fragment_downloads": self.max_concurrent,
+        }
+
+        if self.is_audio:
+            base_opts["format"] = "bestaudio/best"
+            base_opts["postprocessors"] = [
+                {
+                    "key": "FFmpegExtractAudio",
+                    "preferredcodec": self.codec,
+                    "preferredquality": str(self.kbps),
+                },
+                {"key": "FFmpegMetadata"},
+                {"key": "EmbedThumbnail"},
+            ]
+
+            if self.codec == "wav":
+                base_opts["postprocessors"] = [
+                    p
+                    for p in base_opts["postprocessors"]
+                    if p["key"] not in ["FFmpegMetadata", "EmbedThumbnail"]
+                ]
+            elif self.codec in {"m4a", "aac"}:
+                base_opts["format"] = (
+                    "bestaudio[ext=m4a]/bestaudio[ext=aac]/bestaudio/best"
+                )
+                base_opts["postprocessors"] = [
+                    p
+                    for p in base_opts["postprocessors"]
+                    if p["key"] != "FFmpegExtractAudio"
+                ]
+        else:
+            audio_ext = VIDEO_CONTAINER_AUDIO_MAP.get(self.codec, "m4a")
+            format_str = (
+                f"bestvideo[ext=mp4]+bestaudio[ext={audio_ext}]/bestvideo+bestaudio/best"
+                if self.codec == "mp4"
+                else f"bestvideo+bestaudio[ext={audio_ext}]/bestvideo+bestaudio/best"
+            )
+            base_opts.update(format=format_str, merge_output_format=self.codec)
+
+        return base_opts
+
+    def download(self) -> None:
+        """Download a single URL synchronously. Raises DownloadError or DownloadCancelledError."""
+        if self._check_cancelled():
+            raise DownloadCancelledError("Download was cancelled before starting")
+
+        try:
+            from yt_dlp import YoutubeDL
+
+            with YoutubeDL(self._get_opts()) as ydl:
+                ydl.download([self.url])
+        except Exception as e:
+            if self._cancelled:
+                raise DownloadCancelledError("Download was cancelled") from e
+            raise DownloadError(f"Download failed: {e}") from e

siphon_tui-2.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: Siphon-TUI
+Version: 2.1.0
+Summary: Siphon-TUI is a TUI audio/video downloader based on yt-dlp
+Project-URL: Homepage, https://github.com/Fkernel653/Siphon-TUI
+Project-URL: Repository, https://github.com/Fkernel653/Siphon-TUI.git
+Project-URL: Documentation, https://github.com/Fkernel653/Siphon-TUI#readme
+Keywords: yt-dlp,downloader,tui,terminal,textual,video,audio,youtube,cli,multimedia
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: yt-dlp
+Requires-Dist: textual
+Requires-Dist: mutagen
+Requires-Dist: color-kiss
+Requires-Dist: cliss
+Requires-Dist: platformdirs
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# Siphon-TUI — Download audio/video from YouTube, SoundCloud, and 1000+ sites via interactive terminal UI
+
+[![Python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://python.org)
+[![PyPI](https://img.shields.io/pypi/v/siphon-tui.svg)](https://pypi.org/project/siphon-tui/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macOS%20%7C%20windows-lightgrey)]()
+[![TUI](https://img.shields.io/badge/TUI-textual-purple.svg)](https://github.com/Textualize/textual)
+[![Ruff](https://img.shields.io/badge/code%20style-ruff-261230?logo=ruff&logoColor=white)](https://docs.astral.sh/ruff/)
+
+Download and tag high-quality music and video from YouTube, YouTube Music, SoundCloud, and 1000+ sites — all from an interactive terminal UI.
+
+![Screenshot](screenshot.png)
+
+## ✨ Features
+
+- **Interactive TUI** — Dropdown selectors, real-time notifications, cancel support
+- **1000+ Supported Sites** — Any site yt-dlp supports
+- **Audio/Video Formats** — MP3, AAC, FLAC, M4A, Opus, Vorbis, WAV, MP4, MKV, WebM, and more with configurable bitrate (64–320 kbps)
+- **Smart Codec Mapping** — Automatically pairs containers with optimal audio codecs (e.g., MP4→AAC, MKV→Opus)
+- **Metadata Embedding** — Title, artist, album tags + cover art thumbnails
+- **Thread-safe** — Responsive UI during downloads with background processing
+- **Cross-platform Config** — XDG-compliant (Linux), Application Support (macOS), AppData (Windows)
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Python 3.10+ & FFmpeg
+
+### Installation
+```bash
+pip install siphon-tui         # pip
+uv pip install siphon-tui      # uv
+pipx install siphon-tui        # pipx
+```
+
+### Usage
+```bash
+siphon-tui config ~/Downloads    # Set download directory (optional)
+siphon-tui                       # Launch TUI (no arguments)
+```
+
+If you skip `config`, files will be saved to `~/Downloads` (or platform equivalent).
+
+## ⌨️ Controls
+
+| Key | Action |
+|-----|--------|
+| `Tab` | Navigate between fields |
+| `↑`/`↓` | Navigate dropdown options |
+| `Enter` | Confirm selection / Start download |
+| `Esc` | Close dropdown |
+| `Ctrl+C` | Exit application |
+
+## 📋 Interface Elements
+
+### Input Fields
+| Field | Description |
+|-------|-------------|
+| **URL Input** | Paste video/audio URL from any supported platform |
+| **Audio Codec** | Select audio format: MP3, AAC, FLAC, M4A, Opus, Vorbis, WAV |
+| **Container** | Optional video container: MP4, MKV, WebM, MOV, AVI, FLV |
+| **Bitrate** | Audio quality: 64, 128, 256, 320 kbps |
+
+### Buttons
+| Button | Action |
+|--------|--------|
+| **Download** | Start download with selected settings |
+| **Cancel** | Cancel ongoing download |
+
+### Smart Codec Mapping
+When a video container is selected, the optimal audio codec is automatically set:
+
+| Container | Auto Audio Codec |
+|-----------|:----------------:|
+| MP4, MOV | AAC |
+| MKV, WebM | Opus |
+| AVI | MP3 |
+| FLV | AAC |
+
+## 📖 Examples
+
+```bash
+# Audio download
+siphon-tui
+# → Paste URL → Select "mp3" → Select "320" kbps → Press Download
+
+# Video download
+siphon-tui
+# → Paste URL → Select Container "mp4" → Bitrate auto-sets → Press Download
+
+# Cancel download
+# Press "Cancel" button during active download
+```
+
+## 📁 Project Structure
+```
+siphon_tui/
+├── __init__.py
+├── main.py              # Entry point & CLI/TUI routing
+├── cli.py               # CLI interface (cliss)
+├── tui/
+│   ├── app.py           # Textual TUI application
+│   └── style.tcss       # TUI theme & layout
+└── utils/
+    ├── configer.py      # JSON config manager
+    └── download.py      # Download engine (yt-dlp + mutagen)
+```
+
+## ⚙️ Configuration
+
+The download path is stored in a JSON config file and can be set via CLI:
+
+```bash
+siphon-tui config ~/Music       # Set directory
+siphon-tui config                # View current path (if implemented)
+```
+
+Config locations (auto-managed):
+- **Linux:** `~/.config/siphon-tui/config.json`
+- **macOS:** `~/Library/Application Support/siphon-tui/config.json`
+- **Windows:** `%APPDATA%\siphon-tui\config.json`
+
+## 🔧 Requirements
+
+| Dependency | Purpose |
+|------------|---------|
+| `textual` | TUI framework for interactive terminal apps |
+| `yt-dlp` | Media extraction from 1000+ platforms |
+| `mutagen` | Audio metadata tagging and cover art embedding |
+| `platformdirs` | Cross-platform config paths |
+| `color-kiss` | Terminal colors |
+| `cliss` | CLI framework |
+| **FFmpeg** | Audio/video conversion (system) |
+
+## 📄 License
+
+MIT License — see [LICENSE](LICENSE) file.
+
+## 🙏 Acknowledgments
+
+- [Textual](https://github.com/Textualize/textual) – Modern TUI framework
+- [yt-dlp](https://github.com/yt-dlp/yt-dlp) – Download engine
+- [mutagen](https://github.com/quodlibet/mutagen) – Metadata tagging
+- [platformdirs](https://github.com/platformdirs/platformdirs) – Config paths
+- [color-kiss](https://github.com/Fkernel653/color-kiss) – Terminal colors
+- [cliss](https://github.com/Fkernel653/cliss) – CLI framework
+
+## ⚠️ Disclaimer
+
+**For educational purposes only.** Users are responsible for complying with platform Terms of Service and applicable copyright laws. Download only content you have permission to download.
+
+---
+
+**Author:** [Fkernel653](https://github.com/Fkernel653)
+**Repository:** [github.com/Fkernel653/Siphon-TUI](https://github.com/Fkernel653/Siphon-TUI)
+**PyPI:** [pypi.org/project/siphon-tui](https://pypi.org/project/siphon-tui/)

siphon_tui-2.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+siphon_tui/__init__.py,sha256=7lm2OXLtvKW2f5Yr4n0s03LJDfIdiS9On91zwhwWIt8,145
+siphon_tui/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
+siphon_tui/cli.py,sha256=VFodQQTrxtmYa8EAlZqkLldhgQWo1xrsiaGLL_PNlJM,379
+siphon_tui/main.py,sha256=OUu7sICGZrurnIH7y-U7VsdkZVilhaOwn_W0xba-WPk,627
+siphon_tui/tui/app.py,sha256=p39TJ6H3uYrlhDnvylaBxlRGNk4mCn93C7WZ2S-wcEc,8109
+siphon_tui/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siphon_tui/utils/configer.py,sha256=1B4RbMzxognuuY7hgligKsOauQ-E0nwwZXlmRNUaXE0,2673
+siphon_tui/utils/download.py,sha256=FpDE8JCB3wFAf494pwXNg7k8S-b7TOFIFSNczB9FBxw,4448
+siphon_tui-2.1.0.dist-info/licenses/LICENSE,sha256=W8pkVWBfRl4j60erOAE3PfKcLjNEc9V6OPbhxmf3O3k,1063
+siphon_tui-2.1.0.dist-info/METADATA,sha256=p-dNjtDo3TBCQLDHqjvpyE5-1rygMJQQDIKffLaz2XY,6958
+siphon_tui-2.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+siphon_tui-2.1.0.dist-info/entry_points.txt,sha256=d3D9zZDeTZr1RuLNishvByE1PliXCKKYniTNpJusf9w,52
+siphon_tui-2.1.0.dist-info/top_level.txt,sha256=GV2hfTPp4C3fXPMm_DHPJa5r1rLLpMkHZ0fUEbWMS5o,11
+siphon_tui-2.1.0.dist-info/RECORD,,

siphon_tui-2.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

siphon_tui-2.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+siphon-tui = siphon_tui.main:main

siphon_tui-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kernel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

siphon_tui-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+siphon_tui