fifu-tui 1.4.5

package/fifu/screens/search.py

@@ -0,0 +1,231 @@
+"""Search screen for channel name input."""
+
+from textual.app import ComposeResult
+from textual.containers import Container, Vertical, Horizontal
+from textual.screen import Screen
+from textual.widgets import Button, Input, Label, LoadingIndicator, ListItem, ListView
+from fifu.services.youtube import ChannelInfo
+
+
+class SearchScreen(Screen):
+    """Screen for searching YouTube channels."""
+
+    CSS = """
+    #search-container {
+        width: 100%;
+        height: 100%;
+        align: center middle;
+    }
+
+    #search-box {
+        width: 70;
+        height: auto;
+        padding: 1 2;
+        border: round $primary;
+        background: $surface-darken-1;
+    }
+
+    #search-title {
+        width: 100%;
+        text-align: center;
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+
+    #search-subtitle {
+        width: 100%;
+        text-align: center;
+        color: $text-muted;
+        margin-bottom: 2;
+    }
+
+    #search-input {
+        width: 100%;
+        margin-bottom: 1;
+    }
+
+    #search-button {
+        width: 100%;
+        margin-top: 1;
+    }
+
+    #search-status {
+        width: 100%;
+        text-align: center;
+        color: $warning;
+        margin-top: 1;
+        height: 3;
+    }
+
+    #loading {
+        width: 100%;
+        height: 3;
+        margin-top: 1;
+        display: none;
+    }
+
+    #shoutouts {
+        width: 100%;
+        text-align: center;
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+
+    .shoutout-link {
+        color: $accent;
+        text-style: italic;
+    }
+
+    #lists-container {
+        width: 100%;
+        height: auto;
+        margin-top: 1;
+    }
+
+    .list-section {
+        width: 1fr;
+        height: auto;
+        padding: 0 1;
+    }
+
+    .section-title {
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+
+    #history-list, #favorites-list {
+        background: $surface;
+        border: none;
+        height: auto;
+        min-height: 3;
+        max-height: 8;
+    }
+
+    ListItem {
+        padding: 0 1;
+    }
+
+    ListItem:hover {
+        background: $accent 20%;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        """Create the search screen layout."""
+        with Container(id="search-container"):
+            with Vertical(id="search-box"):
+                yield Label("🎬 FIFU", id="search-title")
+                yield Label("YouTube Channel or Playlist Downloader", id="search-subtitle")
+                yield Label(
+                    "Shout out to [b]The PrimeTime[/b] & [b]Devtopia[/b] ⚡", 
+                    id="shoutouts"
+                )
+                yield Input(
+                    placeholder="Enter channel name or paste playlist URL...",
+                    id="search-input",
+                )
+                yield Button("Search / Process URL", id="search-button", variant="primary")
+                yield LoadingIndicator(id="loading")
+                yield Label("", id="search-status")
+
+                with Horizontal(id="lists-container"):
+                    with Vertical(classes="list-section"):
+                        yield Label(" Recent", classes="section-title")
+                        yield ListView(id="history-list")
+                    
+                    with Vertical(classes="list-section"):
+                        yield Label("⭐ Favorites", classes="section-title")
+                        yield ListView(id="favorites-list")
+
+    def on_mount(self) -> None:
+        """Initialize the screen."""
+        self.query_one("#search-input", Input).focus()
+        self._refresh_lists()
+
+    def on_screen_resume(self) -> None:
+        """Refresh lists when returning to this screen."""
+        self._refresh_lists()
+
+    def _refresh_lists(self) -> None:
+        """Reload history and favorites from config."""
+        history_list = self.query_one("#history-list", ListView)
+        fav_list = self.query_one("#favorites-list", ListView)
+        
+        history_list.clear()
+        for item in self.app.config_service.get_history():
+            li = ListItem(Label(item))
+            li.history_query = item  # Store original query safely
+            history_list.append(li)
+            
+        fav_list.clear()
+        for fav in self.app.config_service.get_favorites():
+            fav_list.append(ListItem(
+                Label(f"📺 {fav['name']} ({fav.get('sub_count_str', 'N/A')})"), 
+                id=f"fav-{fav['id']}"
+            ))
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle search button press."""
+        if event.button.id == "search-button":
+            self._do_search()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle enter key in input."""
+        if event.input.id == "search-input":
+            self._do_search()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Handle selection in history or favorites."""
+        item = event.item
+        if hasattr(item, "history_query"):
+            query = item.history_query
+            self.query_one("#search-input", Input).value = query
+            self._do_search()
+        elif item.id and item.id.startswith("fav-"):
+            channel_id = item.id[4:]
+            favorites = self.app.config_service.get_favorites()
+            fav = next((f for f in favorites if f["id"] == channel_id), None)
+            if fav:
+                channel = ChannelInfo(
+                    id=fav["id"],
+                    name=fav["name"],
+                    url=fav["url"]
+                )
+                self.app.select_channel(channel)
+
+    def _do_search(self) -> None:
+        """Perform the channel search."""
+        input_widget = self.query_one("#search-input", Input)
+        query = input_widget.value.strip()
+        
+        if not query:
+            status = self.query_one("#search-status", Label)
+            status.update("Please enter a channel name")
+            return
+        
+        status = self.query_one("#search-status", Label)
+        status.update("Searching...")
+        
+        self.app.search_channels(query)
+
+    def show_error(self, message: str) -> None:
+        """Display an error message."""
+        self.query_one("#loading").display = False
+        try:
+            self.query_one("#search-button").display = True
+        except Exception:
+            pass
+        status = self.query_one("#search-status", Label)
+        status.update(f"❌ {message}")
+
+    def show_searching(self) -> None:
+        """Show searching status."""
+        try:
+            self.query_one("#search-button").display = False
+        except Exception:
+            pass
+        self.query_one("#loading").display = True
+        status = self.query_one("#search-status", Label)
+        status.update("🔍 Searching...")

package/fifu/services/__init__.py

@@ -0,0 +1,7 @@
+"""Fifu services for YouTube and download management."""
+
+from fifu.services.youtube import YouTubeService, ChannelInfo, VideoInfo, PlaylistInfo
+from fifu.services.downloader import DownloadService
+from fifu.services.config import ConfigService
+
+__all__ = ["YouTubeService", "ChannelInfo", "VideoInfo", "PlaylistInfo", "DownloadService", "ConfigService"]

package/fifu/services/config.py

@@ -0,0 +1,87 @@
+"""Service for managing persistent configuration and history."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+class ConfigService:
+    """Manages application configuration, history, and favorites."""
+
+    def __init__(self):
+        self.config_dir = Path.home() / ".config" / "fifu"
+        self.config_file = self.config_dir / "data.json"
+        self._data = {
+            "history": [],
+            "favorites": []
+        }
+        self._load()
+
+    def _load(self) -> None:
+        """Load data from JSON file."""
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, "r") as f:
+                    loaded_data = json.load(f)
+                    # Merge with defaults to handle schema changes
+                    self._data.update(loaded_data)
+            except Exception:
+                pass
+
+    def _save(self) -> None:
+        """Save data to JSON file."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            with open(self.config_file, "w") as f:
+                json.dump(self._data, f, indent=4)
+        except Exception:
+            pass
+
+    def get_history(self) -> list[str]:
+        """Get search history."""
+        return self._data.get("history", [])
+
+    def add_history(self, query: str) -> None:
+        """Add a query to history, ensuring unique and limited to 10 items."""
+        if not query:
+            return
+            
+        history = self.get_history()
+        # Remove if already exists to move to top
+        if query in history:
+            history.remove(query)
+            
+        history.insert(0, query)
+        self._data["history"] = history[:10]
+        self._save()
+
+    def clear_history(self) -> None:
+        """Clear search history."""
+        self._data["history"] = []
+        self._save()
+
+    def get_favorites(self) -> list[dict[str, Any]]:
+        """Get favorite channels."""
+        return self._data.get("favorites", [])
+
+    def is_favorite(self, channel_id: str) -> bool:
+        """Check if a channel is in favorites."""
+        return any(f.get("id") == channel_id for f in self.get_favorites())
+
+    def toggle_favorite(self, channel_info_dict: dict[str, Any]) -> bool:
+        """Add/remove channel from favorites. Returns True if now a favorite."""
+        favorites = self.get_favorites()
+        channel_id = channel_info_dict.get("id")
+        
+        existing = next((f for f in favorites if f.get("id") == channel_id), None)
+        
+        if existing:
+            favorites.remove(existing)
+            result = False
+        else:
+            favorites.insert(0, channel_info_dict)
+            result = True
+            
+        self._data["favorites"] = favorites
+        self._save()
+        return result

package/fifu/services/downloader.py

@@ -0,0 +1,190 @@
+"""Download service for managing video downloads."""
+
+import re
+from dataclasses import dataclass, field
+import logging
+from pathlib import Path
+from typing import Callable, Optional
+import yt_dlp
+
+
+@dataclass
+class DownloadProgress:
+    """Progress information for a download."""
+    video_title: str
+    status: str
+    downloaded_bytes: int = 0
+    total_bytes: int = 0
+    speed: Optional[str] = None
+    eta: Optional[str] = None
+    percent: float = 0.0
+
+
+@dataclass
+class DownloadResult:
+    """Result of a download operation."""
+    success: bool
+    video_title: str
+    file_path: Optional[Path] = None
+    error: Optional[str] = None
+
+
+@dataclass
+class DownloadQueue:
+    """Queue of videos to download."""
+    channel_name: str
+    videos: list = field(default_factory=list)
+    current_index: int = 0
+    downloaded_ids: set = field(default_factory=set)
+
+
+class DownloadService:
+    """Service for downloading YouTube videos."""
+
+    def __init__(self):
+        self.log_file = Path.home() / ".config" / "fifu" / "downloader.log"
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        logging.basicConfig(
+            filename=str(self.log_file),
+            level=logging.DEBUG,
+            format="%(asctime)s - %(levelname)s - %(message)s",
+        )
+        logging.info("Downloader service initialized")
+
+    def get_download_path(self, channel_name: str) -> Path:
+        """Get the download path for a channel."""
+        safe_name = self._sanitize_filename(channel_name)
+        downloads_dir = Path.home() / "Downloads" / "videos" / safe_name
+        downloads_dir.mkdir(parents=True, exist_ok=True)
+        return downloads_dir
+
+    def _sanitize_filename(self, name: str) -> str:
+        """Sanitize a string for use as a filename."""
+        safe = re.sub(r'[<>:"/\\|?*]', '', name)
+        safe = safe.strip('. ')
+        return safe or "unknown_channel"
+
+
+    def download_video(
+        self,
+        video_url: str,
+        output_dir: Path,
+        progress_callback: Optional[Callable[[DownloadProgress], None]] = None,
+        quality: str = "best",
+        video_id: str = "unknown",
+        subtitles: bool = False
+    ) -> DownloadResult:
+        """Download a single video with specified quality."""
+        current_title = "Loading..."
+
+        def progress_hook(d: dict):
+            if progress_callback:
+                status = d.get("status", "unknown")
+                if status == "downloading":
+                    downloaded = d.get("downloaded_bytes", 0)
+                    total = d.get("total_bytes") or d.get("total_bytes_estimate", 0)
+                    percent = (downloaded / total * 100) if total > 0 else 0
+                    
+                    progress_callback(DownloadProgress(
+                        video_title=current_title,
+                        status="downloading",
+                        downloaded_bytes=downloaded,
+                        total_bytes=total,
+                        speed=d.get("_speed_str", ""),
+                        eta=d.get("_eta_str", ""),
+                        percent=percent,
+                    ))
+                elif status == "finished":
+                    progress_callback(DownloadProgress(
+                        video_title=current_title,
+                        status="processing",
+                        percent=100.0,
+                    ))
+
+        output_template = str(output_dir / "%(title)s.%(ext)s")
+        
+        if quality == "best":
+            format_str = "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"
+        elif quality == "bestaudio/best":
+            format_str = "bestaudio/best"
+        else:
+            format_str = quality
+        
+        class YDLogger:
+            def debug(self, msg):
+                if msg.startswith('[debug] '): pass
+                else: self.info(msg)
+            def info(self, msg): logging.info(f"yt-dlp: {msg}")
+            def warning(self, msg): logging.warning(f"yt-dlp: {msg}")
+            def error(self, msg): logging.error(f"yt-dlp: {msg}")
+
+        ydl_opts = {
+            "format": format_str,
+            "outtmpl": output_template,
+            "progress_hooks": [progress_hook],
+            "quiet": True,
+            "no_warnings": True,
+            "merge_output_format": "mp4",
+            "logger": YDLogger(),
+            "noprogress": True,
+        }
+
+        if subtitles:
+            ydl_opts.update({
+                "writesubtitles": True,
+                "subtitleslangs": ["en.*", ".*"],
+                "embedsubs": True,
+            })
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            try:
+                info = ydl.extract_info(video_url, download=False)
+                if info:
+                    current_title = info.get("title", "Unknown")
+                    
+                    if progress_callback:
+                        progress_callback(DownloadProgress(
+                            video_title=current_title,
+                            status="starting",
+                            percent=0.0,
+                        ))
+                    
+                    logging.info(f"Starting download: {current_title} ({video_url})")
+                    ydl.download([video_url])
+                    logging.info(f"Download finished: {current_title}")
+                    
+                    filename = ydl.prepare_filename(info)
+                    file_path = Path(filename)
+                    
+                    if not file_path.exists():
+                        mp4_path = file_path.with_suffix('.mp4')
+                        if mp4_path.exists():
+                            file_path = mp4_path
+                    
+                    return DownloadResult(
+                        success=True,
+                        video_title=current_title,
+                        file_path=file_path if file_path.exists() else None,
+                    )
+            except Exception as e:
+                logging.error(f"Download failed for {video_url}: {str(e)}")
+                return DownloadResult(
+                    success=False,
+                    video_title=current_title,
+                    error=str(e),
+                )
+        
+        return DownloadResult(
+            success=False,
+            video_title=current_title,
+            error="Unknown error",
+        )
+
+    def get_downloaded_videos(self, output_dir: Path) -> set[str]:
+        """Get set of already downloaded video titles (without extension)."""
+        downloaded = set()
+        if output_dir.exists():
+            for file in output_dir.iterdir():
+                if file.is_file() and file.suffix in ('.mp4', '.mkv', '.webm', '.m4a', '.mp3'):
+                    downloaded.add(file.stem)
+        return downloaded