1038 lines
42 KiB
Python
1038 lines
42 KiB
Python
import re
|
|
import time
|
|
import uuid
|
|
from threading import Lock
|
|
from typing import Generator, Optional, Union
|
|
|
|
import click
|
|
import jwt
|
|
from langcodes import Language
|
|
|
|
from unshackle.core.constants import AnyTrack
|
|
from unshackle.core.manifests import DASH
|
|
from unshackle.core.search_result import SearchResult
|
|
from unshackle.core.service import Service
|
|
from unshackle.core.session import session
|
|
from unshackle.core.titles import Episode, Series
|
|
from unshackle.core.tracks import Chapters, Tracks
|
|
from unshackle.core.tracks.chapter import Chapter
|
|
from unshackle.core.tracks.subtitle import Subtitle
|
|
|
|
import pysubs2
|
|
from subby import WebVTTConverter,CommonIssuesFixer
|
|
from hashlib import md5
|
|
|
|
class CR(Service):
|
|
"""
|
|
Service code for Crunchyroll streaming service (https://www.crunchyroll.com).
|
|
|
|
\b
|
|
Version: 3.0.1
|
|
Author: sp4rk.y
|
|
Date: 2026-03-26
|
|
Authorization: Credentials
|
|
Robustness:
|
|
Widevine:
|
|
L3: 1080p, AAC2.0
|
|
|
|
Updated by: SeFree
|
|
Date: 2026-03-30
|
|
Change:
|
|
- Correct SDH and Force subtitle
|
|
|
|
\b
|
|
Tips:
|
|
- Input should be complete URL or series ID
|
|
https://www.crunchyroll.com/series/GRMG8ZQZR/series-name OR GRMG8ZQZR
|
|
- Supports multiple audio and subtitle languages
|
|
- Device ID is cached for consistent authentication across runs
|
|
|
|
\b
|
|
Notes:
|
|
- Emulates Android TV client (v3.58.0) with Playback API v3
|
|
- Uses password-based authentication with refresh token caching
|
|
- Refresh tokens are cached for 30 days for cross-session reuse
|
|
- Manages concurrent stream limits automatically
|
|
"""
|
|
|
|
TITLE_RE = r"^(?:https?://(?:www\.)?crunchyroll\.com/(?:series|watch)/)?(?P<id>[A-Z0-9]+)"
|
|
LICENSE_LOCK = Lock()
|
|
MAX_CONCURRENT_STREAMS = 3
|
|
ACTIVE_STREAMS: list[tuple[str, str]] = []
|
|
|
|
@staticmethod
|
|
def get_session():
|
|
return session("okhttp4")
|
|
|
|
@staticmethod
|
|
@click.command(name="CR", short_help="https://crunchyroll.com")
|
|
@click.argument("title", type=str, required=True)
|
|
@click.pass_context
|
|
def cli(ctx, **kwargs) -> "CR":
|
|
return CR(ctx, **kwargs)
|
|
|
|
def __init__(self, ctx, title: str):
|
|
self.title = title
|
|
self.account_id: Optional[str] = None
|
|
self.access_token: Optional[str] = None
|
|
self.refresh_token: Optional[str] = None
|
|
self.profile_id: Optional[str] = None
|
|
self.token_expiration: Optional[int] = None
|
|
self.anonymous_id = str(uuid.uuid4())
|
|
|
|
self.skip_dl=ctx.parent.params.get("skip_dl")
|
|
|
|
super().__init__(ctx)
|
|
|
|
device_cache_key = "cr_device_id"
|
|
cached_device = self.cache.get(device_cache_key)
|
|
|
|
if cached_device and not cached_device.expired:
|
|
self.device_id = cached_device.data["device_id"]
|
|
else:
|
|
self.device_id = str(uuid.uuid4())
|
|
cached_device.set(
|
|
data={"device_id": self.device_id},
|
|
expiration=60 * 60 * 24 * 365 * 10,
|
|
)
|
|
|
|
self.device_name = self.config.get("device", {}).get("name", "SHIELD Android TV")
|
|
self.device_type = self.config.get("device", {}).get("type", "ANDROIDTV")
|
|
|
|
self.session.headers.update(self.config.get("headers", {}))
|
|
self.session.headers["etp-anonymous-id"] = self.anonymous_id
|
|
|
|
@property
|
|
def auth_header(self) -> dict:
|
|
"""Return authorization header dict."""
|
|
return {"authorization": f"Bearer {self.access_token}"}
|
|
|
|
def ensure_authenticated(self) -> None:
|
|
"""Check if token is expired and re-authenticate if needed."""
|
|
if not self.token_expiration:
|
|
cache_key = f"cr_auth_token_{self.credential.sha1 if self.credential else 'default'}"
|
|
cached = self.cache.get(cache_key)
|
|
|
|
if cached and not cached.expired:
|
|
self.access_token = cached.data["access_token"]
|
|
self.account_id = cached.data.get("account_id")
|
|
self.profile_id = cached.data.get("profile_id")
|
|
self.refresh_token = cached.data.get("refresh_token")
|
|
self.token_expiration = cached.data.get("token_expiration")
|
|
self.session.headers.update(self.auth_header)
|
|
else:
|
|
self.authenticate(credential=self.credential)
|
|
return
|
|
|
|
current_time = int(time.time())
|
|
if current_time >= (self.token_expiration - 60):
|
|
if self.refresh_token:
|
|
self._refresh_access_token()
|
|
else:
|
|
self.authenticate(credential=self.credential)
|
|
|
|
def authenticate(self, cookies=None, credential=None) -> None:
|
|
"""Authenticate using username and password credentials, with refresh token support."""
|
|
super().authenticate(cookies, credential)
|
|
|
|
cache_key = f"cr_auth_token_{credential.sha1 if credential else 'default'}"
|
|
cached = self.cache.get(cache_key)
|
|
|
|
if cached and not cached.expired:
|
|
self.access_token = cached.data["access_token"]
|
|
self.account_id = cached.data.get("account_id")
|
|
self.profile_id = cached.data.get("profile_id")
|
|
self.refresh_token = cached.data.get("refresh_token")
|
|
self.token_expiration = cached.data.get("token_expiration")
|
|
else:
|
|
# Try refresh token from a previous session first
|
|
refresh_cache_key = f"cr_refresh_token_{credential.sha1 if credential else 'default'}"
|
|
refresh_cached = self.cache.get(refresh_cache_key)
|
|
|
|
if refresh_cached and not refresh_cached.expired and refresh_cached.data.get("refresh_token"):
|
|
self.refresh_token = refresh_cached.data["refresh_token"]
|
|
try:
|
|
self._refresh_access_token()
|
|
self._cache_auth(cache_key)
|
|
self.session.headers.update(self.auth_header)
|
|
|
|
if self.ACTIVE_STREAMS:
|
|
self.ACTIVE_STREAMS.clear()
|
|
|
|
try:
|
|
self.clear_all_sessions()
|
|
except Exception as e:
|
|
self.log.warning(f"Failed to clear previous sessions: {e}")
|
|
return
|
|
except Exception:
|
|
self.log.warning("Refresh token expired or invalid, falling back to password login")
|
|
self.refresh_token = None
|
|
|
|
if not credential:
|
|
raise ValueError("No credential provided for authentication")
|
|
|
|
response = self.session.post(
|
|
url=self.config["endpoints"]["token"],
|
|
headers={
|
|
"content-type": "application/x-www-form-urlencoded; charset=UTF-8",
|
|
"request-type": "SignIn",
|
|
},
|
|
data={
|
|
"grant_type": "password",
|
|
"username": credential.username,
|
|
"password": credential.password,
|
|
"scope": "offline_access",
|
|
"client_id": self.config["client"]["id"],
|
|
"client_secret": self.config["client"]["secret"],
|
|
"device_type": self.device_type,
|
|
"device_id": self.device_id,
|
|
"device_name": self.device_name,
|
|
},
|
|
)
|
|
|
|
if response.status_code != 200:
|
|
try:
|
|
error_data = response.json()
|
|
error_msg = error_data.get("error", "Unknown error")
|
|
error_code = error_data.get("code", "")
|
|
raise ValueError(f"Login failed: {response.status_code} - {error_msg} ({error_code})")
|
|
except ValueError:
|
|
raise
|
|
except Exception:
|
|
raise ValueError(f"Login failed: {response.status_code} - {response.text}")
|
|
|
|
self._apply_token_response(response.json())
|
|
self._cache_auth(cache_key)
|
|
|
|
self.session.headers.update(self.auth_header)
|
|
|
|
if self.ACTIVE_STREAMS:
|
|
self.ACTIVE_STREAMS.clear()
|
|
|
|
try:
|
|
self.clear_all_sessions()
|
|
except Exception as e:
|
|
self.log.warning(f"Failed to clear previous sessions: {e}")
|
|
|
|
def _apply_token_response(self, token_data: dict) -> None:
|
|
"""Extract and store auth fields from a token response."""
|
|
self.access_token = token_data["access_token"]
|
|
self.refresh_token = token_data.get("refresh_token", self.refresh_token)
|
|
self.account_id = token_data.get("account_id", self.account_id)
|
|
self.profile_id = token_data.get("profile_id", self.profile_id)
|
|
|
|
try:
|
|
decoded_token = jwt.decode(self.access_token, options={"verify_signature": False})
|
|
self.token_expiration = decoded_token.get("exp")
|
|
except Exception:
|
|
self.token_expiration = int(time.time()) + token_data.get("expires_in", 300)
|
|
|
|
def _cache_auth(self, cache_key: str) -> None:
|
|
"""Cache current auth state (access token + refresh token)."""
|
|
cached = self.cache.get(cache_key)
|
|
cached.set(
|
|
data={
|
|
"access_token": self.access_token,
|
|
"account_id": self.account_id,
|
|
"profile_id": self.profile_id,
|
|
"refresh_token": self.refresh_token,
|
|
"token_expiration": self.token_expiration,
|
|
},
|
|
expiration=self.token_expiration
|
|
if isinstance(self.token_expiration, int) and self.token_expiration > int(time.time())
|
|
else 300,
|
|
)
|
|
|
|
# Cache refresh token separately with a long TTL for cross-session reuse
|
|
if self.refresh_token:
|
|
refresh_cache_key = cache_key.replace("cr_auth_token_", "cr_refresh_token_")
|
|
refresh_cached = self.cache.get(refresh_cache_key)
|
|
refresh_cached.set(
|
|
data={"refresh_token": self.refresh_token},
|
|
expiration=60 * 60 * 24 * 30, # 30 days
|
|
)
|
|
|
|
def _refresh_access_token(self) -> None:
|
|
"""Refresh the access token using the stored refresh token."""
|
|
if not self.refresh_token:
|
|
raise ValueError("No refresh token available")
|
|
|
|
response = self.session.post(
|
|
url=self.config["endpoints"]["token"],
|
|
headers={
|
|
"content-type": "application/x-www-form-urlencoded; charset=UTF-8",
|
|
},
|
|
data={
|
|
"grant_type": "refresh_token",
|
|
"refresh_token": self.refresh_token,
|
|
"scope": "offline_access",
|
|
"client_id": self.config["client"]["id"],
|
|
"client_secret": self.config["client"]["secret"],
|
|
"device_type": self.device_type,
|
|
"device_id": self.device_id,
|
|
"device_name": self.device_name,
|
|
},
|
|
)
|
|
|
|
if response.status_code != 200:
|
|
self.refresh_token = None
|
|
raise ValueError(f"Token refresh failed: {response.status_code}")
|
|
|
|
self._apply_token_response(response.json())
|
|
|
|
cache_key = f"cr_auth_token_{self.credential.sha1 if self.credential else 'default'}"
|
|
self._cache_auth(cache_key)
|
|
self.session.headers.update(self.auth_header)
|
|
|
|
def get_titles(self) -> Union[Series]:
|
|
"""Fetch series and episode information."""
|
|
series_id = self.parse_series_id(self.title)
|
|
|
|
series_http = self.session.get(
|
|
url=self.config["endpoints"]["series"].format(series_id=series_id),
|
|
params={"locale": self.config["params"]["locale"]},
|
|
)
|
|
series_response = series_http.json()
|
|
|
|
if "error" in series_response:
|
|
raise ValueError(f"Series not found: {series_id} - {series_response.get('error')}")
|
|
|
|
series_data = (
|
|
series_response.get("data", [{}])[0] if isinstance(series_response.get("data"), list) else series_response
|
|
)
|
|
series_title = series_data.get("title", "Unknown Series")
|
|
|
|
seasons_http = self.session.get(
|
|
url=self.config["endpoints"]["seasons"].format(series_id=series_id),
|
|
params={
|
|
"locale": self.config["params"]["locale"],
|
|
"preferred_audio_language": self.config.get("params", {}).get("preferred_audio_language", "en-US"),
|
|
},
|
|
)
|
|
seasons_response = seasons_http.json()
|
|
|
|
seasons_data = seasons_response.get("data", [])
|
|
|
|
if not seasons_data:
|
|
raise ValueError(f"No seasons found for series: {series_id}")
|
|
|
|
used_season_numbers: set[int] = set()
|
|
season_id_to_number: dict[str, int] = {}
|
|
|
|
all_episode_data = []
|
|
special_episodes = []
|
|
|
|
for season in seasons_data:
|
|
season_id = season["id"]
|
|
season_number = season.get("season_number", 0)
|
|
|
|
effective_season_number = season_number
|
|
if isinstance(season_number, int) and season_number > 0:
|
|
if season_number in used_season_numbers:
|
|
candidate = season_number + 1
|
|
while candidate in used_season_numbers:
|
|
candidate += 1
|
|
effective_season_number = candidate
|
|
used_season_numbers.add(effective_season_number)
|
|
|
|
season_id_to_number[season_id] = effective_season_number
|
|
|
|
episodes_http = self.session.get(
|
|
url=self.config["endpoints"]["season_episodes"].format(season_id=season_id),
|
|
params={"locale": self.config["params"]["locale"]},
|
|
)
|
|
episodes_response = episodes_http.json()
|
|
|
|
episodes_data = episodes_response.get("data", [])
|
|
|
|
for episode_data in episodes_data:
|
|
episode_number = episode_data.get("episode_number")
|
|
|
|
if episode_number is None or isinstance(episode_number, float):
|
|
special_episodes.append(episode_data)
|
|
|
|
all_episode_data.append((episode_data, effective_season_number))
|
|
|
|
if not all_episode_data:
|
|
raise ValueError(f"No episodes found for series: {series_id}")
|
|
|
|
series_year = None
|
|
if all_episode_data:
|
|
first_episode_data = all_episode_data[0][0]
|
|
first_air_date = first_episode_data.get("episode_air_date")
|
|
if first_air_date:
|
|
series_year = int(first_air_date[:4])
|
|
|
|
special_episodes.sort(key=lambda x: x.get("episode_air_date", ""))
|
|
special_episode_numbers = {ep["id"]: idx + 1 for idx, ep in enumerate(special_episodes)}
|
|
episodes = []
|
|
season_episode_counts = {}
|
|
|
|
for episode_data, season_number in all_episode_data:
|
|
episode_number = episode_data.get("episode_number")
|
|
|
|
if episode_number is None or isinstance(episode_number, float):
|
|
final_season = 0
|
|
final_number = special_episode_numbers[episode_data["id"]]
|
|
else:
|
|
final_season = season_number
|
|
if final_season not in season_episode_counts:
|
|
season_episode_counts[final_season] = 0
|
|
|
|
season_episode_counts[final_season] += 1
|
|
final_number = season_episode_counts[final_season]
|
|
|
|
original_language = None
|
|
versions = episode_data.get("versions", []) if episode_data.get("versions", []) else []
|
|
for version in versions:
|
|
if "main" in version.get("roles", []):
|
|
original_language = version.get("audio_locale")
|
|
break
|
|
|
|
episode = Episode(
|
|
id_=episode_data["id"],
|
|
service=self.__class__,
|
|
title=series_title,
|
|
season=final_season,
|
|
number=final_number,
|
|
name=episode_data.get("title"),
|
|
year=series_year,
|
|
language=original_language,
|
|
description=episode_data.get("description"),
|
|
data=episode_data,
|
|
)
|
|
episodes.append(episode)
|
|
|
|
return Series(episodes)
|
|
|
|
def set_track_metadata(
|
|
self, tracks: Tracks, episode_id: str, is_original: bool, audio_locale: Optional[str] = None
|
|
) -> None:
|
|
"""Set metadata for video and audio tracks."""
|
|
for video in tracks.videos:
|
|
video.needs_repack = True
|
|
video.data["episode_id"] = episode_id
|
|
video.is_original_lang = is_original
|
|
if audio_locale:
|
|
video.data["audio_locale"] = audio_locale
|
|
for audio in tracks.audio:
|
|
audio.data["episode_id"] = episode_id
|
|
audio.is_original_lang = is_original
|
|
if audio_locale:
|
|
audio.data["audio_locale"] = audio_locale
|
|
|
|
def get_tracks(self, title: Episode) -> Tracks:
|
|
"""Fetch video, audio, and subtitle tracks for an episode."""
|
|
self.ensure_authenticated()
|
|
|
|
episode_id = title.id
|
|
|
|
if self.ACTIVE_STREAMS:
|
|
self.ACTIVE_STREAMS.clear()
|
|
|
|
self.clear_all_sessions()
|
|
|
|
# Définir les endpoints à essayer (tv/android_tv pour vidéo, android/phone/download pour audio 192kbps)
|
|
endpoints_to_try = ["playback", "playback_download"]
|
|
|
|
preferred_audio = self.config.get("params", {}).get("preferred_audio_language", "en-US")
|
|
initial_response = self.get_playback_data(
|
|
episode_id, track_stream=False, endpoint_key="playback", audio_locale=preferred_audio
|
|
)
|
|
versions = initial_response.get("versions", [])
|
|
|
|
if not versions:
|
|
self.log.warning("No versions found in playback response, using single version")
|
|
versions = [{"audio_locale": initial_response.get("audioLocale", "ja-JP")}]
|
|
|
|
tracks = None
|
|
|
|
for idx, version in enumerate(versions):
|
|
audio_locale = version.get("audio_locale")
|
|
version_guid = version.get("guid")
|
|
is_original = version.get("original", False)
|
|
|
|
if not audio_locale:
|
|
continue
|
|
|
|
request_episode_id = version_guid if version_guid else episode_id
|
|
|
|
# Essayer chaque endpoint pour cette version
|
|
for endpoint_key in endpoints_to_try:
|
|
try:
|
|
if idx == 0 and not version_guid and endpoint_key == "playback":
|
|
version_response = initial_response
|
|
version_token = version_response.get("token")
|
|
else:
|
|
if idx == 1 and not versions[0].get("guid") and endpoint_key == "playback":
|
|
initial_token = initial_response.get("token")
|
|
if initial_token:
|
|
self.close_stream(episode_id, initial_token)
|
|
|
|
try:
|
|
version_response = self.get_playback_data(
|
|
request_episode_id,
|
|
track_stream=False,
|
|
endpoint_key=endpoint_key,
|
|
audio_locale=audio_locale,
|
|
)
|
|
except ValueError as e:
|
|
self.log.warning(
|
|
f"Could not get playback info for audio {audio_locale} from {endpoint_key}: {e}"
|
|
)
|
|
continue
|
|
|
|
version_token = version_response.get("token")
|
|
|
|
hard_subs = version_response.get("hardSubs", {})
|
|
|
|
root_url = version_response.get("url")
|
|
|
|
if root_url and "/clean/" in root_url:
|
|
dash_url = root_url
|
|
elif "none" in hard_subs:
|
|
dash_url = hard_subs["none"].get("url")
|
|
elif "fr-FR" in hard_subs:
|
|
dash_url = hard_subs["fr-FR"].get("url")
|
|
elif hard_subs:
|
|
first_key = list(hard_subs.keys())[0]
|
|
dash_url = hard_subs[first_key].get("url")
|
|
else:
|
|
dash_url = None
|
|
|
|
if not dash_url:
|
|
if version_token:
|
|
self.close_stream(request_episode_id, version_token)
|
|
continue
|
|
|
|
try:
|
|
version_tracks = DASH.from_url(
|
|
url=dash_url,
|
|
session=self.session,
|
|
).to_tracks(language=audio_locale)
|
|
|
|
if tracks is None:
|
|
tracks = version_tracks
|
|
self.set_track_metadata(tracks, request_episode_id, is_original, audio_locale)
|
|
else:
|
|
self.set_track_metadata(version_tracks, request_episode_id, is_original, audio_locale)
|
|
for video in version_tracks.videos:
|
|
if not any(v.id == video.id for v in tracks.videos):
|
|
tracks.add(video)
|
|
for audio in version_tracks.audio:
|
|
existing_audio = next((a for a in tracks.audio if a.language == audio.language), None)
|
|
if existing_audio is None or (
|
|
hasattr(audio, "bitrate")
|
|
and hasattr(existing_audio, "bitrate")
|
|
and audio.bitrate > existing_audio.bitrate
|
|
):
|
|
tracks.add(audio)
|
|
elif existing_audio is None:
|
|
tracks.add(audio)
|
|
|
|
except Exception as e:
|
|
self.log.warning(
|
|
f"Failed to parse DASH manifest for audio {audio_locale} from {endpoint_key}: {e}"
|
|
)
|
|
if version_token:
|
|
self.close_stream(request_episode_id, version_token)
|
|
continue
|
|
|
|
if endpoint_key == "playback":
|
|
captions = version_response.get("captions", {})
|
|
subtitles_data = version_response.get("subtitles", {})
|
|
# all_subs = {**captions, **subtitles_data}
|
|
|
|
for lang_code, sub_data in captions.items():
|
|
if lang_code == "none":
|
|
continue
|
|
|
|
if isinstance(sub_data, dict) and "url" in sub_data:
|
|
try:
|
|
lang = Language.get(lang_code)
|
|
except (ValueError, LookupError):
|
|
lang = Language.get("en")
|
|
|
|
subtitle_format = sub_data.get("format", "vtt").lower()
|
|
if subtitle_format == "ass" or subtitle_format == "ssa":
|
|
codec = Subtitle.Codec.SubStationAlphav4
|
|
else:
|
|
codec = Subtitle.Codec.SubRip
|
|
|
|
tracks.add(
|
|
Subtitle(
|
|
id_=f"subtitle-{audio_locale}-{lang_code}-sdh",
|
|
url=sub_data["url"],
|
|
codec=codec,
|
|
language=lang,
|
|
forced=False,
|
|
sdh=True,
|
|
),
|
|
warn_only=True,
|
|
)
|
|
for lang_code, sub_data in subtitles_data.items():
|
|
if lang_code == "none":
|
|
continue
|
|
|
|
if isinstance(sub_data, dict) and "url" in sub_data:
|
|
try:
|
|
lang = Language.get(lang_code)
|
|
except (ValueError, LookupError):
|
|
lang = Language.get("en")
|
|
|
|
subtitle_format = sub_data.get("format", "vtt").lower()
|
|
if subtitle_format == "ass" or subtitle_format == "ssa":
|
|
codec = Subtitle.Codec.SubStationAlphav4
|
|
else:
|
|
codec = Subtitle.Codec.SubRip
|
|
|
|
tracks.add(
|
|
Subtitle(
|
|
id_=f"subtitle-{audio_locale}-{lang_code}"+("_force" if (Language.get(audio_locale)== Language.get(lang)) else ""),
|
|
url=sub_data["url"],
|
|
codec=codec,
|
|
language=lang,
|
|
forced=True if Language.get(audio_locale)== Language.get(lang) else False,
|
|
sdh=False,
|
|
),
|
|
warn_only=True,
|
|
)
|
|
|
|
if version_token:
|
|
self.close_stream(request_episode_id, version_token)
|
|
|
|
except Exception as e:
|
|
self.log.warning(f"Error processing endpoint {endpoint_key} for version {idx}: {e}")
|
|
continue
|
|
|
|
if versions and versions[0].get("guid"):
|
|
initial_token = initial_response.get("token")
|
|
if initial_token:
|
|
self.close_stream(episode_id, initial_token)
|
|
|
|
if tracks is None:
|
|
raise ValueError(f"Failed to fetch any tracks for episode: {episode_id}")
|
|
|
|
for track in tracks.audio + tracks.subtitles:
|
|
if track.language:
|
|
try:
|
|
lang_obj = Language.get(str(track.language))
|
|
base_lang = Language.get(lang_obj.language)
|
|
lang_display = base_lang.language_name()
|
|
track.name = lang_display
|
|
except (ValueError, LookupError):
|
|
pass
|
|
|
|
images = title.data.get("images", {})
|
|
thumbnails = images.get("thumbnail", [])
|
|
if thumbnails:
|
|
thumb_variants = thumbnails[0] if isinstance(thumbnails[0], list) else [thumbnails[0]]
|
|
if thumb_variants:
|
|
thumb_index = min(7, len(thumb_variants) - 1)
|
|
thumb = thumb_variants[thumb_index]
|
|
if isinstance(thumb, dict) and "source" in thumb:
|
|
pass
|
|
|
|
return tracks
|
|
|
|
def get_widevine_license(self, challenge: bytes, title: Episode, track) -> bytes:
|
|
"""
|
|
Get Widevine license for decryption.
|
|
|
|
Creates a fresh playback session for each track, gets the license, then immediately
|
|
closes the stream. This prevents hitting the 3 concurrent stream limit.
|
|
CDN authorization is embedded in the manifest URLs, not tied to active sessions.
|
|
"""
|
|
self.ensure_authenticated()
|
|
|
|
track_episode_id = track.data.get("episode_id", title.id)
|
|
|
|
with self.LICENSE_LOCK:
|
|
playback_token = None
|
|
try:
|
|
audio_locale = track.data.get("audio_locale")
|
|
playback_data = self.get_playback_data(track_episode_id, track_stream=True, audio_locale=audio_locale)
|
|
playback_token = playback_data.get("token")
|
|
|
|
if not playback_token:
|
|
raise ValueError(f"No playback token in response for {track_episode_id}")
|
|
|
|
track.data["playback_token"] = playback_token
|
|
|
|
license_response = self.session.post(
|
|
url=self.config["endpoints"]["license_widevine"],
|
|
params={"specConform": "true"},
|
|
data=challenge,
|
|
headers={
|
|
**self.auth_header,
|
|
"content-type": "application/octet-stream",
|
|
"accept": "application/octet-stream",
|
|
"x-cr-content-id": track_episode_id,
|
|
"x-cr-video-token": playback_token,
|
|
},
|
|
)
|
|
if license_response.status_code != 200:
|
|
self.close_stream(track_episode_id, playback_token)
|
|
try:
|
|
error_detail = license_response.text[:200]
|
|
except Exception:
|
|
error_detail = "Unknown error"
|
|
raise ValueError(f"License request failed: {license_response.status_code} - {error_detail}")
|
|
|
|
self.close_stream(track_episode_id, playback_token)
|
|
return license_response.content
|
|
|
|
except Exception:
|
|
if playback_token:
|
|
try:
|
|
self.close_stream(track_episode_id, playback_token)
|
|
except Exception:
|
|
pass
|
|
raise
|
|
|
|
def cleanup_active_streams(self) -> None:
|
|
"""
|
|
Close all remaining active streams.
|
|
Called to ensure no streams are left open.
|
|
"""
|
|
if self.ACTIVE_STREAMS:
|
|
try:
|
|
self.authenticate()
|
|
except Exception as e:
|
|
self.log.warning(f"Failed to re-authenticate during cleanup: {e}")
|
|
|
|
for episode_id, token in list(self.ACTIVE_STREAMS):
|
|
try:
|
|
self.close_stream(episode_id, token)
|
|
except Exception as e:
|
|
self.log.warning(f"Failed to close stream {episode_id}: {e}")
|
|
if (episode_id, token) in self.ACTIVE_STREAMS:
|
|
self.ACTIVE_STREAMS.remove((episode_id, token))
|
|
|
|
def __del__(self) -> None:
|
|
"""Cleanup any remaining streams when service is destroyed."""
|
|
try:
|
|
self.cleanup_active_streams()
|
|
except Exception:
|
|
pass
|
|
|
|
def get_chapters(self, title: Episode) -> Chapters:
|
|
"""Get chapters/skip events for an episode."""
|
|
chapters = Chapters()
|
|
|
|
chapter_response = self.session.get(
|
|
url=self.config["endpoints"]["skip_events"].format(episode_id=title.id),
|
|
)
|
|
special_chapters = []
|
|
|
|
if chapter_response.status_code == 200:
|
|
try:
|
|
chapter_data = chapter_response.json()
|
|
except Exception as e:
|
|
self.log.warning(f"Failed to parse chapter data: {e}")
|
|
return chapters
|
|
|
|
for chapter_type in ["intro", "recap", "credits", "preview"]:
|
|
if chapter_info := chapter_data.get(chapter_type):
|
|
try:
|
|
start_time = int(chapter_info["start"] * 1000)
|
|
end_time = int(chapter_info.get("end", chapter_info["start"]) * 1000)
|
|
special_chapters.append(
|
|
{
|
|
"start": start_time,
|
|
"end": end_time,
|
|
"name": chapter_info["type"].capitalize(),
|
|
"type": chapter_type,
|
|
}
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
special_chapters.sort(key=lambda x: x["start"])
|
|
|
|
all_chapters = []
|
|
chapter_counter = 1
|
|
|
|
all_chapters.append({"timestamp": 0, "name": f"Chapter {chapter_counter}"})
|
|
chapter_counter += 1
|
|
|
|
for idx, special in enumerate(special_chapters):
|
|
all_chapters.append({"timestamp": special["start"], "name": special["name"]})
|
|
|
|
should_add_chapter_after = False
|
|
|
|
if special["end"] > special["start"]:
|
|
if idx + 1 < len(special_chapters):
|
|
next_special = special_chapters[idx + 1]
|
|
if next_special["start"] - special["end"] > 2000:
|
|
should_add_chapter_after = True
|
|
else:
|
|
should_add_chapter_after = True
|
|
|
|
if should_add_chapter_after:
|
|
all_chapters.append({"timestamp": special["end"], "name": f"Chapter {chapter_counter}"})
|
|
chapter_counter += 1
|
|
|
|
for chapter in all_chapters:
|
|
try:
|
|
chapters.add(
|
|
Chapter(
|
|
timestamp=chapter["timestamp"],
|
|
name=chapter["name"],
|
|
)
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
return chapters
|
|
|
|
def search(self) -> Generator[SearchResult, None, None]:
|
|
"""Search for content on Crunchyroll."""
|
|
try:
|
|
response = self.session.get(
|
|
url=self.config["endpoints"]["search"],
|
|
params={
|
|
"q": self.title,
|
|
"type": "series",
|
|
"start": 0,
|
|
"n": 20,
|
|
"locale": self.config["params"]["locale"],
|
|
},
|
|
)
|
|
|
|
if response.status_code != 200:
|
|
raise ValueError(f"Search request failed with status {response.status_code}")
|
|
|
|
search_data = response.json()
|
|
for result_group in search_data.get("data", []):
|
|
for series in result_group.get("items", []):
|
|
series_id = series.get("id")
|
|
|
|
if not series_id:
|
|
continue
|
|
|
|
title = series.get("title", "Unknown")
|
|
description = series.get("description", "")
|
|
year = series.get("series_launch_year")
|
|
if len(description) > 300:
|
|
description = description[:300] + "..."
|
|
|
|
url = f"https://www.crunchyroll.com/series/{series_id}"
|
|
label = f"SERIES ({year})" if year else "SERIES"
|
|
|
|
yield SearchResult(
|
|
id_=series_id,
|
|
title=title,
|
|
label=label,
|
|
description=description,
|
|
url=url,
|
|
)
|
|
|
|
except Exception as e:
|
|
raise ValueError(f"Search failed: {e}")
|
|
|
|
def get_account_id(self) -> str:
|
|
"""Fetch and return the account ID."""
|
|
response = self.session.get(url=self.config["endpoints"]["account_me"], headers=self.auth_header)
|
|
|
|
if response.status_code != 200:
|
|
raise ValueError(f"Failed to get account info: {response.status_code} - {response.text}")
|
|
|
|
data = response.json()
|
|
return data["account_id"]
|
|
|
|
def close_stream(self, episode_id: str, token: str) -> None:
|
|
"""Close an active playback stream to free up concurrent stream slots."""
|
|
should_remove = False
|
|
try:
|
|
response = self.session.delete(
|
|
url=self.config["endpoints"]["playback_delete"].format(episode_id=episode_id, token=token),
|
|
headers=self.auth_header,
|
|
)
|
|
if response.status_code in (200, 204, 403):
|
|
should_remove = True
|
|
else:
|
|
self.log.warning(
|
|
f"Failed to close stream for {episode_id} (status {response.status_code}): {response.text[:200]}"
|
|
)
|
|
except Exception as e:
|
|
self.log.warning(f"Error closing stream for {episode_id}: {e}")
|
|
finally:
|
|
if should_remove and (episode_id, token) in self.ACTIVE_STREAMS:
|
|
self.ACTIVE_STREAMS.remove((episode_id, token))
|
|
|
|
def get_active_sessions(self) -> list:
|
|
"""Get all active streaming sessions for the account."""
|
|
try:
|
|
response = self.session.get(
|
|
url=self.config["endpoints"]["playback_sessions"],
|
|
headers=self.auth_header,
|
|
)
|
|
if response.status_code == 200:
|
|
data = response.json()
|
|
items = data.get("items", [])
|
|
return items
|
|
else:
|
|
self.log.warning(f"Failed to get active sessions (status {response.status_code})")
|
|
return []
|
|
except Exception as e:
|
|
self.log.warning(f"Error getting active sessions: {e}")
|
|
return []
|
|
|
|
def clear_all_sessions(self) -> int:
|
|
"""
|
|
Clear all active streaming sessions created during this or previous runs.
|
|
|
|
Tries multiple approaches to ensure all streams are closed:
|
|
1. Clear tracked streams with known tokens
|
|
2. Query active sessions API and close all found streams
|
|
3. Try alternate token formats if needed
|
|
"""
|
|
cleared = 0
|
|
|
|
if self.ACTIVE_STREAMS:
|
|
streams_to_close = self.ACTIVE_STREAMS[:]
|
|
for episode_id, playback_token in streams_to_close:
|
|
try:
|
|
self.close_stream(episode_id, playback_token)
|
|
cleared += 1
|
|
except Exception:
|
|
if (episode_id, playback_token) in self.ACTIVE_STREAMS:
|
|
self.ACTIVE_STREAMS.remove((episode_id, playback_token))
|
|
|
|
sessions = self.get_active_sessions()
|
|
if sessions:
|
|
for session_data in sessions:
|
|
content_id = session_data.get("contentId")
|
|
session_token = session_data.get("token")
|
|
|
|
if content_id and session_token:
|
|
tokens_to_try = (
|
|
["11-" + session_token[3:], session_token]
|
|
if session_token.startswith("08-")
|
|
else [session_token]
|
|
)
|
|
|
|
session_closed = False
|
|
for token in tokens_to_try:
|
|
try:
|
|
response = self.session.delete(
|
|
url=self.config["endpoints"]["playback_delete"].format(
|
|
episode_id=content_id, token=token
|
|
),
|
|
headers=self.auth_header,
|
|
)
|
|
if response.status_code in (200, 204):
|
|
cleared += 1
|
|
session_closed = True
|
|
break
|
|
elif response.status_code == 403:
|
|
session_closed = True
|
|
break
|
|
except Exception:
|
|
pass
|
|
|
|
if not session_closed:
|
|
self.log.warning(f"Unable to close session {content_id} with any token format")
|
|
|
|
return cleared
|
|
|
|
def get_playback_data(
|
|
self,
|
|
episode_id: str,
|
|
track_stream: bool = True,
|
|
endpoint_key: str = "playback",
|
|
audio_locale: Optional[str] = None,
|
|
) -> dict:
|
|
"""
|
|
Get playback data for an episode with automatic retry on stream limits.
|
|
|
|
Args:
|
|
episode_id: The episode ID to get playback data for
|
|
track_stream: Whether to track this stream in active_streams (False for temporary streams)
|
|
endpoint_key: Which endpoint to use ('playback' or 'playback_download')
|
|
audio_locale: Preferred audio locale (e.g. 'en-US', 'ja-JP')
|
|
|
|
Returns:
|
|
dict: The playback response data
|
|
|
|
Raises:
|
|
ValueError: If playback request fails after retry
|
|
"""
|
|
self.ensure_authenticated()
|
|
|
|
params: dict[str, str] = {"queue": "false"}
|
|
if audio_locale:
|
|
params["audio"] = audio_locale
|
|
|
|
max_retries = 2
|
|
for attempt in range(max_retries + 1):
|
|
http_response = self.session.get(
|
|
url=self.config["endpoints"][endpoint_key].format(episode_id=episode_id),
|
|
params=params,
|
|
)
|
|
|
|
try:
|
|
response = http_response.json()
|
|
except Exception as e:
|
|
raise ValueError(f"Playback: failed to parse JSON (episode_id={episode_id}): {e}")
|
|
|
|
if "error" in response:
|
|
error_code = response.get("code", "")
|
|
error_msg = response.get("message", response.get("error", "Unknown error"))
|
|
|
|
if error_code == "TOO_MANY_ACTIVE_STREAMS" and attempt < max_retries:
|
|
self.log.warning(f"Hit stream limit: {error_msg}")
|
|
cleared = self.clear_all_sessions()
|
|
|
|
if cleared == 0 and attempt == 0:
|
|
wait_time = 30
|
|
self.log.warning(
|
|
f"Found orphaned sessions from previous run. Waiting {wait_time}s for them to expire..."
|
|
)
|
|
time.sleep(wait_time)
|
|
|
|
continue
|
|
|
|
raise ValueError(f"Could not get playback info for episode: {episode_id} - {error_msg}")
|
|
|
|
playback_token = response.get("token")
|
|
if playback_token and track_stream:
|
|
self.ACTIVE_STREAMS.append((episode_id, playback_token))
|
|
|
|
return response
|
|
|
|
raise ValueError(f"Failed to get playback data for episode: {episode_id}")
|
|
|
|
def parse_series_id(self, title_input: str) -> str:
|
|
"""Parse series ID from URL or direct ID input."""
|
|
match = re.match(self.TITLE_RE, title_input, re.IGNORECASE)
|
|
if not match:
|
|
raise ValueError(f"Could not parse series ID from: {title_input}")
|
|
series_id = match.group("id")
|
|
return series_id
|
|
|
|
def on_track_downloaded(self, track: AnyTrack) -> None:
|
|
"""
|
|
Called when a Track has finished downloading.
|
|
|
|
Parameters:
|
|
track: The Track object that was downloaded.
|
|
"""
|
|
if isinstance(track,Subtitle) and not self.skip_dl:
|
|
|
|
if track.path.suffix == ".vtt" and track.path.name:
|
|
|
|
with open(track.path.__str__(), 'rb') as fd:
|
|
data = fd.read()
|
|
converter=WebVTTConverter()
|
|
if isinstance(data, bytes):
|
|
srt = converter.from_bytes(data)
|
|
else:
|
|
srt = converter.from_string(data)
|
|
fixer = CommonIssuesFixer()
|
|
fixed, status = fixer.from_srt(srt)
|
|
if status and fixed:
|
|
srt = fixed
|
|
srt.save(track.path)
|