fifu-tui 1.4.5

package/.SRCINFO

@@ -0,0 +1,18 @@
+pkgbase = fifu
+	pkgdesc = A cross-platform TUI for downloading YouTube videos from channels
+	pkgver = 1.4.5
+	pkgrel = 1
+	url = https://github.com/Dawaman43/fifu
+	arch = any
+	license = MIT
+	makedepends = python-build
+	makedepends = python-installer
+	makedepends = python-hatchling
+	depends = python
+	depends = python-textual
+	depends = yt-dlp
+	depends = python-click
+	source = https://github.com/Dawaman43/fifu/archive/refs/tags/v1.4.5.tar.gz
+	sha256sums = SKIP
+
+pkgname = fifu

package/.github/workflows/publish.yml

@@ -0,0 +1,45 @@
+name: Publish to PyPI and npm
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  pypi-publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+      - name: Build and publish
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          python -m build
+          twine upload dist/*
+
+  npm-publish:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          registry-url: "https://registry.npmjs.org"
+      - name: Install dependencies
+        run: npm install
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/release.yml

@@ -0,0 +1,134 @@
+name: Build and Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    name: Build (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.11"]
+        include:
+          - os: ubuntu-latest
+            artifact_name: fifu-linux
+          - os: windows-latest
+            artifact_name: fifu-win
+          - os: macos-latest
+            artifact_name: fifu-macos
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install PyInstaller
+          pip install .
+
+      - name: Build with PyInstaller (Linux/macOS)
+        if: runner.os != 'Windows'
+        run: |
+          pyinstaller --onefile --add-data "fifu/styles/app.tcss:fifu/styles" --name fifu fifu/__main__.py
+
+      - name: Build with PyInstaller (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          pyinstaller --onefile --add-data "fifu/styles/app.tcss;fifu/styles" --name fifu-win fifu/__main__.py
+
+      - name: Rename and Prepare (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          mv dist/fifu dist/fifu-linux
+          # Prepare for FPM
+          mkdir -p package/usr/local/bin
+          cp dist/fifu-linux package/usr/local/bin/fifu
+
+      - name: Rename binaries (macOS)
+        if: runner.os == 'macOS'
+        run: mv dist/fifu dist/fifu-macos
+
+      - name: Install FPM (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ruby ruby-dev rubygems build-essential rpm
+          sudo gem install --no-document fpm
+
+      - name: Create .deb (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          fpm -s dir -t deb -n fifu -v ${{ github.ref_name }} \
+            --prefix / \
+            -C package \
+            --description "Fifu - YouTube Channel Video Downloader TUI" \
+            --maintainer "Dawaman43 <github.com/Dawaman43>" \
+            --url "https://github.com/Dawaman43/fifu" \
+            dist/fifu.deb
+
+      - name: Create .rpm (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          fpm -s dir -t rpm -n fifu -v ${{ github.ref_name }} \
+            --prefix / \
+            -C package \
+            --description "Fifu - YouTube Channel Video Downloader TUI" \
+            --maintainer "Dawaman43 <github.com/Dawaman43>" \
+            --url "https://github.com/Dawaman43/fifu" \
+            dist/fifu.rpm
+
+      - name: Create .tar.gz (Linux/Arch)
+        if: runner.os == 'Linux'
+        run: |
+          cd dist && tar -czvf fifu-linux-x64.tar.gz fifu-linux && cd ..
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact_name }}
+          path: |
+            dist/fifu-linux
+            dist/fifu-win.exe
+            dist/fifu-macos
+            dist/fifu.deb
+            dist/fifu.rpm
+            dist/fifu-linux-x64.tar.gz
+
+  release:
+    name: Create Release
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+          path: dist
+
+      - name: List files (Debug)
+        run: ls -R dist
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            dist/fifu-linux
+            dist/fifu-linux-x64.tar.gz
+            dist/fifu-win.exe
+            dist/fifu-macos
+            dist/fifu.deb
+            dist/fifu.rpm
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/PKGBUILD

@@ -0,0 +1,22 @@
+# Maintainer: Dawaman43 <github.com/Dawaman43>
+pkgname=fifu
+pkgver=1.4.5
+pkgrel=1
+pkgdesc="A cross-platform TUI for downloading YouTube videos from channels"
+arch=('any')
+url="https://github.com/Dawaman43/fifu"
+license=('MIT')
+depends=('python' 'python-textual' 'yt-dlp' 'python-click')
+makedepends=('python-build' 'python-installer' 'python-hatchling')
+source=("https://github.com/Dawaman43/fifu/archive/refs/tags/v${pkgver}.tar.gz")
+sha256sums=('SKIP')
+
+build() {
+    cd "${pkgname}-${pkgver}"
+    python -m build --wheel --no-isolation
+}
+
+package() {
+    cd "${pkgname}-${pkgver}"
+    python -m installer --destdir="$pkgdir" dist/*.whl
+}

package/README.md

@@ -0,0 +1,104 @@
+# 🎬 Fifu
+
+**The Ultra-Fast, Cross-Platform TUI for Downloading YouTube Channel Content.**
+
+[![Build Status](https://github.com/Dawaman43/fifu/actions/workflows/publish.yml/badge.svg)](https://github.com/Dawaman43/fifu/actions)
+[![PyPI version](https://badge.fury.io/py/fifu.svg)](https://badge.fury.io/py/fifu)
+[![AUR version](https://img.shields.io/aur/version/fifu)](https://aur.archlinux.org/packages/fifu)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+Fifu (Fetch It For Us) is a high-performance Terminal User Interface (TUI) designed for power users who want to download entire YouTube channels or playlists with zero friction. Built with **Textual** and powered by **yt-dlp**.
+
+---
+
+## ✨ Key Features
+
+- 🚀 **Asynchronous Performance** - Multi-threaded metadata fetching and concurrent downloads (3 at a time).
+- 🔍 **Smart Search** - Find any channel instantly, sorted by popularity (subscriber count).
+- 📋 **Playlist Intelligence** - Direct support for downloading entire playlists or specific channel sections.
+- ⚙️ **Custom Quality Profiles** - 1080p, 720p, 480p, or high-fidelity Audio (MP3/M4A).
+- 💬 **Subtitle Support** - Automatically download and embed subtitles into your videos.
+- 💾 **Safe History & Favorites** - One-click access to your most-visited channels.
+- 🏁 **Graceful UX** - Beautiful progress bars, keyboard-first navigation, and instant shutdown.
+
+---
+
+## 🚀 Quick Start
+
+The fastest way to install Fifu on any system is using **pipx**:
+
+```bash
+pipx install git+https://github.com/Dawaman43/fifu.git
+```
+
+---
+
+## 📦 Installation Options
+
+### 🐧 Linux
+
+#### Arch Linux (AUR)
+
+```bash
+yay -S fifu
+```
+
+#### Debian / Ubuntu / Mint
+
+Download the latest `.deb` from [Releases](https://github.com/Dawaman43/fifu/releases) and run:
+
+```bash
+sudo dpkg -i fifu.deb
+```
+
+#### Fedora / RHEL
+
+Download the latest `.rpm` from [Releases](https://github.com/Dawaman43/fifu/releases) and run:
+
+```bash
+sudo rpm -i fifu.rpm
+```
+
+### 🪟 Windows
+
+1. Download `fifu-win.exe` from [Releases](https://github.com/Dawaman43/fifu/releases).
+2. Run it from your terminal or double-click to start.
+
+### 🍎 macOS
+
+```bash
+curl -L -o fifu https://github.com/Dawaman43/fifu/releases/latest/download/fifu-macos
+chmod +x fifu
+./fifu
+```
+
+---
+
+## ⌨️ Controls
+
+| Key             | Action                     |
+| :-------------- | :------------------------- |
+| `Enter`         | Select / Confirm / Start   |
+| `f`             | Toggle Channel as Favorite |
+| `PageUp / Down` | Navigate search results    |
+| `Escape`        | Go back                    |
+| `q`             | Quit Safely                |
+
+---
+
+## 🛠️ Tech Stack
+
+- **[Textual](https://textual.textualize.io/)** - Stunning TUI framework.
+- **[yt-dlp](https://github.com/yt-dlp/yt-dlp)** - The industry standard for video extraction.
+- **[Asyncio](https://docs.python.org/3/library/asyncio.html)** - Powering concurrent downloads.
+
+---
+
+## 📜 License
+
+Fifu is released under the **MIT License**. See [LICENSE](LICENSE) for details.
+
+---
+
+_Made with ❤️ by [Dawaman43](https://github.com/Dawaman43)_

package/bin/fifu.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// This script aims to run the 'fifu' command.
+// If installed via pip, 'fifu' should be in the PATH.
+// If using the bundled binary, it would be different, 
+// but for an npm package that isn't pulling down binaries, 
+// we assume the user has the python environment or we point them to it.
+
+const child = spawn('fifu', process.argv.slice(2), {
+  stdio: 'inherit',
+  shell: true
+});
+
+child.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: "fifu" command not found.');
+    console.error('Please install the python package first: pip install fifu');
+  } else {
+    console.error(`Error: ${err.message}`);
+  }
+  process.exit(1);
+});
+
+child.on('exit', (code) => {
+  process.exit(code);
+});

package/fifu/__init__.py

@@ -0,0 +1,3 @@
+"""Fifu - YouTube Channel Video Downloader TUI"""
+
+__version__ = "0.1.0"

package/fifu/__main__.py

@@ -0,0 +1,16 @@
+"""CLI entry point for Fifu."""
+
+import click
+
+from fifu.app import FifuApp
+
+
+@click.command()
+def main():
+    """Fifu - YouTube Channel Video Downloader TUI"""
+    app = FifuApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

package/fifu/app.py

@@ -0,0 +1,260 @@
+"""Main Fifu Textual application."""
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Optional
+
+from textual.app import App
+from textual.binding import Binding
+
+from fifu.screens.search import SearchScreen
+from fifu.screens.channels import ChannelsScreen
+from fifu.screens.download import DownloadScreen
+from fifu.screens.options import OptionsScreen
+from fifu.services.youtube import YouTubeService, ChannelInfo, VideoInfo, PlaylistInfo, ChannelInfo
+from fifu.services.downloader import DownloadService, DownloadProgress
+from fifu.services.config import ConfigService
+
+
+class FifuApp(App):
+    """Fifu - YouTube Channel Video Downloader TUI."""
+
+    TITLE = "Fifu"
+    SUB_TITLE = "YouTube Channel Video Downloader"
+    
+    if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
+        CSS_PATH = Path(sys._MEIPASS) / "fifu" / "styles" / "app.tcss"
+    else:
+        CSS_PATH = Path(__file__).parent / "styles" / "app.tcss"
+    
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True),
+        Binding("escape", "go_back", "Back", show=True),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.youtube_service = YouTubeService()
+        self.download_service = DownloadService()
+        self.config_service = ConfigService()
+        self._download_task: Optional[asyncio.Task] = None
+        self._stop_downloads = False
+        self._current_channel: Optional[ChannelInfo] = None
+        self._videos: list[VideoInfo] = []
+        self._download_quality = "best"
+        self._max_videos = 9999
+        self._download_subtitles = False
+
+    def on_mount(self) -> None:
+        """Initialize the application."""
+        self.push_screen(SearchScreen())
+
+    async def action_quit(self) -> None:
+        """Handle quit action with cleanup."""
+        self.stop_downloads()
+        self.youtube_service.shutdown()
+        
+        # Cancel any pending asyncio tasks
+        if self._download_task:
+            self._download_task.cancel()
+            try:
+                await self._download_task
+            except asyncio.CancelledError:
+                pass
+        
+        await super().action_quit()
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        if len(self.screen_stack) > 1:
+            self.pop_screen()
+
+    def search_channels(self, query: str) -> None:
+        """Search for channels and display results."""
+        self.run_worker(self._search_channels_async(query), exclusive=True)
+
+    async def _search_channels_async(self, query: str) -> None:
+        """Async worker to search channels."""
+        current_screen = self.screen
+        if not isinstance(current_screen, SearchScreen):
+            return
+        
+        current_screen.show_searching()
+
+        # Check for direct URL
+        if query.startswith(("http://", "https://", "www.youtube.com", "youtube.com")):
+            await self._handle_direct_url(query)
+            return
+        
+        channels = await asyncio.get_event_loop().run_in_executor(
+            None, self.youtube_service.search_channels, query
+        )
+        
+        if not channels:
+            current_screen.show_error("No channels found. Try a different search.")
+            return
+        
+        self.config_service.add_history(query)
+        self.push_screen(ChannelsScreen(channels, query))
+
+    async def _handle_direct_url(self, url: str) -> None:
+        """Handle direct playlist/video URL."""
+        current_screen = self.screen
+        if not isinstance(current_screen, SearchScreen):
+            return
+
+        metadata = await asyncio.get_event_loop().run_in_executor(
+            None, self.youtube_service.get_playlist_metadata, url
+        )
+
+        if metadata:
+            title, uploader = metadata
+            channel = ChannelInfo(
+                id="direct_url",
+                name=title,
+                url=url, # Use original URL
+                description=f"Direct URL from: {uploader}"
+            )
+            self._current_channel = channel
+            self._playlist_url = url
+            self.config_service.add_history(url)
+            self.push_screen(OptionsScreen(channel, [])) # No other playlists to select
+        else:
+            current_screen.show_error("Invalid URL or couldn't fetch metadata.")
+
+    def select_channel(self, channel: ChannelInfo) -> None:
+        """Handle channel selection - show options screen."""
+        self._current_channel = channel
+        self.run_worker(self._load_options_screen(channel), exclusive=True)
+
+    async def _load_options_screen(self, channel: ChannelInfo) -> None:
+        """Load options screen with playlists."""
+        playlists = await asyncio.get_event_loop().run_in_executor(
+            None, self.youtube_service.get_channel_playlists, channel.id
+        )
+        self.push_screen(OptionsScreen(channel, playlists))
+
+    def start_download_with_options(
+        self,
+        channel: ChannelInfo,
+        max_videos: int,
+        quality: str,
+        playlist_url: Optional[str] = None,
+        subtitles: bool = False,
+    ) -> None:
+        """Start downloads with user-selected options."""
+        self._current_channel = channel
+        self._max_videos = max_videos
+        self._download_quality = quality
+        self._playlist_url = playlist_url
+        self._download_subtitles = subtitles
+        self.push_screen(DownloadScreen(channel))
+
+    def start_downloads(self, channel: ChannelInfo) -> None:
+        """Start downloading videos from the channel."""
+        self._stop_downloads = False
+        self._download_task = asyncio.create_task(self._download_loop(channel))
+
+    async def _download_loop(self, channel: ChannelInfo) -> None:
+        """Main download loop with concurrency."""
+        download_screen = self.screen
+        if not isinstance(download_screen, DownloadScreen):
+            return
+
+        download_screen.log_message(f"📡 Fetching videos from {channel.name}...")
+        
+        playlist_url = getattr(self, '_playlist_url', None)
+        if playlist_url:
+            download_screen.log_message(f"📋 Loading playlist...")
+            videos = await asyncio.get_event_loop().run_in_executor(
+                None, 
+                lambda: self.youtube_service.get_playlist_videos(playlist_url, self._max_videos)
+            )
+        else:
+            videos = await asyncio.get_event_loop().run_in_executor(
+                None, 
+                lambda: self.youtube_service.get_channel_videos(channel.url, self._max_videos)
+            )
+        
+        if not videos:
+            download_screen.log_message("No videos found.", "error")
+            download_screen.on_queue_complete()
+            return
+        
+        videos = videos[:self._max_videos]
+        download_screen.log_message(f"📋 Found {len(videos)} videos to download")
+        download_screen.log_message(f"🎬 Quality: {self._download_quality}")
+        if self._download_subtitles:
+            download_screen.log_message("💬 Subtitles: Enabled")
+        
+        output_dir = self.download_service.get_download_path(channel.name)
+        download_screen.log_message(f"📁 Saving to: {output_dir}")
+        
+        downloaded_titles = self.download_service.get_downloaded_videos(output_dir)
+        
+        # Filter out already downloaded
+        to_download = [v for v in videos if v.title not in downloaded_titles]
+        skipped = len(videos) - len(to_download)
+        if skipped:
+            download_screen.log_message(f"⏭ Skipping {skipped} already downloaded videos")
+        
+        download_screen.update_total_progress(0, len(to_download))
+        
+        if not to_download:
+            download_screen.on_queue_complete()
+            return
+
+        # Use Semaphore to limit concurrency
+        semaphore = asyncio.Semaphore(3)
+        tasks = []
+
+        async def download_task(video: VideoInfo, index: int):
+            async with semaphore:
+                if self._stop_downloads:
+                    return
+
+                video_url = f"https://www.youtube.com/watch?v={video.id}"
+                
+                def progress_callback(progress: DownloadProgress):
+                    self.call_from_thread(download_screen.update_progress, progress)
+                
+                quality = self._download_quality
+                subtitles = self._download_subtitles
+                result = await asyncio.get_event_loop().run_in_executor(
+                    None,
+                    lambda: self.download_service.download_video(
+                        video_url, output_dir, progress_callback, quality, subtitles=subtitles
+                    )
+                )
+                
+                if result.success:
+                    self.call_from_thread(download_screen.on_download_complete, result.video_title)
+                else:
+                    self.call_from_thread(
+                        download_screen.on_download_error, 
+                        result.video_title, 
+                        result.error or "Unknown error"
+                    )
+
+        for i, video in enumerate(to_download):
+            tasks.append(asyncio.create_task(download_task(video, i)))
+
+        await asyncio.gather(*tasks)
+        download_screen.on_queue_complete()
+
+    def stop_downloads(self) -> None:
+        """Stop the download loop."""
+        self._stop_downloads = True
+        if self._download_task:
+            self._download_task.cancel()
+
+    def toggle_favorite(self, channel: ChannelInfo) -> bool:
+        """Toggle favorite status for a channel."""
+        channel_dict = {
+            "id": channel.id,
+            "name": channel.name,
+            "url": channel.url,
+            "sub_count_str": getattr(channel, 'subscriber_count_str', 'N/A')
+        }
+        return self.config_service.toggle_favorite(channel_dict)

package/fifu/screens/__init__.py

@@ -0,0 +1,8 @@
+"""Fifu TUI screens."""
+
+from fifu.screens.search import SearchScreen
+from fifu.screens.channels import ChannelsScreen
+from fifu.screens.download import DownloadScreen
+from fifu.screens.options import OptionsScreen
+
+__all__ = ["SearchScreen", "ChannelsScreen", "DownloadScreen", "OptionsScreen"]