@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/acast.py

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,200 @@
+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

@@ -0,0 +1,335 @@
+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'))