@tushar-br/desktop 1.0.282 → 1.0.283

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/yt_dlp/extractor/frontendmasters.py

@@ -0,0 +1,252 @@
+import re
+
+from .common import InfoExtractor
+from ..compat import (
+    compat_str,
+    compat_urlparse,
+)
+from ..utils import (
+    ExtractorError,
+    parse_duration,
+    url_or_none,
+    urlencode_postdata,
+)
+
+
+class FrontendMastersBaseIE(InfoExtractor):
+    _API_BASE = 'https://api.frontendmasters.com/v1/kabuki'
+    _LOGIN_URL = 'https://frontendmasters.com/login/'
+
+    _NETRC_MACHINE = 'frontendmasters'
+
+    _QUALITIES = {
+        'low': {'width': 480, 'height': 360},
+        'mid': {'width': 1280, 'height': 720},
+        'high': {'width': 1920, 'height': 1080}
+    }
+
+    def _perform_login(self, username, password):
+        login_page = self._download_webpage(
+            self._LOGIN_URL, None, 'Downloading login page')
+
+        login_form = self._hidden_inputs(login_page)
+
+        login_form.update({
+            'username': username,
+            'password': password
+        })
+
+        post_url = self._search_regex(
+            r'<form[^>]+action=(["\'])(?P<url>.+?)\1', login_page,
+            'post_url', default=self._LOGIN_URL, group='url')
+
+        if not post_url.startswith('http'):
+            post_url = compat_urlparse.urljoin(self._LOGIN_URL, post_url)
+
+        response = self._download_webpage(
+            post_url, None, 'Logging in', data=urlencode_postdata(login_form),
+            headers={'Content-Type': 'application/x-www-form-urlencoded'})
+
+        # Successful login
+        if any(p in response for p in (
+                'wp-login.php?action=logout', '>Logout')):
+            return
+
+        error = self._html_search_regex(
+            r'class=(["\'])(?:(?!\1).)*\bMessageAlert\b(?:(?!\1).)*\1[^>]*>(?P<error>[^<]+)<',
+            response, 'error message', default=None, group='error')
+        if error:
+            raise ExtractorError('Unable to login: %s' % error, expected=True)
+        raise ExtractorError('Unable to log in')
+
+
+class FrontendMastersPageBaseIE(FrontendMastersBaseIE):
+    def _download_course(self, course_name, url):
+        return self._download_json(
+            '%s/courses/%s' % (self._API_BASE, course_name), course_name,
+            'Downloading course JSON', headers={'Referer': url})
+
+    @staticmethod
+    def _extract_chapters(course):
+        chapters = []
+        lesson_elements = course.get('lessonElements')
+        if isinstance(lesson_elements, list):
+            chapters = [url_or_none(e) for e in lesson_elements if url_or_none(e)]
+        return chapters
+
+    @staticmethod
+    def _extract_lesson(chapters, lesson_id, lesson):
+        title = lesson.get('title') or lesson_id
+        display_id = lesson.get('slug')
+        description = lesson.get('description')
+        thumbnail = lesson.get('thumbnail')
+
+        chapter_number = None
+        index = lesson.get('index')
+        element_index = lesson.get('elementIndex')
+        if (isinstance(index, int) and isinstance(element_index, int)
+                and index < element_index):
+            chapter_number = element_index - index
+        chapter = (chapters[chapter_number - 1]
+                   if chapter_number - 1 < len(chapters) else None)
+
+        duration = None
+        timestamp = lesson.get('timestamp')
+        if isinstance(timestamp, compat_str):
+            mobj = re.search(
+                r'(?P<start>\d{1,2}:\d{1,2}:\d{1,2})\s*-(?P<end>\s*\d{1,2}:\d{1,2}:\d{1,2})',
+                timestamp)
+            if mobj:
+                duration = parse_duration(mobj.group('end')) - parse_duration(
+                    mobj.group('start'))
+
+        return {
+            '_type': 'url_transparent',
+            'url': 'frontendmasters:%s' % lesson_id,
+            'ie_key': FrontendMastersIE.ie_key(),
+            'id': lesson_id,
+            'display_id': display_id,
+            'title': title,
+            'description': description,
+            'thumbnail': thumbnail,
+            'duration': duration,
+            'chapter': chapter,
+            'chapter_number': chapter_number,
+        }
+
+
+class FrontendMastersIE(FrontendMastersBaseIE):
+    _VALID_URL = r'(?:frontendmasters:|https?://api\.frontendmasters\.com/v\d+/kabuki/video/)(?P<id>[^/]+)'
+    _TESTS = [{
+        'url': 'https://api.frontendmasters.com/v1/kabuki/video/a2qogef6ba',
+        'md5': '7f161159710d6b7016a4f4af6fcb05e2',
+        'info_dict': {
+            'id': 'a2qogef6ba',
+            'ext': 'mp4',
+            'title': 'a2qogef6ba',
+        },
+        'skip': 'Requires FrontendMasters account credentials',
+    }, {
+        'url': 'frontendmasters:a2qogef6ba',
+        'only_matching': True,
+    }]
+
+    def _real_extract(self, url):
+        lesson_id = self._match_id(url)
+
+        source_url = '%s/video/%s/source' % (self._API_BASE, lesson_id)
+
+        formats = []
+        for ext in ('webm', 'mp4'):
+            for quality in ('low', 'mid', 'high'):
+                resolution = self._QUALITIES[quality].copy()
+                format_id = '%s-%s' % (ext, quality)
+                format_url = self._download_json(
+                    source_url, lesson_id,
+                    'Downloading %s source JSON' % format_id, query={
+                        'f': ext,
+                        'r': resolution['height'],
+                    }, headers={
+                        'Referer': url,
+                    }, fatal=False)['url']
+
+                if not format_url:
+                    continue
+
+                f = resolution.copy()
+                f.update({
+                    'url': format_url,
+                    'ext': ext,
+                    'format_id': format_id,
+                })
+                formats.append(f)
+
+        subtitles = {
+            'en': [{
+                'url': '%s/transcripts/%s.vtt' % (self._API_BASE, lesson_id),
+            }]
+        }
+
+        return {
+            'id': lesson_id,
+            'title': lesson_id,
+            'formats': formats,
+            'subtitles': subtitles
+        }
+
+
+class FrontendMastersLessonIE(FrontendMastersPageBaseIE):
+    _VALID_URL = r'https?://(?:www\.)?frontendmasters\.com/courses/(?P<course_name>[^/]+)/(?P<lesson_name>[^/]+)'
+    _TEST = {
+        'url': 'https://frontendmasters.com/courses/web-development/tools',
+        'info_dict': {
+            'id': 'a2qogef6ba',
+            'display_id': 'tools',
+            'ext': 'mp4',
+            'title': 'Tools',
+            'description': 'md5:82c1ea6472e88ed5acd1829fe992e4f7',
+            'thumbnail': r're:^https?://.*\.jpg$',
+            'chapter': 'Introduction',
+            'chapter_number': 1,
+        },
+        'params': {
+            'skip_download': True,
+        },
+        'skip': 'Requires FrontendMasters account credentials',
+    }
+
+    def _real_extract(self, url):
+        mobj = self._match_valid_url(url)
+        course_name, lesson_name = mobj.group('course_name', 'lesson_name')
+
+        course = self._download_course(course_name, url)
+
+        lesson_id, lesson = next(
+            (video_id, data)
+            for video_id, data in course['lessonData'].items()
+            if data.get('slug') == lesson_name)
+
+        chapters = self._extract_chapters(course)
+        return self._extract_lesson(chapters, lesson_id, lesson)
+
+
+class FrontendMastersCourseIE(FrontendMastersPageBaseIE):
+    _VALID_URL = r'https?://(?:www\.)?frontendmasters\.com/courses/(?P<id>[^/]+)'
+    _TEST = {
+        'url': 'https://frontendmasters.com/courses/web-development/',
+        'info_dict': {
+            'id': 'web-development',
+            'title': 'Introduction to Web Development',
+            'description': 'md5:9317e6e842098bf725d62360e52d49a6',
+        },
+        'playlist_count': 81,
+        'skip': 'Requires FrontendMasters account credentials',
+    }
+
+    @classmethod
+    def suitable(cls, url):
+        return False if FrontendMastersLessonIE.suitable(url) else super(
+            FrontendMastersBaseIE, cls).suitable(url)
+
+    def _real_extract(self, url):
+        course_name = self._match_id(url)
+
+        course = self._download_course(course_name, url)
+
+        chapters = self._extract_chapters(course)
+
+        lessons = sorted(
+            course['lessonData'].values(), key=lambda data: data['index'])
+
+        entries = []
+        for lesson in lessons:
+            lesson_name = lesson.get('slug')
+            lesson_id = lesson.get('hash') or lesson.get('statsId')
+            if not lesson_id or not lesson_name:
+                continue
+            entries.append(self._extract_lesson(chapters, lesson_id, lesson))
+
+        title = course.get('title')
+        description = course.get('description')
+
+        return self.playlist_result(entries, course_name, title, description)

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/yt_dlp/extractor/fujitv.py

@@ -0,0 +1,71 @@
+from .common import InfoExtractor
+from ..networking import HEADRequest
+
+
+class FujiTVFODPlus7IE(InfoExtractor):
+    _VALID_URL = r'https?://fod\.fujitv\.co\.jp/title/(?P<sid>[0-9a-z]{4})/(?P<id>[0-9a-z]+)'
+    _BASE_URL = 'https://i.fod.fujitv.co.jp/'
+    _BITRATE_MAP = {
+        300: (320, 180),
+        800: (640, 360),
+        1200: (1280, 720),
+        2000: (1280, 720),
+        4000: (1920, 1080),
+    }
+
+    _TESTS = [{
+        'url': 'https://fod.fujitv.co.jp/title/5d40/5d40110076',
+        'info_dict': {
+            'id': '5d40110076',
+            'ext': 'ts',
+            'title': '#1318 『まる子、まぼろしの洋館を見る』の巻',
+            'series': 'ちびまる子ちゃん',
+            'series_id': '5d40',
+            'description': 'md5:b3f51dbfdda162ac4f789e0ff4d65750',
+            'thumbnail': 'https://i.fod.fujitv.co.jp/img/program/5d40/episode/5d40110076_a.jpg',
+        },
+    }, {
+        'url': 'https://fod.fujitv.co.jp/title/5d40/5d40810083',
+        'info_dict': {
+            'id': '5d40810083',
+            'ext': 'ts',
+            'title': '#1324 『まる子とオニの子』の巻／『結成！2月をムダにしない会』の巻',
+            'description': 'md5:3972d900b896adc8ab1849e310507efa',
+            'series': 'ちびまる子ちゃん',
+            'series_id': '5d40',
+            'thumbnail': 'https://i.fod.fujitv.co.jp/img/program/5d40/episode/5d40810083_a.jpg'},
+        'skip': 'Video available only in one week'
+    }]
+
+    def _real_extract(self, url):
+        series_id, video_id = self._match_valid_url(url).groups()
+        self._request_webpage(HEADRequest(url), video_id)
+        json_info = {}
+        token = self._get_cookies(url).get('CT')
+        if token:
+            json_info = self._download_json('https://fod-sp.fujitv.co.jp/apps/api/episode/detail/?ep_id=%s&is_premium=false' % video_id, video_id, headers={'x-authorization': f'Bearer {token.value}'}, fatal=False)
+        else:
+            self.report_warning(f'The token cookie is needed to extract video metadata. {self._login_hint("cookies")}')
+        formats, subtitles = [], {}
+        src_json = self._download_json(f'{self._BASE_URL}abrjson_v2/tv_android/{video_id}', video_id)
+        for src in src_json['video_selector']:
+            if not src.get('url'):
+                continue
+            fmt, subs = self._extract_m3u8_formats_and_subtitles(src['url'], video_id, 'ts')
+            for f in fmt:
+                f.update(dict(zip(('height', 'width'),
+                                  self._BITRATE_MAP.get(f.get('tbr'), ()))))
+            formats.extend(fmt)
+            subtitles = self._merge_subtitles(subtitles, subs)
+
+        return {
+            'id': video_id,
+            'title': json_info.get('ep_title'),
+            'series': json_info.get('lu_title'),
+            'series_id': series_id,
+            'description': json_info.get('ep_description'),
+            'formats': formats,
+            'subtitles': subtitles,
+            'thumbnail': f'{self._BASE_URL}img/program/{series_id}/episode/{video_id}_a.jpg',
+            '_format_sort_fields': ('tbr', )
+        }

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/yt_dlp/extractor/funimation.py

@@ -0,0 +1,349 @@
+import random
+import re
+import string
+
+from .common import InfoExtractor
+from ..networking.exceptions import HTTPError
+from ..utils import (
+    ExtractorError,
+    determine_ext,
+    int_or_none,
+    join_nonempty,
+    js_to_json,
+    make_archive_id,
+    orderedSet,
+    qualities,
+    str_or_none,
+    traverse_obj,
+    try_get,
+    urlencode_postdata,
+)
+
+
+class FunimationBaseIE(InfoExtractor):
+    _NETRC_MACHINE = 'funimation'
+    _REGION = None
+    _TOKEN = None
+
+    def _get_region(self):
+        region_cookie = self._get_cookies('https://www.funimation.com').get('region')
+        region = region_cookie.value if region_cookie else self.get_param('geo_bypass_country')
+        return region or traverse_obj(
+            self._download_json(
+                'https://geo-service.prd.funimationsvc.com/geo/v1/region/check', None, fatal=False,
+                note='Checking geo-location', errnote='Unable to fetch geo-location information'),
+            'region') or 'US'
+
+    def _perform_login(self, username, password):
+        if self._TOKEN:
+            return
+        try:
+            data = self._download_json(
+                'https://prod-api-funimationnow.dadcdigital.com/api/auth/login/',
+                None, 'Logging in', data=urlencode_postdata({
+                    'username': username,
+                    'password': password,
+                }))
+            FunimationBaseIE._TOKEN = data['token']
+        except ExtractorError as e:
+            if isinstance(e.cause, HTTPError) and e.cause.status == 401:
+                error = self._parse_json(e.cause.response.read().decode(), None)['error']
+                raise ExtractorError(error, expected=True)
+            raise
+
+
+class FunimationPageIE(FunimationBaseIE):
+    IE_NAME = 'funimation:page'
+    _VALID_URL = r'https?://(?:www\.)?funimation(?:\.com|now\.uk)/(?:(?P<lang>[^/]+)/)?(?:shows|v)/(?P<show>[^/]+)/(?P<episode>[^/?#&]+)'
+
+    _TESTS = [{
+        'url': 'https://www.funimation.com/shows/attack-on-titan-junior-high/broadcast-dub-preview/',
+        'info_dict': {
+            'id': '210050',
+            'ext': 'mp4',
+            'title': 'Broadcast Dub Preview',
+            # Other metadata is tested in FunimationIE
+        },
+        'params': {
+            'skip_download': 'm3u8',
+        },
+        'add_ie': ['Funimation'],
+    }, {
+        # Not available in US
+        'url': 'https://www.funimation.com/shows/hacksign/role-play/',
+        'only_matching': True,
+    }, {
+        # with lang code
+        'url': 'https://www.funimation.com/en/shows/hacksign/role-play/',
+        'only_matching': True,
+    }, {
+        'url': 'https://www.funimationnow.uk/shows/puzzle-dragons-x/drop-impact/simulcast/',
+        'only_matching': True,
+    }, {
+        'url': 'https://www.funimation.com/v/a-certain-scientific-railgun/super-powered-level-5',
+        'only_matching': True,
+    }]
+
+    def _real_initialize(self):
+        if not self._REGION:
+            FunimationBaseIE._REGION = self._get_region()
+
+    def _real_extract(self, url):
+        locale, show, episode = self._match_valid_url(url).group('lang', 'show', 'episode')
+
+        video_id = traverse_obj(self._download_json(
+            f'https://title-api.prd.funimationsvc.com/v1/shows/{show}/episodes/{episode}',
+            f'{show}_{episode}', query={
+                'deviceType': 'web',
+                'region': self._REGION,
+                'locale': locale or 'en'
+            }), ('videoList', ..., 'id'), get_all=False)
+
+        return self.url_result(f'https://www.funimation.com/player/{video_id}', FunimationIE.ie_key(), video_id)
+
+
+class FunimationIE(FunimationBaseIE):
+    _VALID_URL = r'https?://(?:www\.)?funimation\.com/player/(?P<id>\d+)'
+
+    _TESTS = [{
+        'url': 'https://www.funimation.com/player/210051',
+        'info_dict': {
+            'id': '210050',
+            'display_id': 'broadcast-dub-preview',
+            'ext': 'mp4',
+            'title': 'Broadcast Dub Preview',
+            'thumbnail': r're:https?://.*\.(?:jpg|png)',
+            'episode': 'Broadcast Dub Preview',
+            'episode_id': '210050',
+            'season': 'Extras',
+            'season_id': '166038',
+            'season_number': 99,
+            'series': 'Attack on Titan: Junior High',
+            'description': '',
+            'duration': 155,
+        },
+        'params': {
+            'skip_download': 'm3u8',
+        },
+    }, {
+        'note': 'player_id should be extracted with the relevent compat-opt',
+        'url': 'https://www.funimation.com/player/210051',
+        'info_dict': {
+            'id': '210051',
+            'display_id': 'broadcast-dub-preview',
+            'ext': 'mp4',
+            'title': 'Broadcast Dub Preview',
+            'thumbnail': r're:https?://.*\.(?:jpg|png)',
+            'episode': 'Broadcast Dub Preview',
+            'episode_id': '210050',
+            'season': 'Extras',
+            'season_id': '166038',
+            'season_number': 99,
+            'series': 'Attack on Titan: Junior High',
+            'description': '',
+            'duration': 155,
+        },
+        'params': {
+            'skip_download': 'm3u8',
+            'compat_opts': ['seperate-video-versions'],
+        },
+    }]
+
+    @staticmethod
+    def _get_experiences(episode):
+        for lang, lang_data in episode.get('languages', {}).items():
+            for video_data in lang_data.values():
+                for version, f in video_data.items():
+                    yield lang, version.title(), f
+
+    def _get_episode(self, webpage, experience_id=None, episode_id=None, fatal=True):
+        ''' Extract the episode, season and show objects given either episode/experience id '''
+        show = self._parse_json(
+            self._search_regex(
+                r'show\s*=\s*({.+?})\s*;', webpage, 'show data', fatal=fatal),
+            experience_id, transform_source=js_to_json, fatal=fatal) or []
+        for season in show.get('seasons', []):
+            for episode in season.get('episodes', []):
+                if episode_id is not None:
+                    if str(episode.get('episodePk')) == episode_id:
+                        return episode, season, show
+                    continue
+                for _, _, f in self._get_experiences(episode):
+                    if f.get('experienceId') == experience_id:
+                        return episode, season, show
+        if fatal:
+            raise ExtractorError('Unable to find episode information')
+        else:
+            self.report_warning('Unable to find episode information')
+        return {}, {}, {}
+
+    def _real_extract(self, url):
+        initial_experience_id = self._match_id(url)
+        webpage = self._download_webpage(
+            url, initial_experience_id, note=f'Downloading player webpage for {initial_experience_id}')
+        episode, season, show = self._get_episode(webpage, experience_id=int(initial_experience_id))
+        episode_id = str(episode['episodePk'])
+        display_id = episode.get('slug') or episode_id
+
+        formats, subtitles, thumbnails, duration = [], {}, [], 0
+        requested_languages, requested_versions = self._configuration_arg('language'), self._configuration_arg('version')
+        language_preference = qualities((requested_languages or [''])[::-1])
+        source_preference = qualities((requested_versions or ['uncut', 'simulcast'])[::-1])
+        only_initial_experience = 'seperate-video-versions' in self.get_param('compat_opts', [])
+
+        for lang, version, fmt in self._get_experiences(episode):
+            experience_id = str(fmt['experienceId'])
+            if (only_initial_experience and experience_id != initial_experience_id
+                    or requested_languages and lang.lower() not in requested_languages
+                    or requested_versions and version.lower() not in requested_versions):
+                continue
+            thumbnails.append({'url': fmt.get('poster')})
+            duration = max(duration, fmt.get('duration', 0))
+            format_name = '%s %s (%s)' % (version, lang, experience_id)
+            self.extract_subtitles(
+                subtitles, experience_id, display_id=display_id, format_name=format_name,
+                episode=episode if experience_id == initial_experience_id else episode_id)
+
+            headers = {}
+            if self._TOKEN:
+                headers['Authorization'] = 'Token %s' % self._TOKEN
+            page = self._download_json(
+                'https://www.funimation.com/api/showexperience/%s/' % experience_id,
+                display_id, headers=headers, expected_status=403, query={
+                    'pinst_id': ''.join(random.choices(string.digits + string.ascii_letters, k=8)),
+                }, note=f'Downloading {format_name} JSON')
+            sources = page.get('items') or []
+            if not sources:
+                error = try_get(page, lambda x: x['errors'][0], dict)
+                if error:
+                    self.report_warning('%s said: Error %s - %s' % (
+                        self.IE_NAME, error.get('code'), error.get('detail') or error.get('title')))
+                else:
+                    self.report_warning('No sources found for format')
+
+            current_formats = []
+            for source in sources:
+                source_url = source.get('src')
+                source_type = source.get('videoType') or determine_ext(source_url)
+                if source_type == 'm3u8':
+                    current_formats.extend(self._extract_m3u8_formats(
+                        source_url, display_id, 'mp4', m3u8_id='%s-%s' % (experience_id, 'hls'), fatal=False,
+                        note=f'Downloading {format_name} m3u8 information'))
+                else:
+                    current_formats.append({
+                        'format_id': '%s-%s' % (experience_id, source_type),
+                        'url': source_url,
+                    })
+                for f in current_formats:
+                    # TODO: Convert language to code
+                    f.update({
+                        'language': lang,
+                        'format_note': version,
+                        'source_preference': source_preference(version.lower()),
+                        'language_preference': language_preference(lang.lower()),
+                    })
+                formats.extend(current_formats)
+        if not formats and (requested_languages or requested_versions):
+            self.raise_no_formats(
+                'There are no video formats matching the requested languages/versions', expected=True, video_id=display_id)
+        self._remove_duplicate_formats(formats)
+
+        return {
+            'id': episode_id,
+            '_old_archive_ids': [make_archive_id(self, initial_experience_id)],
+            'display_id': display_id,
+            'duration': duration,
+            'title': episode['episodeTitle'],
+            'description': episode.get('episodeSummary'),
+            'episode': episode.get('episodeTitle'),
+            'episode_number': int_or_none(episode.get('episodeId')),
+            'episode_id': episode_id,
+            'season': season.get('seasonTitle'),
+            'season_number': int_or_none(season.get('seasonId')),
+            'season_id': str_or_none(season.get('seasonPk')),
+            'series': show.get('showTitle'),
+            'formats': formats,
+            'thumbnails': thumbnails,
+            'subtitles': subtitles,
+            '_format_sort_fields': ('lang', 'source'),
+        }
+
+    def _get_subtitles(self, subtitles, experience_id, episode, display_id, format_name):
+        if isinstance(episode, str):
+            webpage = self._download_webpage(
+                f'https://www.funimation.com/player/{experience_id}/', display_id,
+                fatal=False, note=f'Downloading player webpage for {format_name}')
+            episode, _, _ = self._get_episode(webpage, episode_id=episode, fatal=False)
+
+        for _, version, f in self._get_experiences(episode):
+            for source in f.get('sources'):
+                for text_track in source.get('textTracks'):
+                    if not text_track.get('src'):
+                        continue
+                    sub_type = text_track.get('type').upper()
+                    sub_type = sub_type if sub_type != 'FULL' else None
+                    current_sub = {
+                        'url': text_track['src'],
+                        'name': join_nonempty(version, text_track.get('label'), sub_type, delim=' ')
+                    }
+                    lang = join_nonempty(text_track.get('language', 'und'),
+                                         version if version != 'Simulcast' else None,
+                                         sub_type, delim='_')
+                    if current_sub not in subtitles.get(lang, []):
+                        subtitles.setdefault(lang, []).append(current_sub)
+        return subtitles
+
+
+class FunimationShowIE(FunimationBaseIE):
+    IE_NAME = 'funimation:show'
+    _VALID_URL = r'(?P<url>https?://(?:www\.)?funimation(?:\.com|now\.uk)/(?P<locale>[^/]+)?/?shows/(?P<id>[^/?#&]+))/?(?:[?#]|$)'
+
+    _TESTS = [{
+        'url': 'https://www.funimation.com/en/shows/sk8-the-infinity',
+        'info_dict': {
+            'id': '1315000',
+            'title': 'SK8 the Infinity'
+        },
+        'playlist_count': 13,
+        'params': {
+            'skip_download': True,
+        },
+    }, {
+        # without lang code
+        'url': 'https://www.funimation.com/shows/ouran-high-school-host-club/',
+        'info_dict': {
+            'id': '39643',
+            'title': 'Ouran High School Host Club'
+        },
+        'playlist_count': 26,
+        'params': {
+            'skip_download': True,
+        },
+    }]
+
+    def _real_initialize(self):
+        if not self._REGION:
+            FunimationBaseIE._REGION = self._get_region()
+
+    def _real_extract(self, url):
+        base_url, locale, display_id = self._match_valid_url(url).groups()
+
+        show_info = self._download_json(
+            'https://title-api.prd.funimationsvc.com/v2/shows/%s?region=%s&deviceType=web&locale=%s'
+            % (display_id, self._REGION, locale or 'en'), display_id)
+        items_info = self._download_json(
+            'https://prod-api-funimationnow.dadcdigital.com/api/funimation/episodes/?limit=99999&title_id=%s'
+            % show_info.get('id'), display_id)
+
+        vod_items = traverse_obj(items_info, ('items', ..., lambda k, _: re.match(r'(?i)mostRecent[AS]vod', k), 'item'))
+
+        return {
+            '_type': 'playlist',
+            'id': str_or_none(show_info['id']),
+            'title': show_info['name'],
+            'entries': orderedSet(
+                self.url_result(
+                    '%s/%s' % (base_url, vod_item.get('episodeSlug')), FunimationPageIE.ie_key(),
+                    vod_item.get('episodeId'), vod_item.get('episodeName'))
+                for vod_item in sorted(vod_items, key=lambda x: x.get('episodeOrder', -1))),
+        }