yt_dlp/extractor/funimation.py

   1 import random
   2 import re
   3 import string
   4
   5 from .common import InfoExtractor
   6 from ..compat import compat_HTTPError
   7 from ..utils import (
   8     determine_ext,
   9     int_or_none,
  10     join_nonempty,
  11     js_to_json,
  12     orderedSet,
  13     qualities,
  14     str_or_none,
  15     traverse_obj,
  16     try_get,
  17     urlencode_postdata,
  18     ExtractorError,
  19 )
  20
  21
  22 class FunimationBaseIE(InfoExtractor):
  23     _NETRC_MACHINE = 'funimation'
  24     _REGION = None
  25     _TOKEN = None
  26
  27     def _get_region(self):
  28         region_cookie = self._get_cookies('https://www.funimation.com').get('region')
  29         region = region_cookie.value if region_cookie else self.get_param('geo_bypass_country')
  30         return region or traverse_obj(
  31             self._download_json(
  32                 'https://geo-service.prd.funimationsvc.com/geo/v1/region/check', None, fatal=False,
  33                 note='Checking geo-location', errnote='Unable to fetch geo-location information'),
  34             'region') or 'US'
  35
  36     def _perform_login(self, username, password):
  37         if self._TOKEN:
  38             return
  39         try:
  40             data = self._download_json(
  41                 'https://prod-api-funimationnow.dadcdigital.com/api/auth/login/',
  42                 None, 'Logging in', data=urlencode_postdata({
  43                     'username': username,
  44                     'password': password,
  45                 }))
  46             FunimationBaseIE._TOKEN = data['token']
  47         except ExtractorError as e:
  48             if isinstance(e.cause, compat_HTTPError) and e.cause.code == 401:
  49                 error = self._parse_json(e.cause.read().decode(), None)['error']
  50                 raise ExtractorError(error, expected=True)
  51             raise
  52
  53
  54 class FunimationPageIE(FunimationBaseIE):
  55     IE_NAME = 'funimation:page'
  56     _VALID_URL = r'https?://(?:www\.)?funimation(?:\.com|now\.uk)/(?:(?P<lang>[^/]+)/)?(?:shows|v)/(?P<show>[^/]+)/(?P<episode>[^/?#&]+)'
  57
  58     _TESTS = [{
  59         'url': 'https://www.funimation.com/shows/attack-on-titan-junior-high/broadcast-dub-preview/',
  60         'info_dict': {
  61             'id': '210050',
  62             'ext': 'mp4',
  63             'title': 'Broadcast Dub Preview',
  64             # Other metadata is tested in FunimationIE
  65         },
  66         'params': {
  67             'skip_download': 'm3u8',
  68         },
  69         'add_ie': ['Funimation'],
  70     }, {
  71         # Not available in US
  72         'url': 'https://www.funimation.com/shows/hacksign/role-play/',
  73         'only_matching': True,
  74     }, {
  75         # with lang code
  76         'url': 'https://www.funimation.com/en/shows/hacksign/role-play/',
  77         'only_matching': True,
  78     }, {
  79         'url': 'https://www.funimationnow.uk/shows/puzzle-dragons-x/drop-impact/simulcast/',
  80         'only_matching': True,
  81     }, {
  82         'url': 'https://www.funimation.com/v/a-certain-scientific-railgun/super-powered-level-5',
  83         'only_matching': True,
  84     }]
  85
  86     def _real_initialize(self):
  87         if not self._REGION:
  88             FunimationBaseIE._REGION = self._get_region()
  89
  90     def _real_extract(self, url):
  91         locale, show, episode = self._match_valid_url(url).group('lang', 'show', 'episode')
  92
  93         video_id = traverse_obj(self._download_json(
  94             f'https://title-api.prd.funimationsvc.com/v1/shows/{show}/episodes/{episode}',
  95             f'{show}_{episode}', query={
  96                 'deviceType': 'web',
  97                 'region': self._REGION,
  98                 'locale': locale or 'en'
  99             }), ('videoList', ..., 'id'), get_all=False)
 100
 101         return self.url_result(f'https://www.funimation.com/player/{video_id}', FunimationIE.ie_key(), video_id)
 102
 103
 104 class FunimationIE(FunimationBaseIE):
 105     _VALID_URL = r'https?://(?:www\.)?funimation\.com/player/(?P<id>\d+)'
 106
 107     _TESTS = [{
 108         'url': 'https://www.funimation.com/player/210051',
 109         'info_dict': {
 110             'id': '210050',
 111             'display_id': 'broadcast-dub-preview',
 112             'ext': 'mp4',
 113             'title': 'Broadcast Dub Preview',
 114             'thumbnail': r're:https?://.*\.(?:jpg|png)',
 115             'episode': 'Broadcast Dub Preview',
 116             'episode_id': '210050',
 117             'season': 'Extras',
 118             'season_id': '166038',
 119             'season_number': 99,
 120             'series': 'Attack on Titan: Junior High',
 121             'description': '',
 122             'duration': 155,
 123         },
 124         'params': {
 125             'skip_download': 'm3u8',
 126         },
 127     }, {
 128         'note': 'player_id should be extracted with the relevent compat-opt',
 129         'url': 'https://www.funimation.com/player/210051',
 130         'info_dict': {
 131             'id': '210051',
 132             'display_id': 'broadcast-dub-preview',
 133             'ext': 'mp4',
 134             'title': 'Broadcast Dub Preview',
 135             'thumbnail': r're:https?://.*\.(?:jpg|png)',
 136             'episode': 'Broadcast Dub Preview',
 137             'episode_id': '210050',
 138             'season': 'Extras',
 139             'season_id': '166038',
 140             'season_number': 99,
 141             'series': 'Attack on Titan: Junior High',
 142             'description': '',
 143             'duration': 155,
 144         },
 145         'params': {
 146             'skip_download': 'm3u8',
 147             'compat_opts': ['seperate-video-versions'],
 148         },
 149     }]
 150
 151     @staticmethod
 152     def _get_experiences(episode):
 153         for lang, lang_data in episode.get('languages', {}).items():
 154             for video_data in lang_data.values():
 155                 for version, f in video_data.items():
 156                     yield lang, version.title(), f
 157
 158     def _get_episode(self, webpage, experience_id=None, episode_id=None, fatal=True):
 159         ''' Extract the episode, season and show objects given either episode/experience id '''
 160         show = self._parse_json(
 161             self._search_regex(
 162                 r'show\s*=\s*({.+?})\s*;', webpage, 'show data', fatal=fatal),
 163             experience_id, transform_source=js_to_json, fatal=fatal) or []
 164         for season in show.get('seasons', []):
 165             for episode in season.get('episodes', []):
 166                 if episode_id is not None:
 167                     if str(episode.get('episodePk')) == episode_id:
 168                         return episode, season, show
 169                     continue
 170                 for _, _, f in self._get_experiences(episode):
 171                     if f.get('experienceId') == experience_id:
 172                         return episode, season, show
 173         if fatal:
 174             raise ExtractorError('Unable to find episode information')
 175         else:
 176             self.report_warning('Unable to find episode information')
 177         return {}, {}, {}
 178
 179     def _real_extract(self, url):
 180         initial_experience_id = self._match_id(url)
 181         webpage = self._download_webpage(
 182             url, initial_experience_id, note=f'Downloading player webpage for {initial_experience_id}')
 183         episode, season, show = self._get_episode(webpage, experience_id=int(initial_experience_id))
 184         episode_id = str(episode['episodePk'])
 185         display_id = episode.get('slug') or episode_id
 186
 187         formats, subtitles, thumbnails, duration = [], {}, [], 0
 188         requested_languages, requested_versions = self._configuration_arg('language'), self._configuration_arg('version')
 189         language_preference = qualities((requested_languages or [''])[::-1])
 190         source_preference = qualities((requested_versions or ['uncut', 'simulcast'])[::-1])
 191         only_initial_experience = 'seperate-video-versions' in self.get_param('compat_opts', [])
 192
 193         for lang, version, fmt in self._get_experiences(episode):
 194             experience_id = str(fmt['experienceId'])
 195             if (only_initial_experience and experience_id != initial_experience_id
 196                     or requested_languages and lang.lower() not in requested_languages
 197                     or requested_versions and version.lower() not in requested_versions):
 198                 continue
 199             thumbnails.append({'url': fmt.get('poster')})
 200             duration = max(duration, fmt.get('duration', 0))
 201             format_name = '%s %s (%s)' % (version, lang, experience_id)
 202             self.extract_subtitles(
 203                 subtitles, experience_id, display_id=display_id, format_name=format_name,
 204                 episode=episode if experience_id == initial_experience_id else episode_id)
 205
 206             headers = {}
 207             if self._TOKEN:
 208                 headers['Authorization'] = 'Token %s' % self._TOKEN
 209             page = self._download_json(
 210                 'https://www.funimation.com/api/showexperience/%s/' % experience_id,
 211                 display_id, headers=headers, expected_status=403, query={
 212                     'pinst_id': ''.join([random.choice(string.digits + string.ascii_letters) for _ in range(8)]),
 213                 }, note=f'Downloading {format_name} JSON')
 214             sources = page.get('items') or []
 215             if not sources:
 216                 error = try_get(page, lambda x: x['errors'][0], dict)
 217                 if error:
 218                     self.report_warning('%s said: Error %s - %s' % (
 219                         self.IE_NAME, error.get('code'), error.get('detail') or error.get('title')))
 220                 else:
 221                     self.report_warning('No sources found for format')
 222
 223             current_formats = []
 224             for source in sources:
 225                 source_url = source.get('src')
 226                 source_type = source.get('videoType') or determine_ext(source_url)
 227                 if source_type == 'm3u8':
 228                     current_formats.extend(self._extract_m3u8_formats(
 229                         source_url, display_id, 'mp4', m3u8_id='%s-%s' % (experience_id, 'hls'), fatal=False,
 230                         note=f'Downloading {format_name} m3u8 information'))
 231                 else:
 232                     current_formats.append({
 233                         'format_id': '%s-%s' % (experience_id, source_type),
 234                         'url': source_url,
 235                     })
 236                 for f in current_formats:
 237                     # TODO: Convert language to code
 238                     f.update({
 239                         'language': lang,
 240                         'format_note': version,
 241                         'source_preference': source_preference(version.lower()),
 242                         'language_preference': language_preference(lang.lower()),
 243                     })
 244                 formats.extend(current_formats)
 245         self._remove_duplicate_formats(formats)
 246         self._sort_formats(formats, ('lang', 'source'))
 247
 248         return {
 249             'id': initial_experience_id if only_initial_experience else episode_id,
 250             'display_id': display_id,
 251             'duration': duration,
 252             'title': episode['episodeTitle'],
 253             'description': episode.get('episodeSummary'),
 254             'episode': episode.get('episodeTitle'),
 255             'episode_number': int_or_none(episode.get('episodeId')),
 256             'episode_id': episode_id,
 257             'season': season.get('seasonTitle'),
 258             'season_number': int_or_none(season.get('seasonId')),
 259             'season_id': str_or_none(season.get('seasonPk')),
 260             'series': show.get('showTitle'),
 261             'formats': formats,
 262             'thumbnails': thumbnails,
 263             'subtitles': subtitles,
 264         }
 265
 266     def _get_subtitles(self, subtitles, experience_id, episode, display_id, format_name):
 267         if isinstance(episode, str):
 268             webpage = self._download_webpage(
 269                 f'https://www.funimation.com/player/{experience_id}/', display_id,
 270                 fatal=False, note=f'Downloading player webpage for {format_name}')
 271             episode, _, _ = self._get_episode(webpage, episode_id=episode, fatal=False)
 272
 273         for _, version, f in self._get_experiences(episode):
 274             for source in f.get('sources'):
 275                 for text_track in source.get('textTracks'):
 276                     if not text_track.get('src'):
 277                         continue
 278                     sub_type = text_track.get('type').upper()
 279                     sub_type = sub_type if sub_type != 'FULL' else None
 280                     current_sub = {
 281                         'url': text_track['src'],
 282                         'name': join_nonempty(version, text_track.get('label'), sub_type, delim=' ')
 283                     }
 284                     lang = join_nonempty(text_track.get('language', 'und'),
 285                                          version if version != 'Simulcast' else None,
 286                                          sub_type, delim='_')
 287                     if current_sub not in subtitles.get(lang, []):
 288                         subtitles.setdefault(lang, []).append(current_sub)
 289         return subtitles
 290
 291
 292 class FunimationShowIE(FunimationBaseIE):
 293     IE_NAME = 'funimation:show'
 294     _VALID_URL = r'(?P<url>https?://(?:www\.)?funimation(?:\.com|now\.uk)/(?P<locale>[^/]+)?/?shows/(?P<id>[^/?#&]+))/?(?:[?#]|$)'
 295
 296     _TESTS = [{
 297         'url': 'https://www.funimation.com/en/shows/sk8-the-infinity',
 298         'info_dict': {
 299             'id': 1315000,
 300             'title': 'SK8 the Infinity'
 301         },
 302         'playlist_count': 13,
 303         'params': {
 304             'skip_download': True,
 305         },
 306     }, {
 307         # without lang code
 308         'url': 'https://www.funimation.com/shows/ouran-high-school-host-club/',
 309         'info_dict': {
 310             'id': 39643,
 311             'title': 'Ouran High School Host Club'
 312         },
 313         'playlist_count': 26,
 314         'params': {
 315             'skip_download': True,
 316         },
 317     }]
 318
 319     def _real_initialize(self):
 320         if not self._REGION:
 321             FunimationBaseIE._REGION = self._get_region()
 322
 323     def _real_extract(self, url):
 324         base_url, locale, display_id = self._match_valid_url(url).groups()
 325
 326         show_info = self._download_json(
 327             'https://title-api.prd.funimationsvc.com/v2/shows/%s?region=%s&deviceType=web&locale=%s'
 328             % (display_id, self._REGION, locale or 'en'), display_id)
 329         items_info = self._download_json(
 330             'https://prod-api-funimationnow.dadcdigital.com/api/funimation/episodes/?limit=99999&title_id=%s'
 331             % show_info.get('id'), display_id)
 332
 333         vod_items = traverse_obj(items_info, ('items', ..., lambda k, _: re.match(r'(?i)mostRecent[AS]vod', k), 'item'))
 334
 335         return {
 336             '_type': 'playlist',
 337             'id': show_info['id'],
 338             'title': show_info['name'],
 339             'entries': orderedSet(
 340                 self.url_result(
 341                     '%s/%s' % (base_url, vod_item.get('episodeSlug')), FunimationPageIE.ie_key(),
 342                     vod_item.get('episodeId'), vod_item.get('episodeName'))
 343                 for vod_item in sorted(vod_items, key=lambda x: x.get('episodeOrder', -1))),
 344         }