git-cli-yt 1.2.0 → 2.0.1

package/mix/mix_service.py

@@ -0,0 +1,227 @@
+"""Geração de playlist relacionada à faixa âncora."""
+
+from __future__ import annotations
+
+import html
+import re
+import unicodedata
+from difflib import SequenceMatcher
+from collections.abc import Callable
+from typing import Any, Optional
+
+from utils.helpers import extract_video_id
+
+MIX_INITIAL_COUNT = 30
+MIX_REFILL_COUNT = 10
+_GENERIC_TITLE_TOKENS = frozenset(
+    {"song", "music", "video", "audio", "live", "radio", "mix", "hit", "hits"}
+)
+MIX_REFILL_THRESHOLD = 3
+
+FetchResult = tuple[list[dict[str, Any]], Optional[str]]
+
+
+class MixService:
+    def __init__(
+        self,
+        fetch_fn: Callable[[str, int, Optional[str]], FetchResult],
+    ) -> None:
+        self.fetch_fn = fetch_fn
+        self.tracks: list[dict[str, Any]] = []
+        self.anchor: Optional[dict[str, Any]] = None
+        self.artist: Optional[str] = None
+        self.seen_ids: set[str] = set()
+        self.seen_sigs: set[tuple[str, str]] = set()
+        self.seen_titles: set[str] = set()
+        self._page_tokens: dict[str, str] = {}
+        self._exhausted_queries: set[str] = set()
+
+    def reset(self) -> None:
+        self.tracks.clear()
+        self.anchor = None
+        self.artist = None
+        self.seen_ids.clear()
+        self.seen_sigs.clear()
+        self._page_tokens.clear()
+        self.seen_titles.clear()
+        self._exhausted_queries.clear()
+
+    def start(
+        self,
+        track: dict[str, Any],
+        seed_tracks: Optional[list[dict[str, Any]]] = None,
+    ) -> list[dict[str, Any]]:
+        """Cria a Mix usando resultados já carregados antes da API."""
+        self.reset()
+        self.anchor = track
+        self.artist = str(
+            track.get("artist") or self._extract_artist(str(track.get("title", "")))
+        ).strip() or None
+        self._add(track)
+        for candidate in seed_tracks or []:
+            if len(self.tracks) >= MIX_INITIAL_COUNT:
+                break
+            self._add(candidate)
+        self._generate_batch(MIX_INITIAL_COUNT - len(self.tracks))
+        return list(self.tracks)
+
+    def refill(self) -> list[dict[str, Any]]:
+        """Adiciona até dez faixas relacionadas à Mix atual."""
+        if not self.anchor:
+            return []
+        previous_count = len(self.tracks)
+        self._generate_batch(MIX_REFILL_COUNT)
+        return self.tracks[previous_count:]
+
+    def next(self, current_track: Optional[dict[str, Any]] = None) -> Optional[dict[str, Any]]:
+        if not self.tracks:
+            return None
+        if current_track is None:
+            return self.tracks[0]
+
+        current_id = self._id_of(current_track)
+        for index, track in enumerate(self.tracks):
+            matches = (
+                self._id_of(track) == current_id
+                if current_id
+                else track is current_track
+            )
+            if matches:
+                return self.tracks[index + 1] if index + 1 < len(self.tracks) else None
+        return None
+
+    def needs_refill(self, remaining: int) -> bool:
+        return bool(self.anchor) and remaining <= MIX_REFILL_THRESHOLD
+
+    def clear(self) -> None:
+        self.reset()
+
+    @property
+    def total_tracks(self) -> int:
+        return len(self.tracks)
+
+    @property
+    def anchor_track(self) -> Optional[dict[str, Any]]:
+        return self.anchor
+
+    def _generate_batch(self, count_to_add: int) -> None:
+        if count_to_add <= 0:
+            return
+
+        generated = 0
+        for query in self._build_queries():
+            if generated >= count_to_add or query in self._exhausted_queries:
+                continue
+            while generated < count_to_add:
+                batch_size = min(15, max(1, (count_to_add - generated) * 2))
+                page_token = self._page_tokens.get(query)
+                tracks, next_page = self.fetch_fn(query, batch_size, page_token)
+                if next_page == page_token:
+                    next_page = None
+                if next_page:
+                    self._page_tokens[query] = next_page
+                else:
+                    self._exhausted_queries.add(query)
+                for track in tracks:
+                    if generated >= count_to_add:
+                        break
+                    if self._add(track):
+                        generated += 1
+                if not next_page:
+                    break
+
+    def _add(self, track: dict[str, Any]) -> bool:
+        video_id = self._id_of(track)
+        if not video_id or video_id in self.seen_ids:
+            return False
+        signature = (
+            str(track.get("title", "")).strip().casefold(),
+            str(track.get("artist", "")).strip().casefold(),
+        )
+        normalized_title = self._content_title(track)
+        if signature in self.seen_sigs or self._is_duplicate_title(normalized_title):
+            return False
+        self.tracks.append(track)
+        self.seen_ids.add(video_id)
+        self.seen_sigs.add(signature)
+        if normalized_title:
+            self.seen_titles.add(normalized_title)
+        return True
+
+    def _content_title(self, track: dict[str, Any]) -> str:
+        normalized = _normalize_title(track.get("title", ""))
+        artist = _normalize_title(track.get("artist", "") or self.artist or "")
+        artist_tokens = set(artist.split())
+        if artist_tokens:
+            normalized = " ".join(
+                token for token in normalized.split() if token not in artist_tokens
+            )
+        return normalized or _normalize_title(track.get("title", ""))
+
+    def _is_duplicate_title(self, normalized_title: str) -> bool:
+        if not normalized_title:
+            return False
+        current_tokens = set(normalized_title.split())
+        for existing in self.seen_titles:
+            if normalized_title == existing:
+                return True
+            existing_tokens = set(existing.split())
+            if (
+                current_tokens.issubset(existing_tokens)
+                or existing_tokens.issubset(current_tokens)
+            ) and any(
+                len(token) >= 5 and token not in _GENERIC_TITLE_TOKENS
+                for token in current_tokens & existing_tokens
+            ):
+                return True
+            if SequenceMatcher(None, normalized_title, existing).ratio() >= 0.84:
+                return True
+        return False
+
+    def _id_of(self, track: dict[str, Any]) -> Optional[str]:
+        return str(track.get("id") or extract_video_id(str(track.get("url", "")))) or None
+
+    def _build_queries(self) -> list[str]:
+        if not self.anchor:
+            return []
+        title = str(self.anchor.get("title", "")).strip()
+        artist = self.artist
+        if artist:
+            return [
+                f"{artist} {title}",
+                f"{artist} música",
+                f"{artist} hits",
+                f"{artist} melhores",
+            ]
+        return [title, f"música {title}", f"hit {title}"]
+
+    def _extract_artist(self, title: str) -> str:
+        cleaned = re.sub(
+            r"\s*[\(\[](?:official|video|lyrics?|audio|hd|4k|remaster.*?)[\)\]]",
+            "",
+            title,
+            flags=re.IGNORECASE,
+        )
+        for separator in (" - ", " – ", " — "):
+            if separator in cleaned:
+                return cleaned.split(separator, 1)[0].strip()
+        return ""
+
+
+def _normalize_title(value: Any) -> str:
+    text = html.unescape(str(value or ""))
+    text = unicodedata.normalize("NFKD", text)
+    text = "".join(char for char in text if not unicodedata.combining(char))
+    text = re.sub(r"[\(\[\{].*?[\)\]\}]", " ", text)
+    text = re.sub(
+        r"\b(?:official(?: music)?(?: video)?|music video|lyrics?|audio|"
+        r"visualizer|hd|4k|remaster(?:ed)?|full album|with lyrics|live|"
+        r"cover|remix|acoustic|instrumental|karaoke|sped up|slowed|"
+        r"part\s*\d+|volume\s*\d+)\b",
+        " ",
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = re.sub(r"\b(?:feat|ft|featuring)\.?\s+.*$", " ", text, flags=re.IGNORECASE)
+    text = re.sub(r"[^\w\s]", " ", text, flags=re.UNICODE)
+    return " ".join(text.casefold().split())

package/package.json

@@ -1,29 +1,32 @@
-{
-  "name": "git-cli-yt",
-  "version": "1.2.0",
-  "description": "YouTube TUI Player executável via NPX",
-  "main": "bin/cli.js",
-  "bin": {
-    "git-cli-yt": "bin/cli.js",
-    "meu-player-tui": "bin/cli.js"
-  },
-  "files": [
-    "bin/cli.js",
-    "main.py",
-    "requirements.txt"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "tui",
-    "youtube",
-    "music",
-    "cli"
-  ],
-  "author": "Bruno Soares",
-  "license": "MIT",
-  "dependencies": {
-    "dotenv": "^17.4.2"
-  }
-}
+{
+  "name": "git-cli-yt",
+  "version": "2.0.1",
+  "description": "YouTube TUI Player V2 executável via Python ou NPX",
+  "main": "bin/cli.js",
+  "bin": {
+    "git-cli-yt": "bin/cli.js",
+    "meu-player-tui": "bin/cli.js"
+  },
+  "files": [
+    "bin/cli.js",
+    "main.py",
+    "app.py",
+    "audio/*.py",
+    "youtube/*.py",
+    "mix/*.py",
+    "utils/*.py",
+    "requirements.txt",
+    "PRIVACY_POLICY.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "tui",
+    "youtube",
+    "music",
+    "cli"
+  ],
+  "author": "Bruno Soares",
+  "license": "MIT"
+}

package/requirements.txt

@@ -1,8 +1,10 @@
-textual>=0.50.0
-yt-dlp>=2024.3.10
-google-api-python-client>=2.100.0
-google-auth-oauthlib>=1.2.0
-av>=11.0.0
-sounddevice>=0.4.6
-numpy>=1.26.0
-python-dotenv>=1.0.0
+textual>=4.0.0
+rich>=14.0.0
+google-api-python-client>=2.100.0
+requests>=2.31.0
+google-auth-oauthlib>=1.2.0
+av>=11.0.0
+sounddevice>=0.4.6
+numpy>=1.26.0
+python-dotenv>=1.0.0
+yt-dlp>=2024.6.11

package/utils/helpers.py

@@ -0,0 +1,37 @@
+"""Utilitários compartilhados entre módulos."""
+
+import re
+from typing import Optional
+
+
+def format_time(seconds: Optional[float]) -> str:
+    """Converte segundos em MM:SS (ou HH:MM:SS se > 1h)."""
+    if seconds is None:
+        return "00:00"
+    s = max(0, int(seconds))
+    h, s = divmod(s, 3600)
+    m, s = divmod(s, 60)
+    if h > 0:
+        return f"{h}:{m:02d}:{s:02d}"
+    return f"{m:02d}:{s:02d}"
+
+
+def extract_video_id(url: str) -> Optional[str]:
+    """Extrai o ID de vídeo de uma URL do YouTube."""
+    patterns = [
+        r"youtube\.com/watch\?v=([a-zA-Z0-9_-]{11})",
+        r"youtube\.com/embed/([a-zA-Z0-9_-]{11})",
+        r"youtube\.com/shorts/([a-zA-Z0-9_-]{11})",
+        r"youtu\.be/([a-zA-Z0-9_-]{11})",
+        r"^([a-zA-Z0-9_-]{11})$",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, url)
+        if match:
+            return match.group(1)
+    return None
+
+
+def build_related_url(video_id: str) -> str:
+    """URL de busca relacionada usada pela Mix."""
+    return f"https://www.youtube.com/watch?v={video_id}&list=related"

package/youtube/auth.py

@@ -0,0 +1,196 @@
+"""Autenticação OAuth 2.0 e acesso à YouTube Data API v3."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional, cast
+
+from dotenv import load_dotenv
+from google.auth.exceptions import GoogleAuthError
+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
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+CONFIG_DIR = Path.home() / ".config" / "meu-player-tui"
+TOKEN_FILE = CONFIG_DIR / "token.json"
+CLIENT_SECRET_FILE = PROJECT_ROOT / "client_secret.json"
+SCOPES = ["https://www.googleapis.com/auth/youtube.readonly"]
+_CHANNEL_INFO: Optional[dict[str, str]] = None
+
+CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+load_dotenv(PROJECT_ROOT / ".env")
+load_dotenv(Path.cwd() / ".env")
+
+
+class OAuthConfigurationError(RuntimeError):
+    """As credenciais do aplicativo OAuth não estão configuradas."""
+
+
+def get_api_key() -> str:
+    """Retorna a chave opcional para busca pública."""
+    return (
+        os.environ.get("YOUTUBE_API_KEY", "")
+        or os.environ.get("GOOGLE_API_KEY", "")
+    ).strip()
+
+
+def get_client_config() -> dict[str, dict[str, Any]]:
+    """Carrega o OAuth client do ambiente ou de ``client_secret.json``."""
+    client_id = (
+        os.environ.get("YOUTUBE_CLIENT_ID", "")
+        or os.environ.get("GOOGLE_CLIENT_ID", "")
+    ).strip()
+    client_secret = (
+        os.environ.get("YOUTUBE_CLIENT_SECRET", "")
+        or os.environ.get("GOOGLE_CLIENT_SECRET", "")
+    ).strip()
+
+    if not client_id or not client_secret:
+        file_config = _read_client_secret_file()
+        client_id = client_id or file_config.get("client_id", "")
+        client_secret = client_secret or file_config.get("client_secret", "")
+
+    if not client_id or not client_secret:
+        raise OAuthConfigurationError(
+            "Configure YOUTUBE_CLIENT_ID e YOUTUBE_CLIENT_SECRET no arquivo .env."
+        )
+
+    return {
+        "installed": {
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+            "redirect_uris": ["http://localhost"],
+        }
+    }
+
+
+def get_credentials(interactive: bool = False) -> Optional[Credentials]:
+    """Carrega, renova ou cria credenciais OAuth."""
+    credentials = _load_saved_credentials()
+
+    if credentials and credentials.expired and credentials.refresh_token:
+        try:
+            credentials.refresh(Request())
+            _save_token(credentials)
+        except (GoogleAuthError, OSError):
+            credentials = None
+
+    if credentials and credentials.valid:
+        return credentials
+    if not interactive:
+        return None
+
+    flow = InstalledAppFlow.from_client_config(get_client_config(), SCOPES)
+    credentials = cast(
+        Credentials,
+        flow.run_local_server(
+            host="localhost",
+            port=8080,
+            authorization_prompt_message="Abra o navegador para autorizar o acesso.",
+            success_message="Login concluído. Você já pode fechar esta janela.",
+            open_browser=True,
+            access_type="offline",
+            prompt="consent",
+        ),
+    )
+    _save_token(credentials)
+    return credentials
+
+
+def get_youtube_service(interactive: bool = False) -> Any:
+    """Obtém o cliente da YouTube Data API."""
+    credentials = get_credentials(interactive=interactive)
+    if not credentials or not credentials.valid:
+        return None
+    try:
+        return build("youtube", "v3", credentials=credentials)
+    except HttpError:
+        return None
+
+
+def is_logged_in() -> bool:
+    """Verifica se há credenciais válidas sem abrir o navegador."""
+    return get_credentials(interactive=False) is not None
+
+
+def get_channel_info(refresh: bool = False) -> Optional[dict[str, str]]:
+    """Retorna ID e título do canal autenticado, com cache local."""
+    global _CHANNEL_INFO
+    if _CHANNEL_INFO is not None and not refresh:
+        return dict(_CHANNEL_INFO)
+
+    service = get_youtube_service(interactive=False)
+    if service is None:
+        return None
+    try:
+        response = service.channels().list(part="snippet", mine=True).execute()
+        items = response.get("items", [])
+        if not items:
+            return None
+        item = items[0]
+        channel_id = str(item.get("id", "")).strip()
+        title = str(item.get("snippet", {}).get("title", "")).strip()
+        if not channel_id:
+            return None
+        _CHANNEL_INFO = {"id": channel_id, "title": title}
+        return dict(_CHANNEL_INFO)
+    except HttpError:
+        return None
+
+
+def get_account_name() -> Optional[str]:
+    """Obtém o nome do canal autenticado."""
+    channel = get_channel_info()
+    return channel.get("title") if channel else None
+
+
+def clear_session() -> None:
+    """Remove somente o token OAuth local."""
+    global _CHANNEL_INFO
+    TOKEN_FILE.unlink(missing_ok=True)
+    _CHANNEL_INFO = None
+
+
+def switch_account() -> Any:
+    """Limpa a sessão local e inicia outro login."""
+    clear_session()
+    return get_youtube_service(interactive=True)
+
+
+def _load_saved_credentials() -> Optional[Credentials]:
+    if not TOKEN_FILE.exists():
+        return None
+    try:
+        return Credentials.from_authorized_user_file(str(TOKEN_FILE), SCOPES)
+    except (OSError, ValueError, KeyError, json.JSONDecodeError):
+        return None
+
+
+def _save_token(credentials: Credentials) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    TOKEN_FILE.write_text(credentials.to_json(), encoding="utf-8")
+    try:
+        TOKEN_FILE.chmod(0o600)
+    except OSError:
+        pass
+
+
+def _read_client_secret_file() -> dict[str, str]:
+    if not CLIENT_SECRET_FILE.exists():
+        return {}
+    try:
+        data = json.loads(CLIENT_SECRET_FILE.read_text(encoding="utf-8"))
+        installed = data.get("installed") or data.get("web") or {}
+        return {
+            "client_id": str(installed.get("client_id", "")),
+            "client_secret": str(installed.get("client_secret", "")),
+        }
+    except (OSError, ValueError, TypeError):
+        return {}

package/youtube/liked.py

@@ -0,0 +1,121 @@
+"""Lista paginada de vídeos curtidos na categoria Música do YouTube."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from googleapiclient.errors import HttpError
+
+MUSIC_CATEGORY_ID = "10"
+_LIKED_PAGE_SIZE = 50
+
+
+class LikedError(RuntimeError):
+    """Erro seguro e legível ao consultar os vídeos curtidos."""
+
+
+def fetch_liked(
+    youtube_service: Any,
+    page_token: Optional[str] = None,
+    max_results: int = 20,
+) -> tuple[list[dict[str, Any]], Optional[str]]:
+    """Retorna apenas curtidas da categoria Música e o próximo token."""
+    if youtube_service is None:
+        return [], None
+
+    target = max(1, min(int(max_results), 50))
+    results: list[dict[str, Any]] = []
+    next_token = page_token
+
+    while len(results) < target:
+        requested_token = next_token
+        kwargs: dict[str, Any] = {
+            "part": "snippet,contentDetails",
+            "myRating": "like",
+            "maxResults": _LIKED_PAGE_SIZE,
+        }
+        if next_token:
+            kwargs["pageToken"] = next_token
+
+        try:
+            response = youtube_service.videos().list(**kwargs).execute()
+        except HttpError as exc:
+            raise _liked_error(exc) from exc
+
+        for item in response.get("items", []):
+            snippet = item.get("snippet", {})
+            if str(snippet.get("categoryId", "")) != MUSIC_CATEGORY_ID:
+                continue
+            video_id = str(item.get("id", ""))
+            if not video_id:
+                continue
+            raw_artist = str(
+                snippet.get("videoOwnerChannelTitle")
+                or snippet.get("channelTitle")
+                or ""
+            )
+            results.append(
+                {
+                    "id": video_id,
+                    "title": snippet.get("title", "Sem título"),
+                    "url": f"https://www.youtube.com/watch?v={video_id}",
+                    "duration": _duration_seconds(
+                        item.get("contentDetails", {}).get("duration", "")
+                    ),
+                    "is_music": True,
+                    "artist": _clean_artist(raw_artist),
+                    "channelTitle": raw_artist,
+                }
+            )
+            if len(results) >= target:
+                break
+
+        response_token = response.get("nextPageToken")
+        if response_token and str(response_token) == requested_token:
+            next_token = None
+            break
+        next_token = str(response_token) if response_token else None
+        if next_token is None:
+            break
+
+    return results, next_token
+
+
+def _liked_error(error: HttpError) -> LikedError:
+    status = getattr(getattr(error, "resp", None), "status", None)
+    if status == 401:
+        return LikedError("A sessão expirou. Entre na conta novamente.")
+    if status == 403:
+        return LikedError("A API não retornou as curtidas para esta conta ou projeto.")
+    if status:
+        return LikedError(f"A API do YouTube respondeu com HTTP {status}.")
+    return LikedError("Não foi possível consultar as curtidas.")
+
+
+def _clean_artist(name: str) -> Optional[str]:
+    """Remove marcadores comuns de canais musicais."""
+    cleaned = name.strip()
+    for suffix in (" - Topic", "VEVO", " Official", " Canal Oficial"):
+        if cleaned.endswith(suffix):
+            cleaned = cleaned[: -len(suffix)].strip()
+    return cleaned or None
+
+
+def _duration_seconds(value: Any) -> float:
+    if not isinstance(value, str) or not value.startswith("P"):
+        return 0.0
+    try:
+        time_part = value[1:].split("T", 1)[1]
+        days = int(time_part.split("D", 1)[0]) if "D" in time_part else 0
+        if "D" in time_part:
+            time_part = time_part.split("D", 1)[1]
+        hours = int(time_part.split("H", 1)[0]) if "H" in time_part else 0
+        if "H" in time_part:
+            time_part = time_part.split("H", 1)[1]
+        minutes = int(time_part.split("M", 1)[0]) if "M" in time_part else 0
+        time_part = time_part.split("M", 1)[1] if "M" in time_part else time_part
+        return days * 86400 + hours * 3600 + minutes * 60 + float(
+            time_part.rstrip("S")
+        )
+    except (IndexError, TypeError, ValueError):
+        return 0.0