@tushar-br/desktop 1.0.283 → 1.0.284

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

@@ -1,143 +0,0 @@
-from .common import InfoExtractor
-from ..utils import (
-    clean_html,
-    clean_podcast_url,
-    int_or_none,
-    parse_iso8601,
-)
-
-
-class ACastBaseIE(InfoExtractor):
-    def _extract_episode(self, episode, show_info):
-        title = episode['title']
-        info = {
-            'id': episode['id'],
-            'display_id': episode.get('episodeUrl'),
-            'url': clean_podcast_url(episode['url']),
-            'title': title,
-            'description': clean_html(episode.get('description') or episode.get('summary')),
-            'thumbnail': episode.get('image'),
-            'timestamp': parse_iso8601(episode.get('publishDate')),
-            'duration': int_or_none(episode.get('duration')),
-            'filesize': int_or_none(episode.get('contentLength')),
-            'season_number': int_or_none(episode.get('season')),
-            'episode': title,
-            'episode_number': int_or_none(episode.get('episode')),
-        }
-        info.update(show_info)
-        return info
-
-    def _extract_show_info(self, show):
-        return {
-            'creator': show.get('author'),
-            'series': show.get('title'),
-        }
-
-    def _call_api(self, path, video_id, query=None):
-        return self._download_json(
-            'https://feeder.acast.com/api/v1/shows/' + path, video_id, query=query)
-
-
-class ACastIE(ACastBaseIE):
-    IE_NAME = 'acast'
-    _VALID_URL = r'''(?x:
-                    https?://
-                        (?:
-                            (?:(?:embed|www)\.)?acast\.com/|
-                            play\.acast\.com/s/
-                        )
-                        (?P<channel>[^/]+)/(?P<id>[^/#?"]+)
-                    )'''
-    _EMBED_REGEX = [rf'(?x)<iframe[^>]+\bsrc=[\'"](?P<url>{_VALID_URL})']
-    _TESTS = [{
-        'url': 'https://www.acast.com/sparpodcast/2.raggarmordet-rosterurdetforflutna',
-        'info_dict': {
-            'id': '2a92b283-1a75-4ad8-8396-499c641de0d9',
-            'ext': 'mp3',
-            'title': '2. Raggarmordet - Röster ur det förflutna',
-            'description': 'md5:013959207e05011ad14a222cf22278cc',
-            'timestamp': 1477346700,
-            'upload_date': '20161024',
-            'duration': 2766,
-            'creator': 'Third Ear Studio',
-            'series': 'Spår',
-            'episode': '2. Raggarmordet - Röster ur det förflutna',
-            'thumbnail': 'https://assets.pippa.io/shows/616ebe1886d7b1398620b943/616ebe33c7e6e70013cae7da.jpg',
-            'episode_number': 2,
-            'display_id': '2.raggarmordet-rosterurdetforflutna',
-            'season_number': 4,
-            'season': 'Season 4',
-        }
-    }, {
-        'url': 'http://embed.acast.com/adambuxton/ep.12-adam-joeschristmaspodcast2015',
-        'only_matching': True,
-    }, {
-        'url': 'https://play.acast.com/s/rattegangspodden/s04e09styckmordetihelenelund-del2-2',
-        'only_matching': True,
-    }, {
-        'url': 'https://play.acast.com/s/sparpodcast/2a92b283-1a75-4ad8-8396-499c641de0d9',
-        'only_matching': True,
-    }]
-    _WEBPAGE_TESTS = [{
-        'url': 'https://ausi.anu.edu.au/news/democracy-sausage-episode-can-labor-be-long-form-government',
-        'info_dict': {
-            'id': '646c68fb21fbf20011e9c651',
-            'ext': 'mp3',
-            'creator': 'The Australian National University',
-            'display_id': 'can-labor-be-a-long-form-government',
-            'duration': 2618,
-            'thumbnail': 'https://assets.pippa.io/shows/6113e8578b4903809f16f7e5/1684821529295-515b9520db9ce53275b995eb302f941c.jpeg',
-            'title': 'Can Labor be a long-form government?',
-            'episode': 'Can Labor be a long-form government?',
-            'upload_date': '20230523',
-            'series': 'Democracy Sausage with Mark Kenny',
-            'timestamp': 1684826362,
-            'description': 'md5:feabe1fc5004c78ee59c84a46bf4ba16',
-        }
-    }]
-
-    def _real_extract(self, url):
-        channel, display_id = self._match_valid_url(url).groups()
-        episode = self._call_api(
-            '%s/episodes/%s' % (channel, display_id),
-            display_id, {'showInfo': 'true'})
-        return self._extract_episode(
-            episode, self._extract_show_info(episode.get('show') or {}))
-
-
-class ACastChannelIE(ACastBaseIE):
-    IE_NAME = 'acast:channel'
-    _VALID_URL = r'''(?x)
-                    https?://
-                        (?:
-                            (?:www\.)?acast\.com/|
-                            play\.acast\.com/s/
-                        )
-                        (?P<id>[^/#?]+)
-                    '''
-    _TESTS = [{
-        'url': 'https://www.acast.com/todayinfocus',
-        'info_dict': {
-            'id': '4efc5294-5385-4847-98bd-519799ce5786',
-            'title': 'Today in Focus',
-            'description': 'md5:c09ce28c91002ce4ffce71d6504abaae',
-        },
-        'playlist_mincount': 200,
-    }, {
-        'url': 'http://play.acast.com/s/ft-banking-weekly',
-        'only_matching': True,
-    }]
-
-    @classmethod
-    def suitable(cls, url):
-        return False if ACastIE.suitable(url) else super(ACastChannelIE, cls).suitable(url)
-
-    def _real_extract(self, url):
-        show_slug = self._match_id(url)
-        show = self._call_api(show_slug, show_slug)
-        show_info = self._extract_show_info(show)
-        entries = []
-        for episode in (show.get('episodes') or []):
-            entries.append(self._extract_episode(episode, show_info))
-        return self.playlist_result(
-            entries, show.get('id'), show.get('title'), show.get('description'))

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

@@ -1,200 +0,0 @@
-from .common import InfoExtractor
-from ..utils import (
-    float_or_none,
-    format_field,
-    int_or_none,
-    str_or_none,
-    traverse_obj,
-    parse_codecs,
-    parse_qs,
-)
-
-
-class AcFunVideoBaseIE(InfoExtractor):
-    def _extract_metadata(self, video_id, video_info):
-        playjson = self._parse_json(video_info['ksPlayJson'], video_id)
-
-        formats, subtitles = [], {}
-        for video in traverse_obj(playjson, ('adaptationSet', 0, 'representation')):
-            fmts, subs = self._extract_m3u8_formats_and_subtitles(video['url'], video_id, 'mp4', fatal=False)
-            formats.extend(fmts)
-            self._merge_subtitles(subs, target=subtitles)
-            for f in fmts:
-                f.update({
-                    'fps': float_or_none(video.get('frameRate')),
-                    'width': int_or_none(video.get('width')),
-                    'height': int_or_none(video.get('height')),
-                    'tbr': float_or_none(video.get('avgBitrate')),
-                    **parse_codecs(video.get('codecs', ''))
-                })
-
-        return {
-            'id': video_id,
-            'formats': formats,
-            'subtitles': subtitles,
-            'duration': float_or_none(video_info.get('durationMillis'), 1000),
-            'timestamp': int_or_none(video_info.get('uploadTime'), 1000),
-            'http_headers': {'Referer': 'https://www.acfun.cn/'},
-        }
-
-
-class AcFunVideoIE(AcFunVideoBaseIE):
-    _VALID_URL = r'https?://www\.acfun\.cn/v/ac(?P<id>[_\d]+)'
-
-    _TESTS = [{
-        'url': 'https://www.acfun.cn/v/ac35457073',
-        'info_dict': {
-            'id': '35457073',
-            'ext': 'mp4',
-            'duration': 174.208,
-            'timestamp': 1656403967,
-            'title': '1 8 岁 现 状',
-            'description': '“赶紧回去！班主任查班了！”',
-            'uploader': '锤子game',
-            'uploader_id': '51246077',
-            'thumbnail': r're:^https?://.*\.(jpg|jpeg)',
-            'upload_date': '20220628',
-            'like_count': int,
-            'view_count': int,
-            'comment_count': int,
-            'tags': list,
-        },
-    }, {
-        # example for len(video_list) > 1
-        'url': 'https://www.acfun.cn/v/ac35468952_2',
-        'info_dict': {
-            'id': '35468952_2',
-            'ext': 'mp4',
-            'title': '【动画剧集】Rocket & Groot Season 1（2022）/火箭浣熊与格鲁特第1季 P02 S01E02 十拿九穩',
-            'duration': 90.459,
-            'uploader': '比令',
-            'uploader_id': '37259967',
-            'upload_date': '20220629',
-            'timestamp': 1656479962,
-            'tags': list,
-            'like_count': int,
-            'view_count': int,
-            'comment_count': int,
-            'thumbnail': r're:^https?://.*\.(jpg|jpeg)',
-            'description': 'md5:67583aaf3a0f933bd606bc8a2d3ebb17',
-        }
-    }]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-
-        webpage = self._download_webpage(url, video_id)
-        json_all = self._search_json(r'window.videoInfo\s*=', webpage, 'videoInfo', video_id)
-
-        title = json_all.get('title')
-        video_list = json_all.get('videoList') or []
-        video_internal_id = traverse_obj(json_all, ('currentVideoInfo', 'id'))
-        if video_internal_id and len(video_list) > 1:
-            part_idx, part_video_info = next(
-                (idx + 1, v) for (idx, v) in enumerate(video_list)
-                if v['id'] == video_internal_id)
-            title = f'{title} P{part_idx:02d} {part_video_info["title"]}'
-
-        return {
-            **self._extract_metadata(video_id, json_all['currentVideoInfo']),
-            'title': title,
-            'thumbnail': json_all.get('coverUrl'),
-            'description': json_all.get('description'),
-            'uploader': traverse_obj(json_all, ('user', 'name')),
-            'uploader_id': traverse_obj(json_all, ('user', 'href')),
-            'tags': traverse_obj(json_all, ('tagList', ..., 'name')),
-            'view_count': int_or_none(json_all.get('viewCount')),
-            'like_count': int_or_none(json_all.get('likeCountShow')),
-            'comment_count': int_or_none(json_all.get('commentCountShow')),
-        }
-
-
-class AcFunBangumiIE(AcFunVideoBaseIE):
-    _VALID_URL = r'https?://www\.acfun\.cn/bangumi/(?P<id>aa[_\d]+)'
-
-    _TESTS = [{
-        'url': 'https://www.acfun.cn/bangumi/aa6002917_36188_1745457?ac=2',
-        'info_dict': {
-            'id': 'aa6002917_36188_1745457__2',
-            'ext': 'mp4',
-            'title': '【7月】租借女友 水原千鹤角色曲『DATE』特别PV',
-            'upload_date': '20200916',
-            'timestamp': 1600243813,
-            'duration': 92.091,
-        },
-    }, {
-        'url': 'https://www.acfun.cn/bangumi/aa5023171_36188_1750645',
-        'info_dict': {
-            'id': 'aa5023171_36188_1750645',
-            'ext': 'mp4',
-            'title': '红孩儿之趴趴蛙寻石记 第5话 ',
-            'duration': 760.0,
-            'season': '红孩儿之趴趴蛙寻石记',
-            'season_id': '5023171',
-            'season_number': 1,  # series has only 1 season
-            'episode': 'Episode 5',
-            'episode_number': 5,
-            'upload_date': '20181223',
-            'timestamp': 1545552185,
-            'thumbnail': r're:^https?://.*\.(jpg|jpeg|png)',
-            'comment_count': int,
-        },
-    }, {
-        'url': 'https://www.acfun.cn/bangumi/aa6065485_36188_1885061',
-        'info_dict': {
-            'id': 'aa6065485_36188_1885061',
-            'ext': 'mp4',
-            'title': '叽歪老表（第二季） 第5话 坚不可摧',
-            'season': '叽歪老表（第二季）',
-            'season_number': 2,
-            'season_id': '6065485',
-            'episode': '坚不可摧',
-            'episode_number': 5,
-            'upload_date': '20220324',
-            'timestamp': 1648082786,
-            'duration': 105.002,
-            'thumbnail': r're:^https?://.*\.(jpg|jpeg|png)',
-            'comment_count': int,
-        },
-    }]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        ac_idx = parse_qs(url).get('ac', [None])[-1]
-        video_id = f'{video_id}{format_field(ac_idx, None, "__%s")}'
-
-        webpage = self._download_webpage(url, video_id)
-        json_bangumi_data = self._search_json(r'window.bangumiData\s*=', webpage, 'bangumiData', video_id)
-
-        if ac_idx:
-            video_info = json_bangumi_data['hlVideoInfo']
-            return {
-                **self._extract_metadata(video_id, video_info),
-                'title': video_info.get('title'),
-            }
-
-        video_info = json_bangumi_data['currentVideoInfo']
-
-        season_id = json_bangumi_data.get('bangumiId')
-        season_number = season_id and next((
-            idx for idx, v in enumerate(json_bangumi_data.get('relatedBangumis') or [], 1)
-            if v.get('id') == season_id), 1)
-
-        json_bangumi_list = self._search_json(
-            r'window\.bangumiList\s*=', webpage, 'bangumiList', video_id, fatal=False)
-        video_internal_id = int_or_none(traverse_obj(json_bangumi_data, ('currentVideoInfo', 'id')))
-        episode_number = video_internal_id and next((
-            idx for idx, v in enumerate(json_bangumi_list.get('items') or [], 1)
-            if v.get('videoId') == video_internal_id), None)
-
-        return {
-            **self._extract_metadata(video_id, video_info),
-            'title': json_bangumi_data.get('showTitle'),
-            'thumbnail': json_bangumi_data.get('image'),
-            'season': json_bangumi_data.get('bangumiTitle'),
-            'season_id': str_or_none(season_id),
-            'season_number': season_number,
-            'episode': json_bangumi_data.get('title'),
-            'episode_number': episode_number,
-            'comment_count': int_or_none(json_bangumi_data.get('commentCount')),
-        }

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

@@ -1,335 +0,0 @@
-import base64
-import binascii
-import json
-import os
-import random
-import time
-
-from .common import InfoExtractor
-from ..aes import aes_cbc_decrypt_bytes, unpad_pkcs7
-from ..compat import compat_b64decode
-from ..networking.exceptions import HTTPError
-from ..utils import (
-    ass_subtitles_timecode,
-    bytes_to_intlist,
-    bytes_to_long,
-    ExtractorError,
-    float_or_none,
-    int_or_none,
-    intlist_to_bytes,
-    long_to_bytes,
-    parse_iso8601,
-    pkcs1pad,
-    strip_or_none,
-    str_or_none,
-    try_get,
-    unified_strdate,
-    urlencode_postdata,
-)
-from ..utils.traversal import traverse_obj
-
-
-class ADNBaseIE(InfoExtractor):
-    IE_DESC = 'Animation Digital Network'
-    _NETRC_MACHINE = 'animationdigitalnetwork'
-    _BASE = 'animationdigitalnetwork.fr'
-    _API_BASE_URL = f'https://gw.api.{_BASE}/'
-    _PLAYER_BASE_URL = f'{_API_BASE_URL}player/'
-    _HEADERS = {}
-    _LOGIN_ERR_MESSAGE = 'Unable to log in'
-    _RSA_KEY = (0x9B42B08905199A5CCE2026274399CA560ECB209EE9878A708B1C0812E1BB8CB5D1FB7441861147C1A1F2F3A0476DD63A9CAC20D3E983613346850AA6CB38F16DC7D720FD7D86FC6E5B3D5BBC72E14CD0BF9E869F2CEA2CCAD648F1DCE38F1FF916CEFB2D339B64AA0264372344BC775E265E8A852F88144AB0BD9AA06C1A4ABB, 65537)
-    _POS_ALIGN_MAP = {
-        'start': 1,
-        'end': 3,
-    }
-    _LINE_ALIGN_MAP = {
-        'middle': 8,
-        'end': 4,
-    }
-
-
-class ADNIE(ADNBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?(?:animation|anime)digitalnetwork\.(?P<lang>fr|de)/video/[^/?#]+/(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://animationdigitalnetwork.fr/video/fruits-basket/9841-episode-1-a-ce-soir',
-        'md5': '1c9ef066ceb302c86f80c2b371615261',
-        'info_dict': {
-            'id': '9841',
-            'ext': 'mp4',
-            'title': 'Fruits Basket - Episode 1',
-            'description': 'md5:14be2f72c3c96809b0ca424b0097d336',
-            'series': 'Fruits Basket',
-            'duration': 1437,
-            'release_date': '20190405',
-            'comment_count': int,
-            'average_rating': float,
-            'season_number': 1,
-            'episode': 'À ce soir !',
-            'episode_number': 1,
-            'thumbnail': str,
-            'season': 'Season 1',
-        },
-        'skip': 'Only available in French and German speaking Europe',
-    }, {
-        'url': 'http://animedigitalnetwork.fr/video/blue-exorcist-kyoto-saga/7778-episode-1-debut-des-hostilites',
-        'only_matching': True,
-    }, {
-        'url': 'https://animationdigitalnetwork.de/video/the-eminence-in-shadow/23550-folge-1',
-        'md5': '5c5651bf5791fa6fcd7906012b9d94e8',
-        'info_dict': {
-            'id': '23550',
-            'ext': 'mp4',
-            'episode_number': 1,
-            'duration': 1417,
-            'release_date': '20231004',
-            'series': 'The Eminence in Shadow',
-            'season_number': 2,
-            'episode': str,
-            'title': str,
-            'thumbnail': str,
-            'season': 'Season 2',
-            'comment_count': int,
-            'average_rating': float,
-            'description': str,
-        },
-        # 'skip': 'Only available in French and German speaking Europe',
-    }]
-
-    def _get_subtitles(self, sub_url, video_id):
-        if not sub_url:
-            return None
-
-        enc_subtitles = self._download_webpage(
-            sub_url, video_id, 'Downloading subtitles location', fatal=False) or '{}'
-        subtitle_location = (self._parse_json(enc_subtitles, video_id, fatal=False) or {}).get('location')
-        if subtitle_location:
-            enc_subtitles = self._download_webpage(
-                subtitle_location, video_id, 'Downloading subtitles data',
-                fatal=False, headers={'Origin': 'https://' + self._BASE})
-        if not enc_subtitles:
-            return None
-
-        # http://animationdigitalnetwork.fr/components/com_vodvideo/videojs/adn-vjs.min.js
-        dec_subtitles = unpad_pkcs7(aes_cbc_decrypt_bytes(
-            compat_b64decode(enc_subtitles[24:]),
-            binascii.unhexlify(self._K + '7fac1178830cfe0c'),
-            compat_b64decode(enc_subtitles[:24])))
-        subtitles_json = self._parse_json(dec_subtitles.decode(), None, fatal=False)
-        if not subtitles_json:
-            return None
-
-        subtitles = {}
-        for sub_lang, sub in subtitles_json.items():
-            ssa = '''[Script Info]
-ScriptType:V4.00
-[V4 Styles]
-Format: Name,Fontname,Fontsize,PrimaryColour,SecondaryColour,TertiaryColour,BackColour,Bold,Italic,BorderStyle,Outline,Shadow,Alignment,MarginL,MarginR,MarginV,AlphaLevel,Encoding
-Style: Default,Arial,18,16777215,16777215,16777215,0,-1,0,1,1,0,2,20,20,20,0,0
-[Events]
-Format: Marked,Start,End,Style,Name,MarginL,MarginR,MarginV,Effect,Text'''
-            for current in sub:
-                start, end, text, line_align, position_align = (
-                    float_or_none(current.get('startTime')),
-                    float_or_none(current.get('endTime')),
-                    current.get('text'), current.get('lineAlign'),
-                    current.get('positionAlign'))
-                if start is None or end is None or text is None:
-                    continue
-                alignment = self._POS_ALIGN_MAP.get(position_align, 2) + self._LINE_ALIGN_MAP.get(line_align, 0)
-                ssa += os.linesep + 'Dialogue: Marked=0,%s,%s,Default,,0,0,0,,%s%s' % (
-                    ass_subtitles_timecode(start),
-                    ass_subtitles_timecode(end),
-                    '{\\a%d}' % alignment if alignment != 2 else '',
-                    text.replace('\n', '\\N').replace('<i>', '{\\i1}').replace('</i>', '{\\i0}'))
-
-            if sub_lang == 'vostf':
-                sub_lang = 'fr'
-            elif sub_lang == 'vostde':
-                sub_lang = 'de'
-            subtitles.setdefault(sub_lang, []).extend([{
-                'ext': 'json',
-                'data': json.dumps(sub),
-            }, {
-                'ext': 'ssa',
-                'data': ssa,
-            }])
-        return subtitles
-
-    def _perform_login(self, username, password):
-        try:
-            access_token = (self._download_json(
-                self._API_BASE_URL + 'authentication/login', None,
-                'Logging in', self._LOGIN_ERR_MESSAGE, fatal=False,
-                data=urlencode_postdata({
-                    'password': password,
-                    'rememberMe': False,
-                    'source': 'Web',
-                    'username': username,
-                })) or {}).get('accessToken')
-            if access_token:
-                self._HEADERS = {'authorization': 'Bearer ' + access_token}
-        except ExtractorError as e:
-            message = None
-            if isinstance(e.cause, HTTPError) and e.cause.status == 401:
-                resp = self._parse_json(
-                    e.cause.response.read().decode(), None, fatal=False) or {}
-                message = resp.get('message') or resp.get('code')
-            self.report_warning(message or self._LOGIN_ERR_MESSAGE)
-
-    def _real_extract(self, url):
-        lang, video_id = self._match_valid_url(url).group('lang', 'id')
-        video_base_url = self._PLAYER_BASE_URL + 'video/%s/' % video_id
-        player = self._download_json(
-            video_base_url + 'configuration', video_id,
-            'Downloading player config JSON metadata',
-            headers=self._HEADERS)['player']
-        options = player['options']
-
-        user = options['user']
-        if not user.get('hasAccess'):
-            start_date = traverse_obj(options, ('video', 'startDate', {str}))
-            if (parse_iso8601(start_date) or 0) > time.time():
-                raise ExtractorError(f'This video is not available yet. Release date: {start_date}', expected=True)
-            self.raise_login_required('This video requires a subscription', method='password')
-
-        token = self._download_json(
-            user.get('refreshTokenUrl') or (self._PLAYER_BASE_URL + 'refresh/token'),
-            video_id, 'Downloading access token', headers={
-                'X-Player-Refresh-Token': user['refreshToken'],
-            }, data=b'')['token']
-
-        links_url = try_get(options, lambda x: x['video']['url']) or (video_base_url + 'link')
-        self._K = ''.join(random.choices('0123456789abcdef', k=16))
-        message = bytes_to_intlist(json.dumps({
-            'k': self._K,
-            't': token,
-        }))
-
-        # Sometimes authentication fails for no good reason, retry with
-        # a different random padding
-        links_data = None
-        for _ in range(3):
-            padded_message = intlist_to_bytes(pkcs1pad(message, 128))
-            n, e = self._RSA_KEY
-            encrypted_message = long_to_bytes(pow(bytes_to_long(padded_message), e, n))
-            authorization = base64.b64encode(encrypted_message).decode()
-
-            try:
-                links_data = self._download_json(
-                    links_url, video_id, 'Downloading links JSON metadata', headers={
-                        'X-Player-Token': authorization,
-                        'X-Target-Distribution': lang,
-                        **self._HEADERS
-                    }, query={
-                        'freeWithAds': 'true',
-                        'adaptive': 'false',
-                        'withMetadata': 'true',
-                        'source': 'Web'
-                    })
-                break
-            except ExtractorError as e:
-                if not isinstance(e.cause, HTTPError):
-                    raise e
-
-                if e.cause.status == 401:
-                    # This usually goes away with a different random pkcs1pad, so retry
-                    continue
-
-                error = self._parse_json(e.cause.response.read(), video_id)
-                message = error.get('message')
-                if e.cause.code == 403 and error.get('code') == 'player-bad-geolocation-country':
-                    self.raise_geo_restricted(msg=message)
-                raise ExtractorError(message)
-        else:
-            raise ExtractorError('Giving up retrying')
-
-        links = links_data.get('links') or {}
-        metas = links_data.get('metadata') or {}
-        sub_url = (links.get('subtitles') or {}).get('all')
-        video_info = links_data.get('video') or {}
-        title = metas['title']
-
-        formats = []
-        for format_id, qualities in (links.get('streaming') or {}).items():
-            if not isinstance(qualities, dict):
-                continue
-            for quality, load_balancer_url in qualities.items():
-                load_balancer_data = self._download_json(
-                    load_balancer_url, video_id,
-                    'Downloading %s %s JSON metadata' % (format_id, quality),
-                    fatal=False) or {}
-                m3u8_url = load_balancer_data.get('location')
-                if not m3u8_url:
-                    continue
-                m3u8_formats = self._extract_m3u8_formats(
-                    m3u8_url, video_id, 'mp4', 'm3u8_native',
-                    m3u8_id=format_id, fatal=False)
-                if format_id == 'vf':
-                    for f in m3u8_formats:
-                        f['language'] = 'fr'
-                elif format_id == 'vde':
-                    for f in m3u8_formats:
-                        f['language'] = 'de'
-                formats.extend(m3u8_formats)
-
-        if not formats:
-            self.raise_login_required('This video requires a subscription', method='password')
-
-        video = (self._download_json(
-            self._API_BASE_URL + 'video/%s' % video_id, video_id,
-            'Downloading additional video metadata', fatal=False) or {}).get('video') or {}
-        show = video.get('show') or {}
-
-        return {
-            'id': video_id,
-            'title': title,
-            'description': strip_or_none(metas.get('summary') or video.get('summary')),
-            'thumbnail': video_info.get('image') or player.get('image'),
-            'formats': formats,
-            'subtitles': self.extract_subtitles(sub_url, video_id),
-            'episode': metas.get('subtitle') or video.get('name'),
-            'episode_number': int_or_none(video.get('shortNumber')),
-            'series': show.get('title'),
-            'season_number': int_or_none(video.get('season')),
-            'duration': int_or_none(video_info.get('duration') or video.get('duration')),
-            'release_date': unified_strdate(video.get('releaseDate')),
-            'average_rating': float_or_none(video.get('rating') or metas.get('rating')),
-            'comment_count': int_or_none(video.get('commentsCount')),
-        }
-
-
-class ADNSeasonIE(ADNBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?(?:animation|anime)digitalnetwork\.(?P<lang>fr|de)/video/(?P<id>[^/?#]+)/?(?:$|[#?])'
-    _TESTS = [{
-        'url': 'https://animationdigitalnetwork.fr/video/tokyo-mew-mew-new',
-        'playlist_count': 12,
-        'info_dict': {
-            'id': '911',
-            'title': 'Tokyo Mew Mew New',
-        },
-        # 'skip': 'Only available in French end German speaking Europe',
-    }]
-
-    def _real_extract(self, url):
-        lang, video_show_slug = self._match_valid_url(url).group('lang', 'id')
-        show = self._download_json(
-            f'{self._API_BASE_URL}show/{video_show_slug}/', video_show_slug,
-            'Downloading show JSON metadata', headers=self._HEADERS)['show']
-        show_id = str(show['id'])
-        episodes = self._download_json(
-            f'{self._API_BASE_URL}video/show/{show_id}', video_show_slug,
-            'Downloading episode list', headers={
-                'X-Target-Distribution': lang,
-                **self._HEADERS
-            }, query={
-                'order': 'asc',
-                'limit': '-1',
-            })
-
-        def entries():
-            for episode_id in traverse_obj(episodes, ('videos', ..., 'id', {str_or_none})):
-                yield self.url_result(
-                    f'https://animationdigitalnetwork.{lang}/video/{video_show_slug}/{episode_id}',
-                    ADNIE, episode_id)
-
-        return self.playlist_result(entries(), show_id, show.get('title'))