git-cli-yt 1.1.9 → 2.0.0

package/youtube/playlist.py

@@ -0,0 +1,139 @@
+"""Listagem de playlists do YouTube via yt-dlp."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+import yt_dlp
+
+from youtube.search import normalize_ytdlp_entry
+
+
+class PlaylistError(RuntimeError):
+    """Erro ao enumerar uma playlist."""
+
+
+
+def fetch_user_playlists(
+    channel_id: str,
+    cookies_file: Optional[str] = None,
+) -> list[dict[str, Any]]:
+    """Retorna Curtidas primeiro e depois as playlists do canal."""
+    channel_id = channel_id.strip()
+    if not channel_id:
+        raise PlaylistError("Não foi possível identificar o canal do usuário.")
+
+    options: Any = {
+        "quiet": True,
+        "no_warnings": True,
+        "skip_download": True,
+        "extract_flat": True,
+    }
+    cookie_path = Path(cookies_file) if cookies_file else None
+    if cookie_path and cookie_path.exists():
+        options["cookiefile"] = str(cookie_path)
+
+    url = f"https://www.youtube.com/channel/{channel_id}/playlists"
+    try:
+        with yt_dlp.YoutubeDL(options) as downloader:
+            info = downloader.extract_info(url, download=False)
+    except Exception as exc:
+        raise PlaylistError("Não foi possível listar as playlists do usuário.") from exc
+
+    results: list[dict[str, Any]] = [
+        {
+            "id": "liked",
+            "kind": "liked",
+            "title": "Curtidas",
+            "url": "",
+            "count": None,
+            "thumbnail": "",
+        }
+    ]
+    for entry in (info.get("entries") if isinstance(info, dict) else None) or []:
+        if not isinstance(entry, dict):
+            continue
+        playlist_id = str(entry.get("id", "")).strip()
+        playlist_url = str(
+            entry.get("webpage_url")
+            or entry.get("url")
+            or (f"https://www.youtube.com/playlist?list={playlist_id}" if playlist_id else "")
+        )
+        title = str(entry.get("title") or "Playlist sem título").strip()
+        if not playlist_id and not playlist_url:
+            continue
+        thumbnails = entry.get("thumbnails") or []
+        thumbnail = max(
+            thumbnails,
+            key=lambda item: item.get("width", 0) if isinstance(item, dict) else 0,
+            default={},
+        )
+        results.append(
+            {
+                "id": playlist_id or playlist_url,
+                "kind": "playlist",
+                "title": title,
+                "url": playlist_url,
+                "count": entry.get("playlist_count"),
+                "thumbnail": thumbnail.get("url", "")
+                if isinstance(thumbnail, dict)
+                else "",
+            }
+        )
+    return results
+
+def fetch_playlist(
+    url: str,
+    count: int = 50,
+    page_token: Optional[str] = None,
+    cookies_file: Optional[str] = None,
+) -> tuple[list[dict[str, Any]], Optional[str]]:
+    """Retorna uma página de uma playlist, usando ``extract_flat``.
+
+    ``cookies_file`` é opcional e só é necessário para playlists privadas ou
+    playlists pessoais, como a lista de vídeos curtidos.
+    """
+    if not url.strip():
+        raise PlaylistError("Informe a URL da playlist.")
+    limit = max(1, min(int(count), 50))
+    offset = _offset(page_token)
+    options: Any = {
+        "quiet": True,
+        "no_warnings": True,
+        "skip_download": True,
+        "extract_flat": True,
+        "playliststart": offset,
+        "playlistend": offset + limit,
+    }
+    cookie_path = Path(cookies_file) if cookies_file else None
+    if cookie_path and cookie_path.exists():
+        options["cookiefile"] = str(cookie_path)
+
+    try:
+        with yt_dlp.YoutubeDL(options) as downloader:
+            info = downloader.extract_info(url, download=False)
+    except Exception as exc:
+        raise PlaylistError("Não foi possível ler a playlist com yt-dlp.") from exc
+
+    entries = info.get("entries") if isinstance(info, dict) else None
+    results = [
+        normalized
+        for entry in (entries or [])
+        if (normalized := normalize_ytdlp_entry(entry)) is not None
+    ]
+    total = info.get("playlist_count") if isinstance(info, dict) else None
+    has_next = isinstance(total, int) and offset + limit < total
+    if total is None:
+        has_next = len(results) >= limit
+    next_token = str(offset + limit) if has_next else None
+    return results, next_token
+
+
+def _offset(page_token: Optional[str]) -> int:
+    if not page_token:
+        return 0
+    try:
+        return max(0, int(page_token))
+    except ValueError:
+        return 0

package/youtube/search.py

@@ -0,0 +1,362 @@
+"""Busca paginada de vídeos usando a YouTube Data API v3."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any, Optional
+
+import requests
+import yt_dlp
+from googleapiclient.errors import HttpError
+
+from youtube import auth
+
+_SEARCH_URL = "https://www.googleapis.com/youtube/v3/search"
+_VIDEOS_URL = "https://www.googleapis.com/youtube/v3/videos"
+_MUSIC_CATEGORY_ID = "10"
+_YTDLP_CACHE: dict[str, list[dict[str, Any]]] = {}
+_YTDLP_MAX_RESULTS = 50
+_NON_MUSIC_MARKERS = (
+    "notícia",
+    "podcast",
+    "gameplay",
+    "tutorial",
+    "aula",
+    "vlog",
+    "entrevista",
+    "shorts",
+)
+
+
+class SearchError(RuntimeError):
+    """Erro seguro e legível para falhas da busca."""
+
+
+def fetch_page(
+    query: str,
+    count: int = 15,
+    page_token: Optional[str] = None,
+) -> tuple[list[dict[str, Any]], Optional[str]]:
+    """Busca uma página; usa Data API e cai para yt-dlp quando necessário."""
+    query = query.strip()
+    if not query:
+        raise SearchError("Informe um termo de busca.")
+
+    count = max(1, min(int(count), 50))
+    service = auth.get_youtube_service(interactive=False)
+    if service is not None:
+        try:
+            response = _search_oauth(service, query, count, page_token)
+            results = _build_results(response, service=service)
+            if results:
+                return results, _next_page_token(response)
+        except HttpError:
+            pass
+
+    api_key = auth.get_api_key()
+    if api_key:
+        try:
+            response = _search_with_key(query, count, page_token, api_key)
+            results = _build_results(response, api_key=api_key)
+            if results:
+                return results, _next_page_token(response)
+        except (requests.RequestException, ValueError):
+            pass
+
+    return _fetch_ytdlp_page(query, count, page_token)
+
+
+def search(query: str, count: int = 15) -> Iterator[dict[str, Any]]:
+    """Interface em generator para compatibilidade com consumidores simples."""
+    results, _ = fetch_page(query, count=count)
+    yield from results
+
+
+def _next_page_token(response: dict[str, Any]) -> Optional[str]:
+    token = response.get("nextPageToken")
+    return str(token) if token else None
+
+
+def _fetch_ytdlp_page(
+    query: str,
+    count: int,
+    page_token: Optional[str],
+) -> tuple[list[dict[str, Any]], Optional[str]]:
+    offset = _ytdlp_offset(page_token)
+    if offset >= _YTDLP_MAX_RESULTS:
+        return [], None
+
+    cache_key = query.casefold()
+    cached = _YTDLP_CACHE.get(cache_key, [])
+    required = min(offset + count, _YTDLP_MAX_RESULTS)
+    if len(cached) < required:
+        request_limit = min(required + count, _YTDLP_MAX_RESULTS)
+        try:
+            options = {
+                "quiet": True,
+                "no_warnings": True,
+                "skip_download": True,
+                "extract_flat": True,
+            }
+            with yt_dlp.YoutubeDL(options) as downloader:
+                info = downloader.extract_info(
+                    f"ytsearch{request_limit}:{query}", download=False
+                )
+            cached = [
+                normalized
+                for entry in (info.get("entries") or [])
+                if (normalized := normalize_ytdlp_entry(entry)) is not None
+            ]
+            _YTDLP_CACHE[cache_key] = cached
+        except Exception as exc:
+            raise SearchError(
+                "A busca do YouTube e o fallback yt-dlp estão indisponíveis."
+            ) from exc
+
+    results = cached[offset : offset + count]
+    next_token = (
+        f"yt:{offset + count}"
+        if offset + count < len(cached)
+        else None
+    )
+    return results, next_token
+
+
+def _ytdlp_offset(page_token: Optional[str]) -> int:
+    if not page_token or not page_token.startswith("yt:"):
+        return 0
+    try:
+        return max(0, int(page_token[3:]))
+    except ValueError:
+        return 0
+
+
+def normalize_ytdlp_entry(entry: Any) -> Optional[dict[str, Any]]:
+    if not isinstance(entry, dict):
+        return None
+    video_id = str(entry.get("id", "")).strip()
+    title = str(entry.get("title") or "Sem título").strip()
+    if not video_id:
+        return None
+
+    channel = str(entry.get("channel") or entry.get("uploader") or "").strip()
+    searchable = f"{title} {channel}".casefold()
+    music_markers = ("music", "música", "song", "audio", "lyrics", "official", "topic", "vevo", "remaster", "live")
+    if any(marker in searchable for marker in _NON_MUSIC_MARKERS) and not any(
+        marker in searchable for marker in music_markers
+    ):
+        return None
+
+    thumbnails = entry.get("thumbnails") or []
+    thumbnail = max(
+        thumbnails,
+        key=lambda item: item.get("width", 0) if isinstance(item, dict) else 0,
+        default={},
+    )
+    url = str(
+        entry.get("webpage_url")
+        or entry.get("url")
+        or f"https://www.youtube.com/watch?v={video_id}"
+    )
+    if url.startswith("/"):
+        url = "https://www.youtube.com" + url
+    duration = entry.get("duration", 0)
+    try:
+        duration = float(duration or 0)
+    except (TypeError, ValueError):
+        duration = 0.0
+
+    return {
+        "id": video_id,
+        "title": title,
+        "url": url,
+        "duration": duration,
+        "is_music": True,
+        "thumbnail": thumbnail.get("url", "") if isinstance(thumbnail, dict) else "",
+        "channelTitle": channel,
+        "artist": channel or None,
+        "source": "yt-dlp",
+    }
+
+
+def _search_oauth(
+    service: Any,
+    query: str,
+    count: int,
+    page_token: Optional[str],
+) -> dict[str, Any]:
+    kwargs: dict[str, Any] = {
+        "part": "snippet",
+        "q": query,
+        "type": "video",
+        "videoCategoryId": _MUSIC_CATEGORY_ID,
+        "maxResults": count,
+        "order": "relevance",
+    }
+    if page_token:
+        kwargs["pageToken"] = page_token
+    return service.search().list(**kwargs).execute()
+
+
+def _search_with_key(
+    query: str,
+    count: int,
+    page_token: Optional[str],
+    api_key: str,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {
+        "part": "snippet",
+        "q": query,
+        "type": "video",
+        "videoCategoryId": _MUSIC_CATEGORY_ID,
+        "maxResults": count,
+        "order": "relevance",
+        "key": api_key,
+    }
+    if page_token:
+        params["pageToken"] = page_token
+
+    http_response = requests.get(_SEARCH_URL, params=params, timeout=15)
+    if http_response.status_code == 429:
+        raise ValueError("A cota diária de buscas do YouTube foi atingida.")
+    if http_response.status_code == 403:
+        raise ValueError("A YOUTUBE_API_KEY não tem acesso ou cuota disponível.")
+    if http_response.status_code == 400:
+        raise ValueError("O YouTube recusou os parâmetros da busca.")
+    http_response.raise_for_status()
+    return http_response.json()
+
+
+def _build_results(
+    response: dict[str, Any],
+    service: Any = None,
+    api_key: Optional[str] = None,
+) -> tuple[list[dict[str, Any]], Optional[str]]:
+    items = response.get("items", [])
+    video_ids = [
+        item.get("id", {}).get("videoId", "")
+        for item in items
+        if item.get("id", {}).get("videoId")
+    ]
+    details = _video_details(video_ids, service=service, api_key=api_key)
+
+    results: list[dict[str, Any]] = []
+    for item in items:
+        video_id = item.get("id", {}).get("videoId", "")
+        if not video_id:
+            continue
+        snippet = item.get("snippet", {})
+        detail = details.get(video_id, {})
+        detail_snippet = detail.get("snippet", {})
+        thumbnails = snippet.get("thumbnails", {}) or {}
+        thumbnail = max(
+            thumbnails.values(),
+            key=lambda value: value.get("width", 0),
+            default={},
+        ).get("url", "")
+        channel = str(
+            snippet.get("channelTitle")
+            or detail_snippet.get("channelTitle")
+            or ""
+        )
+        category_id = str(
+            detail_snippet.get("categoryId")
+            or snippet.get("categoryId")
+            or ""
+        )
+        if category_id != _MUSIC_CATEGORY_ID:
+            continue
+        results.append(
+            {
+                "id": video_id,
+                "title": snippet.get("title", "Sem título"),
+                "url": f"https://www.youtube.com/watch?v={video_id}",
+                "duration": _parse_duration(
+                    detail.get("contentDetails", {}).get("duration", "")
+                ),
+                "is_music": category_id == _MUSIC_CATEGORY_ID,
+                "thumbnail": thumbnail,
+                "channelTitle": channel,
+                "artist": channel or None,
+            }
+        )
+
+    next_page = response.get("nextPageToken")
+    return results, str(next_page) if next_page else None
+
+
+def _video_details(
+    video_ids: list[str],
+    service: Any = None,
+    api_key: Optional[str] = None,
+) -> dict[str, dict[str, Any]]:
+    if not video_ids:
+        return {}
+    ids = ",".join(video_ids[:50])
+    try:
+        if service is not None:
+            response = (
+                service.videos()
+                .list(part="snippet,contentDetails", id=ids)
+                .execute()
+            )
+        elif api_key:
+            response = requests.get(
+                _VIDEOS_URL,
+                params={
+                    "part": "snippet,contentDetails",
+                    "id": ids,
+                    "key": api_key,
+                },
+                timeout=15,
+            )
+            response.raise_for_status()
+            response = response.json()
+        else:
+            return {}
+    except (HttpError, requests.RequestException, ValueError):
+        return {}
+
+    return {
+        item["id"]: item
+        for item in response.get("items", [])
+        if item.get("id")
+    }
+
+
+def _parse_duration(value: Any) -> float:
+    """Converte a duração ISO 8601 da API para segundos."""
+    if not isinstance(value, str) or not value.startswith("P"):
+        return 0.0
+    try:
+        time_part = value[1:].split("T", 1)[1]
+        days = 0
+        if "D" in time_part:
+            day_part, time_part = time_part.split("D", 1)
+            days = int(day_part)
+        hours = 0
+        minutes = 0
+        seconds = 0.0
+        if "H" in time_part:
+            hour_part, time_part = time_part.split("H", 1)
+            hours = int(hour_part)
+        if "M" in time_part:
+            minute_part, time_part = time_part.split("M", 1)
+            minutes = int(minute_part)
+        seconds = float(time_part.rstrip("S"))
+        return days * 86400 + hours * 3600 + minutes * 60 + seconds
+    except (IndexError, TypeError, ValueError):
+        return 0.0
+
+
+def _safe_http_error(error: HttpError) -> str:
+    status = getattr(getattr(error, "resp", None), "status", None)
+    if status == 429:
+        return "A cota diária de buscas do YouTube foi atingida. Aguarde o reset ou use outro projeto/API key."
+    if status == 403:
+        return "A conta ou o projeto não tem quota disponível para a API."
+    if status == 401:
+        return "A sessão expirou. Entre na conta novamente."
+    if status:
+        return f"A API do YouTube respondeu com HTTP {status}."
+    return "A API do YouTube recusou a solicitação."