npm - git-cli-yt - Versions diffs - 1.2.0 → 2.0.0 - Mend

git-cli-yt 1.2.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/main.py CHANGED Viewed

@@ -1,1065 +1,8 @@
-import json
-import os
-import queue
-import socket
-import sys
-import threading
-import time
-from pathlib import Path
-import av
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-import numpy as np
-import sounddevice as sd
-from textual.app import App, ComposeResult
-from textual.containers import Horizontal, Vertical
-from textual.widgets import (
-    Button,
-    Footer,
-    Header,
-    Input,
-    Label,
-    ListItem,
-    ListView,
-    ProgressBar,
-    Select,
-)
-import yt_dlp
-# Tenta carregar variáveis do .env se existir
-try:
-    from dotenv import load_dotenv
-    load_dotenv(Path.cwd() / ".env")
-    load_dotenv(Path(__file__).resolve().parent / ".env")
-except ImportError:
-    pass
-socket.setdefaulttimeout(15)
-# Diretório para salvar o token do usuário
-CONFIG_DIR = Path.home() / ".config" / "meu-player-tui"
-CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-TOKEN_FILE = CONFIG_DIR / "token.json"
-SCOPES = ["https://www.googleapis.com/auth/youtube.readonly"]
-MUSIC_CATEGORY_ID = "10"
-DEFAULT_CLIENT_ID = os.environ.get(
-    "GOOGLE_CLIENT_ID",
-    "50790974670-qshvlqkejhu0ksj76v0t0lpcq3krm593.apps.googleusercontent.com",
-)
-DEFAULT_CLIENT_SECRET = os.environ.get(
-    "GOOGLE_CLIENT_SECRET", "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"
-)
-def get_client_config():
-    """Retorna a configuração OAuth 2.0 padrão para aplicação desktop."""
-    return {
-        "installed": {
-            "client_id": DEFAULT_CLIENT_ID,
-            "client_secret": DEFAULT_CLIENT_SECRET,
-            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-            "token_uri": "https://oauth2.googleapis.com/token",
-            "redirect_uris": ["http://localhost:8080/"],
-        }
-    }
-def get_youtube_service(interactive=False):
-    """Obtém a conexão com a API do YouTube."""
-    creds = None
-    if TOKEN_FILE.exists():
-        try:
-            creds = Credentials.from_authorized_user_file(
-                str(TOKEN_FILE), SCOPES
-            )
-        except Exception:
-            creds = None
-    if creds and creds.expired and creds.refresh_token:
-        try:
-            creds.refresh(Request())
-            with open(TOKEN_FILE, "w", encoding="utf-8") as token:
-                token.write(creds.to_json())
-        except Exception:
-            creds = None
-    if not creds or not creds.valid:
-        if not interactive:
-            return None
-        client_config = get_client_config()
-        flow = InstalledAppFlow.from_client_config(
-            client_config,
-            SCOPES,
-            redirect_uri="http://localhost:8080/",
-        )
-        creds = flow.run_local_server(
-            port=8080,
-            prompt="consent",
-            access_type="offline",
-        )
-        with open(TOKEN_FILE, "w", encoding="utf-8") as token:
-            token.write(creds.to_json())
-    return build("youtube", "v3", credentials=creds)
-class MusicPlayerApp(App):
-    CSS = """
-    $youtube-bg: #0f0f0f;
-    $youtube-panel: #212121;
-    $youtube-panel-dark: #181818;
-    $youtube-hover: #3f3f3f;
-    $youtube-border: #303030;
-    $youtube-text: #f1f1f1;
-    $youtube-muted: #aaaaaa;
-    $youtube-red: #ff0000;
-    $youtube-red-dark: #cc0000;
-    Screen {
-        layout: vertical;
-        background: $youtube-bg;
-        color: $youtube-text;
-    }
-    Header {
-        height: 3;
-    }
-    #main {
-        height: 1fr;
-        width: 100%;
-        layout: horizontal;
-    }
-    #sidebar {
-        width: 28;
-        height: 100%;
-        background: $youtube-panel-dark;
-        border-right: solid $youtube-border;
-        padding: 1 1;
-    }
-    #sidebar-title {
-        height: 3;
-        content-align: center middle;
-        text-style: bold;
-        color: $youtube-red;
-        margin-bottom: 1;
-    }
-    .nav-button {
-        width: 100%;
-        margin-bottom: 1;
-        background: $youtube-panel-dark;
-        color: $youtube-text;
-        border: none;
-    }
-    .nav-button:hover {
-        background: $youtube-hover;
-    }
-    .nav-button.-primary {
-        background: $youtube-red;
-        color: #ffffff;
-    }
-    .nav-button.-primary:hover {
-        background: $youtube-red-dark;
-    }
-    #nav-spacer {
-        height: 1fr;
-    }
-    #content {
-        width: 1fr;
-        height: 100%;
-        padding: 2 3;
-    }
-    .page {
-        width: 100%;
-        height: 100%;
-    }
-    .page-title {
-        text-style: bold;
-        color: $youtube-text;
-        margin-bottom: 1;
-    }
-    #search_input {
-        width: 100%;
-        margin-bottom: 1;
-        background: $youtube-panel-dark;
-        color: $youtube-text;
-        border: solid $youtube-border;
-    }
-    #search_input:focus {
-        border: solid $youtube-text;
-    }
-    #search-toolbar {
-        height: auto;
-        margin-bottom: 1;
-    }
-    #filter_select {
-        width: 32;
-    }
-    #results_list {
-        width: 100%;
-        height: 1fr;
-        background: $youtube-bg;
-        border: solid $youtube-border;
-        margin-top: 1;
-    }
-    #liked_results_list {
-        width: 100%;
-        height: 1fr;
-        background: $youtube-bg;
-        border: solid $youtube-border;
-        margin-top: 1;
-    }
-    #btn_load_more, #btn_liked_load_more {
-        width: 100%;
-        margin-top: 1;
-        background: $youtube-panel;
-        color: $youtube-text;
-        border: solid $youtube-border;
-    }
-    #btn_load_more:hover, #btn_liked_load_more:hover {
-        background: $youtube-hover;
-    }
-    #liked_hint, #login_hint, #settings_hint {
-        color: $youtube-muted;
-    }
-    #login-panel {
-        width: 100%;
-        height: auto;
-        border: round $youtube-border;
-        background: $youtube-panel-dark;
-        padding: 2;
-    }
-    #login-user {
-        margin: 1 0;
-        text-style: bold;
-    }
-    #player {
-        height: 11;
-        width: 100%;
-        background: $youtube-panel;
-        border-top: solid $youtube-border;
-        padding: 1 2;
-    }
-    #now-playing {
-        width: 100%;
-        height: 2;
-        text-align: center;
-        text-style: bold;
-    }
-    #visualizer {
-        width: 100%;
-        height: 1;
-        text-align: center;
-        color: $youtube-red;
-    }
-    #progress-container {
-        width: 100%;
-        height: 2;
-        align: center middle;
-    }
-    #progress-container ProgressBar {
-        width: 1fr;
-        margin: 0 1;
-    }
-    #volume-container {
-        width: 100%;
-        height: 3;
-        align: center middle;
-    }
-    #volume-container Button {
-        margin: 0 1;
-    }
-    #controls {
-        width: 100%;
-        height: 3;
-        align: center middle;
-    }
-    #controls Button {
-        margin: 0 1;
-    }
-    #status {
-        width: 100%;
-        height: 1;
-        text-align: center;
-        color: $youtube-muted;
-    }
-    .danger-nav {
-        color: $youtube-red;
-    }
-    #controls Button {
-        background: $youtube-panel-dark;
-        color: $youtube-text;
-        border: solid $youtube-border;
-    }
-    #controls Button:hover {
-        background: $youtube-hover;
-    }
-    #controls #btn_toggle.-primary {
-        background: $youtube-red;
-        color: #ffffff;
-        border: none;
-    }
-    #controls #btn_toggle.-primary:hover {
-        background: $youtube-red-dark;
-    }
-    #controls #btn_stop.-error {
-        background: $youtube-red;
-        color: #ffffff;
-        border: none;
-    }
-    #controls #btn_stop.-error:hover {
-        background: $youtube-red-dark;
-    }
-    """
-    BINDINGS = [
-        ("q", "quit", "Sair"),
-        ("space", "toggle_play", "Play/Pause"),
-        ("up", "volume_up", "Aumentar Vol"),
-        ("down", "volume_down", "Diminuir Vol"),
-    ]
-    def __init__(self):
-        super().__init__()
-        self.stream_thread = None
-        self.stop_event = threading.Event()
-        self.pause_event = threading.Event()
-        self.pause_event.set()
-        self.is_playing = False
-        self.raw_results = []
-        self.filtered_results = []
-        self.youtube_api = None
-        # Paginação e Busca
-        self.next_page_token = None
-        self.last_query = ""
-        self.last_source_type = None  # 'search' ou 'liked'
-        self.is_loading_more = False
-        # Áudio
-        self.volume = 0.8
-        self.duration_seconds = 0
-        self.current_position_seconds = 0
-        self.seek_target_seconds = None
-        self.current_page = "home"
-    def compose(self) -> ComposeResult:
-        yield Header()
-        with Horizontal(id="main"):
-            with Vertical(id="sidebar"):
-                yield Label("🎵 MEU PLAYER", id="sidebar-title")
-                yield Button("🏠  Início", id="btn_home", classes="nav-button", variant="primary")
-                yield Button("❤️  Curtidas", id="btn_liked", classes="nav-button")
-                yield Button("👤  Login", id="btn_login", classes="nav-button")
-                yield Button("⚙️  Configurações", id="btn_settings", classes="nav-button")
-                yield Label("", id="nav-spacer")
-                yield Button("🚪  Sair", id="btn_exit", classes="nav-button danger-nav")
-            with Vertical(id="content"):
-                with Vertical(id="home_page", classes="page"):
-                    yield Label("Início", classes="page-title")
-                    yield Input(
-                        placeholder="Pesquise por música, artista ou álbum...",
-                        id="search_input",
-                    )
-                    with Horizontal(id="search-toolbar"):
-                        yield Select(
-                            [
-                                ("🎵 Apenas Músicas", "music"),
-                                ("🎬 Todos os Vídeos", "all"),
-                            ],
-                            value="music",
-                            id="filter_select",
-                            allow_blank=False,
-                        )
-                    yield ListView(id="results_list")
-                    yield Button("➕ Carregar mais", id="btn_load_more")
-                with Vertical(id="liked_page", classes="page"):
-                    yield Label("Curtidas", classes="page-title")
-                    yield Label(
-                        "Suas músicas curtidas no YouTube.",
-                        id="liked_hint",
-                    )
-                    yield ListView(id="liked_results_list")
-                    yield Button("➕ Carregar mais", id="btn_liked_load_more")
-                with Vertical(id="login_page", classes="page"):
-                    yield Label("Login", classes="page-title")
-                    with Vertical(id="login-panel"):
-                        yield Label("Verificando sessão...", id="login-user")
-                        yield Label(
-                            "Conecte sua conta do YouTube para acessar suas curtidas.",
-                            id="login_hint",
-                        )
-                        yield Button("🔑 Entrar com Google", id="btn_login_action", variant="primary")
-                        yield Button("🔄 Trocar conta", id="btn_logout_account")
-                with Vertical(id="settings_page", classes="page"):
-                    yield Label("Configurações", classes="page-title")
-                    yield Label("🚧 Em construção...", id="settings_hint")
-        with Vertical(id="player"):
-            yield Label("Nenhuma música selecionada", id="now-playing")
-            yield Label("░░░░░░░░░░░░░░░░░░░░", id="visualizer")
-            with Horizontal(id="progress-container"):
-                yield Label("00:00 ", id="time_current")
-                yield ProgressBar(id="song_progress", total=100, show_percentage=False)
-                yield Label(" 00:00", id="time_total")
-            with Horizontal(id="controls"):
-                yield Button("⏪ -10s", id="btn_rewind")
-                yield Button("▶ / ⏸", id="btn_toggle", variant="primary")
-                yield Button("⏩ +10s", id="btn_forward")
-                yield Button("⏹ Parar", id="btn_stop", variant="error")
-                yield Button("🔉 -", id="btn_vol_down")
-                yield Label("Volume: 80%", id="vol_label")
-                yield Button("🔊 +", id="btn_vol_up")
-            yield Label("Status: Pronto.", id="status")
-        yield Footer()
-    def on_mount(self) -> None:
-        self._show_page("home")
-        def auto_auth():
-            self.youtube_api = get_youtube_service(interactive=False)
-            status = self.query_one("#status", Label)
-            if self.youtube_api:
-                self.call_from_thread(
-                    status.update,
-                    "[green]Sessão de usuário carregada com sucesso![/green]",
-                )
-                self.call_from_thread(self._update_login_page)
-            else:
-                self.call_from_thread(self._update_login_page)
-        threading.Thread(target=auto_auth, daemon=True).start()
-    def _show_page(self, page: str) -> None:
-        pages = {
-            "home": "#home_page",
-            "liked": "#liked_page",
-            "login": "#login_page",
-            "settings": "#settings_page",
-        }
-        for name, selector in pages.items():
-            self.query_one(selector).display = name == page
-        self.current_page = page
-        nav_buttons = {
-            "home": "#btn_home",
-            "liked": "#btn_liked",
-            "login": "#btn_login",
-            "settings": "#btn_settings",
-        }
-        for name, selector in nav_buttons.items():
-            button = self.query_one(selector, Button)
-            button.variant = "primary" if name == page else "default"
-        if page == "login":
-            self._update_login_page()
-    def _update_login_page(self) -> None:
-        user_label = self.query_one("#login-user", Label)
-        login_button = self.query_one("#btn_login_action", Button)
-        logout_button = self.query_one("#btn_logout_account", Button)
-        if not self.youtube_api:
-            user_label.update("Nenhuma conta conectada")
-            login_button.display = True
-            logout_button.display = False
-            return
-        user_label.update("Conta conectada. Carregando usuário...")
-        login_button.display = False
-        logout_button.display = True
-        def fetch_user():
-            try:
-                response = self.youtube_api.channels().list(
-                    part="snippet",
-                    mine=True,
-                ).execute()
-                items = response.get("items", [])
-                if items:
-                    name = items[0].get("snippet", {}).get("title", "Conta do YouTube")
-                else:
-                    name = "Conta do YouTube"
-                self.call_from_thread(
-                    user_label.update,
-                    f"👤 {name}",
-                )
-            except Exception:
-                self.call_from_thread(user_label.update, "👤 Conta do YouTube conectada")
-        threading.Thread(target=fetch_user, daemon=True).start()
-    def _logout_youtube(self) -> None:
-        self._stop_audio()
-        try:
-            if TOKEN_FILE.exists():
-                TOKEN_FILE.unlink()
-        except OSError as e:
-            self.query_one("#status", Label).update(
-                f"[red]Erro ao remover sessão: {e}[/red]"
-            )
-            return
-        self.youtube_api = None
-        self.query_one("#status", Label).update("Sessão encerrada.")
-        self._update_login_page()
-    def _handle_navigation(self, button_id: str) -> None:
-        if button_id == "btn_home":
-            self._show_page("home")
-        elif button_id == "btn_liked":
-            self._show_page("liked")
-            self.last_query = ""
-            self.next_page_token = None
-            self._fetch_liked_videos()
-        elif button_id == "btn_login":
-            self._show_page("login")
-        elif button_id == "btn_settings":
-            self._show_page("settings")
-        elif button_id == "btn_exit":
-            self.exit()
-    # --- FILTRAGEM E ATUALIZAÇÃO ---
-    def on_select_changed(self, event: Select.Changed) -> None:
-        if event.select.id == "filter_select":
-            self._apply_filter_and_update_ui()
-    def _apply_filter_and_update_ui(self) -> None:
-        filter_type = self.query_one("#filter_select", Select).value
-        if filter_type == "music":
-            self.filtered_results = [
-                item for item in self.raw_results if item.get("is_music")
-            ]
-        else:
-            self.filtered_results = list(self.raw_results)
-        list_id = "#liked_results_list" if self.current_page == "liked" else "#results_list"
-        list_view = self.query_one(list_id, ListView)
-        list_view.clear()
-        for item in self.filtered_results:
-            tag = "🎵" if item.get("is_music") else "🎬"
-            list_view.append(ListItem(Label(f"{tag} {item['title']}")))
-        status = self.query_one("#status", Label)
-        status.update(
-            f"[green]Exibindo {len(self.filtered_results)} item(ns).[/green]"
-        )
-    # --- AUTENTICAÇÃO E CURTIDAS COM PAGINAÇÃO ---
-    def _authenticate_youtube(self) -> None:
-        status = self.query_one("#status", Label)
-        status.update("[yellow]Abra o navegador para autorizar o acesso...[/yellow]")
-        try:
-            self.youtube_api = get_youtube_service(interactive=True)
-            self.call_from_thread(
-                status.update, "[green]Login realizado com sucesso![/green]"
-            )
-            self.call_from_thread(self._update_login_page)
-        except Exception as e:
-            self.call_from_thread(
-                status.update, f"[red]Erro na autenticação: {e}[/red]"
-            )
-    def _fetch_liked_videos(self, load_more=False) -> None:
-        status = self.query_one("#status", Label)
-        status.update("[yellow]Carregando músicas curtidas...[/yellow]")
-        def fetch_task():
-            try:
-                if not self.youtube_api:
-                    self.youtube_api = get_youtube_service(interactive=True)
-                kwargs = {
-                    "part": "snippet",
-                    "myRating": "like",
-                    "maxResults": 20,
-                }
-                if load_more and self.next_page_token:
-                    kwargs["pageToken"] = self.next_page_token
-                request = self.youtube_api.videos().list(**kwargs)
-                response = request.execute()
-                items = response.get("items", [])
-                self.next_page_token = response.get("nextPageToken")
-                new_items = [
-                    {
-                        "title": item["snippet"]["title"],
-                        "url": f"https://www.youtube.com/watch?v={item['id']}",
-                        "is_music": True,
-                    }
-                    for item in items
-                    if item.get("snippet", {}).get("categoryId") == MUSIC_CATEGORY_ID
-                ]
-                if load_more:
-                    self.raw_results.extend(new_items)
-                else:
-                    self.raw_results = new_items
-                self.last_source_type = "liked"
-                self.is_loading_more = False
-                self.call_from_thread(self._apply_filter_and_update_ui)
-            except Exception as e:
-                self.is_loading_more = False
-                self.call_from_thread(
-                    status.update, f"[red]Erro ao carregar curtidas: {e}[/red]"
-                )
-        if not self.is_loading_more:
-            self.is_loading_more = True
-            threading.Thread(target=fetch_task, daemon=True).start()
-    # --- BUSCA COM YT-DLP E PAGINAÇÃO ---
-    def on_input_submitted(self, event: Input.Submitted) -> None:
-        query = event.value.strip()
-        if not query:
-            return
-        self.last_query = query
-        self.next_page_token = None
-        self.raw_results = []
-        status = self.query_one("#status", Label)
-        status.update("[yellow]Buscando no YouTube...[/yellow]")
-        threading.Thread(
-            target=self._search_youtube, args=(query, False), daemon=True
-        ).start()
-    def _search_youtube(self, query: str, load_more=False) -> None:
-        count = 15
-        search_query = f"ytsearch{count}:{query}"
-        ydl_opts = {
-            "quiet": True,
-            "extract_flat": True,
-            "no_warnings": True,
-            "nocheckcertificate": True,
-            "extractor_args": {
-                "youtube": {"player_client": ["mweb", "web", "android"]}
-            },
-        }
-        try:
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(search_query, download=False)
-                entries = info.get("entries", []) if info else []
-                new_entries = [
-                    {
-                        "title": entry.get("title", "Sem título"),
-                        "url": entry.get("url")
-                        or f"https://www.youtube.com/watch?v={entry.get('id')}",
-                        "duration": entry.get("duration", 0),
-                        "is_music": True,
-                    }
-                    for entry in entries
-                    if entry
-                ]
-            if load_more:
-                self.raw_results.extend(new_entries)
-            else:
-                self.raw_results = new_entries
-            self.last_source_type = "search"
-            self.is_loading_more = False
-            self.call_from_thread(self._apply_filter_and_update_ui)
-        except Exception as e:
-            self.is_loading_more = False
-            self.call_from_thread(
-                self.query_one("#status", Label).update,
-                f"[red]Erro na busca: {e}[/red]",
-            )
-    def _load_more_content(self) -> None:
-        if self.is_loading_more:
-            return
-        if self.last_source_type == "liked":
-            self._fetch_liked_videos(load_more=True)
-        elif self.last_source_type == "search" and self.last_query:
-            self.is_loading_more = True
-            threading.Thread(
-                target=self._search_youtube,
-                args=(self.last_query, True),
-                daemon=True,
-            ).start()
-    # --- REPRODUÇÃO E ÁUDIO ---
-    def on_list_view_selected(self, event: ListView.Selected) -> None:
-        index = event.list_view.index
-        if index is not None and index < len(self.filtered_results):
-            selected_track = self.filtered_results[index]
-            self._play_stream(selected_track)
-            if index >= len(self.filtered_results) - 2:
-                self._load_more_content()
-    def _play_stream(self, track: dict) -> None:
-        now_playing = self.query_one("#now-playing", Label)
-        status = self.query_one("#status", Label)
-        self._stop_audio()
-        self.current_position_seconds = 0
-        self.duration_seconds = 0
-        self.seek_target_seconds = None
-        now_playing.update(f"[bold cyan]Tocando:[/bold cyan] {track['title']}")
-        status.update("[yellow]Obtendo áudio...[/yellow]")
-        def stream_worker():
-            max_retries = 3
-            retry_count = 0
-            self.stop_event.clear()
-            self.pause_event.set()
-            pcm_buffer = bytearray()
-            pcm_lock = threading.Lock()
-            played_samples = 0
-            def audio_callback(outdata, frames, time_info, status_flags):
-                nonlocal pcm_buffer, played_samples
-                bytes_needed = frames * 2 * 4  # frames * 2 canais * 4 bytes (float32)
-                with pcm_lock:
-                    if len(pcm_buffer) >= bytes_needed:
-                        chunk = pcm_buffer[:bytes_needed]
-                        pcm_buffer = pcm_buffer[bytes_needed:]
-                        outdata[:] = np.frombuffer(chunk, dtype=np.float32).reshape(
-                            frames, 2
-                        )
-                        if self.pause_event.is_set():
-                            played_samples += frames
-                    else:
-                        outdata.fill(0)
-            while retry_count <= max_retries and not self.stop_event.is_set():
-                try:
-                    ydl_opts = {
-                        "format": "bestaudio/best/b",
-                        "quiet": True,
-                        "no_warnings": True,
-                        "nocheckcertificate": True,
-                        "extractor_args": {
-                            "youtube": {"player_client": ["mweb", "web", "android"]}
-                        },
-                    }
-                    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                        info = ydl.extract_info(track["url"], download=False)
-                        direct_url = info["url"]
-                        self.duration_seconds = info.get("duration", 0)
-                        headers = info.get("http_headers", {})
-                    headers_str = "".join([f"{k}: {v}\r\n" for k, v in headers.items()])
-                    container_options = {
-                        "user_agent": headers.get(
-                            "User-Agent",
-                            "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
-                        ),
-                        "headers": headers_str,
-                        "reconnect": "1",
-                        "reconnect_streamed": "1",
-                        "reconnect_delay_max": "5",
-                    }
-                    container = av.open(direct_url, options=container_options)
-                    audio_stream = next(
-                        (s for s in container.streams if s.type == "audio"), None
-                    )
-                    if audio_stream is None:
-                        raise ValueError("Nenhuma faixa de áudio encontrada no fluxo do vídeo.")
-                    sample_rate = (
-                        audio_stream.codec_context.sample_rate or 48000
-                    )
-                    time_base = float(audio_stream.time_base)
-                    resampler = av.AudioResampler(
-                        format="fltp", layout="stereo", rate=sample_rate
-                    )
-                    with sd.OutputStream(
-                        samplerate=sample_rate,
-                        channels=2,
-                        dtype="float32",
-                        callback=audio_callback,
-                        blocksize=1024,
-                    ):
-                        self.is_playing = True
-                        self.call_from_thread(
-                            status.update, "[green]Reproduzindo ♪[/green]"
-                        )
-                        last_ui_update = 0
-                        for frame in container.decode(audio_stream):
-                            if self.stop_event.is_set():
-                                break
-                            # Controla a velocidade de decodificação para não sobrecarregar o buffer
-                            max_buffer_bytes = sample_rate * 2 * 4 * 3  # ~3 segundos de áudio
-                            while len(pcm_buffer) > max_buffer_bytes and not self.stop_event.is_set():
-                                time.sleep(0.05)
-                            if self.seek_target_seconds is not None:
-                                target_pts = int(
-                                    self.seek_target_seconds / time_base
-                                )
-                                container.seek(target_pts, stream=audio_stream)
-                                played_samples = int(self.seek_target_seconds * sample_rate)
-                                with pcm_lock:
-                                    pcm_buffer.clear()
-                                self.seek_target_seconds = None
-                                resampler = av.AudioResampler(
-                                    format="fltp",
-                                    layout="stereo",
-                                    rate=sample_rate,
-                                )
-                                continue
-                            self.pause_event.wait()
-                            resampled_frames = resampler.resample(frame)
-                            if not resampled_frames:
-                                continue
-                            for r_frame in resampled_frames:
-                                if self.stop_event.is_set():
-                                    break
-                                audio_array = r_frame.to_ndarray()
-                                if audio_array.ndim == 1:
-                                    audio_array = np.vstack((audio_array, audio_array))
-                                audio_array = audio_array * self.volume
-                                audio_data = np.ascontiguousarray(audio_array.T, dtype=np.float32)
-                                with pcm_lock:
-                                    pcm_buffer.extend(audio_data.tobytes())
-                                # Atualização da interface sincronizada por tempo real de reprodução
-                                current_time = time.time()
-                                if current_time - last_ui_update >= 0.2:
-                                    self.current_position_seconds = played_samples / sample_rate
-                                    rms = np.sqrt(np.mean(audio_data**2)) if len(audio_data) > 0 else 0
-                                    self.call_from_thread(self._update_playback_ui, rms)
-                                    last_ui_update = current_time
-                        # Aguarda consumir os últimos bytes de áudio no buffer antes de finalizar
-                        while len(pcm_buffer) > 0 and not self.stop_event.is_set():
-                            self.current_position_seconds = played_samples / sample_rate
-                            self.call_from_thread(self._update_playback_ui, 0)
-                            time.sleep(0.1)
-                    container.close()
-                    break
-                except (av.FFmpegError, OSError, Exception) as e:
-                    if self.stop_event.is_set():
-                        break
-                    retry_count += 1
-                    if retry_count <= max_retries:
-                        self.call_from_thread(
-                            status.update,
-                            f"[yellow]Reconectando ({retry_count}/{max_retries})...[/yellow]",
-                        )
-                        time.sleep(1)
-                    else:
-                        self.is_playing = False
-                        self.call_from_thread(
-                            status.update, f"[red]Erro ao tocar: {e}[/red]"
-                        )
-            self.is_playing = False
-            self.call_from_thread(self._reset_playback_ui)
-        self.stream_thread = threading.Thread(
-            target=stream_worker, daemon=True
-        )
-        self.stream_thread.start()
-    def _update_playback_ui(self, rms_volume: float) -> None:
-        curr_str = time.strftime(
-            "%M:%S", time.gmtime(self.current_position_seconds)
-        )
-        tot_str = time.strftime("%M:%S", time.gmtime(self.duration_seconds))
-        self.query_one("#time_current", Label).update(f"{curr_str} ")
-        self.query_one("#time_total", Label).update(f" {tot_str}")
-        progress_bar = self.query_one("#song_progress", ProgressBar)
-        if self.duration_seconds > 0:
-            progress_bar.progress = min(
-                100.0,
-                (self.current_position_seconds / self.duration_seconds) * 100,
-            )
-        bars = [" ", " ", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
-        level = min(int(rms_volume * 35), len(bars) - 1)
-        char = bars[level]
-        meter_str = f"░▒▓█ {char * 12} █▓▒░"
-        self.query_one("#visualizer", Label).update(meter_str)
-    def _reset_playback_ui(self) -> None:
-        self.query_one("#visualizer", Label).update("░░░░░░░░░░░░░░░░░░░░")
-        self.query_one("#song_progress", ProgressBar).progress = 0
-        self.query_one("#time_current", Label).update("00:00 ")
-        self.query_one("#time_total", Label).update(" 00:00")
-    # --- CONTROLES E ATALHOS ---
-    def _stop_audio(self) -> None:
-        """Interrompe e encerra síncronamente qualquer thread de reprodução em execução."""
-        self.stop_event.set()
-        self.pause_event.set()
-        if self.stream_thread and self.stream_thread.is_alive():
-            if threading.current_thread() != self.stream_thread:
-                self.stream_thread.join(timeout=2.0)
-        self.is_playing = False
-    def action_toggle_play(self) -> None:
-        self.toggle_audio()
-    def action_volume_up(self) -> None:
-        self._adjust_volume(0.05)
-    def action_volume_down(self) -> None:
-        self._adjust_volume(-0.05)
-    def _adjust_volume(self, delta: float) -> None:
-        self.volume = max(0.0, min(1.0, self.volume + delta))
-        vol_pct = int(self.volume * 100)
-        self.query_one("#vol_label", Label).update(f" Volume: {vol_pct}% ")
-    def _seek(self, seconds_delta: float) -> None:
-        new_pos = max(0, self.current_position_seconds + seconds_delta)
-        if self.duration_seconds > 0:
-            new_pos = min(self.duration_seconds - 1, new_pos)
-        self.seek_target_seconds = new_pos
-    def on_button_pressed(self, event: Button.Pressed) -> None:
-        b_id = event.button.id
-        if b_id in {"btn_home", "btn_liked", "btn_login", "btn_settings", "btn_exit"}:
-            self._handle_navigation(b_id)
-        elif b_id == "btn_login_action":
-            self._show_page("login")
-            threading.Thread(
-                target=self._authenticate_youtube, daemon=True
-            ).start()
-        elif b_id == "btn_logout_account":
-            self._logout_youtube()
-        elif b_id == "btn_toggle":
-            self.toggle_audio()
-        elif b_id == "btn_stop":
-            self._stop_audio()
-            self._reset_playback_ui()
-            self.query_one("#status", Label).update("Reprodução parada.")
-            self.query_one("#now-playing", Label).update(
-                "Nenhuma música selecionada"
-            )
-        elif b_id == "btn_vol_up":
-            self._adjust_volume(0.1)
-        elif b_id == "btn_vol_down":
-            self._adjust_volume(-0.1)
-        elif b_id == "btn_rewind":
-            self._seek(-10)
-        elif b_id == "btn_forward":
-            self._seek(10)
-        elif b_id in {"btn_load_more", "btn_liked_load_more"}:
-            self._load_more_content()
-    def toggle_audio(self) -> None:
-        if not self.stream_thread or not self.stream_thread.is_alive():
-            return
-        if self.is_playing:
-            self.pause_event.clear()
-            self.is_playing = False
-            self.query_one("#status", Label).update("Pausado ⏸")
-        else:
-            self.pause_event.set()
-            self.is_playing = True
-            self.query_one("#status", Label).update("Reproduzindo ♪")
-if __name__ == "__main__":
-    app = MusicPlayerApp()
-    app.run()
+"""Launcher da V2 - abre a interface Textual."""
+from app import YouTubePlayer
+if __name__ == "__main__":
+    app = YouTubePlayer()
+    app.run()