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

@@ -1,150 +0,0 @@
-from .common import InfoExtractor
-
-from ..utils import (
-    ExtractorError,
-    parse_resolution,
-    traverse_obj,
-    try_get,
-    urlencode_postdata,
-)
-
-
-class DigitalConcertHallIE(InfoExtractor):
-    IE_DESC = 'DigitalConcertHall extractor'
-    _VALID_URL = r'https?://(?:www\.)?digitalconcerthall\.com/(?P<language>[a-z]+)/(?P<type>film|concert)/(?P<id>[0-9]+)'
-    _OAUTH_URL = 'https://api.digitalconcerthall.com/v2/oauth2/token'
-    _ACCESS_TOKEN = None
-    _NETRC_MACHINE = 'digitalconcerthall'
-    _TESTS = [{
-        'note': 'Playlist with only one video',
-        'url': 'https://www.digitalconcerthall.com/en/concert/53201',
-        'info_dict': {
-            'id': '53201-1',
-            'ext': 'mp4',
-            'composer': 'Kurt Weill',
-            'title': '[Magic Night]',
-            'thumbnail': r're:^https?://images.digitalconcerthall.com/cms/thumbnails.*\.jpg$',
-            'upload_date': '20210624',
-            'timestamp': 1624548600,
-            'duration': 2798,
-            'album_artist': 'Members of the Berliner Philharmoniker / Simon Rössler',
-        },
-        'params': {'skip_download': 'm3u8'},
-    }, {
-        'note': 'Concert with several works and an interview',
-        'url': 'https://www.digitalconcerthall.com/en/concert/53785',
-        'info_dict': {
-            'id': '53785',
-            'album_artist': 'Berliner Philharmoniker / Kirill Petrenko',
-            'title': 'Kirill Petrenko conducts Mendelssohn and Shostakovich',
-        },
-        'params': {'skip_download': 'm3u8'},
-        'playlist_count': 3,
-    }, {
-        'url': 'https://www.digitalconcerthall.com/en/film/388',
-        'info_dict': {
-            'id': '388',
-            'ext': 'mp4',
-            'title': 'The Berliner Philharmoniker and Frank Peter Zimmermann',
-            'description': 'md5:cfe25a7044fa4be13743e5089b5b5eb2',
-            'thumbnail': r're:^https?://images.digitalconcerthall.com/cms/thumbnails.*\.jpg$',
-            'upload_date': '20220714',
-            'timestamp': 1657785600,
-            'album_artist': 'Frank Peter Zimmermann / Benedikt von Bernstorff / Jakob von Bernstorff',
-        },
-        'params': {'skip_download': 'm3u8'},
-    }]
-
-    def _perform_login(self, username, password):
-        token_response = self._download_json(
-            self._OAUTH_URL,
-            None, 'Obtaining token', errnote='Unable to obtain token', data=urlencode_postdata({
-                'affiliate': 'none',
-                'grant_type': 'device',
-                'device_vendor': 'unknown',
-                'app_id': 'dch.webapp',
-                'app_version': '1.0.0',
-                'client_secret': '2ySLN+2Fwb',
-            }), headers={
-                'Content-Type': 'application/x-www-form-urlencoded',
-            })
-        self._ACCESS_TOKEN = token_response['access_token']
-        try:
-            self._download_json(
-                self._OAUTH_URL,
-                None, note='Logging in', errnote='Unable to login', data=urlencode_postdata({
-                    'grant_type': 'password',
-                    'username': username,
-                    'password': password,
-                }), headers={
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                    'Referer': 'https://www.digitalconcerthall.com',
-                    'Authorization': f'Bearer {self._ACCESS_TOKEN}'
-                })
-        except ExtractorError:
-            self.raise_login_required(msg='Login info incorrect')
-
-    def _real_initialize(self):
-        if not self._ACCESS_TOKEN:
-            self.raise_login_required(method='password')
-
-    def _entries(self, items, language, type_, **kwargs):
-        for item in items:
-            video_id = item['id']
-            stream_info = self._download_json(
-                self._proto_relative_url(item['_links']['streams']['href']), video_id, headers={
-                    'Accept': 'application/json',
-                    'Authorization': f'Bearer {self._ACCESS_TOKEN}',
-                    'Accept-Language': language
-                })
-
-            m3u8_url = traverse_obj(
-                stream_info, ('channel', lambda k, _: k.startswith('vod_mixed'), 'stream', 0, 'url'), get_all=False)
-            formats = self._extract_m3u8_formats(m3u8_url, video_id, 'mp4', 'm3u8_native', fatal=False)
-
-            yield {
-                'id': video_id,
-                'title': item.get('title'),
-                'composer': item.get('name_composer'),
-                'url': m3u8_url,
-                'formats': formats,
-                'duration': item.get('duration_total'),
-                'timestamp': traverse_obj(item, ('date', 'published')),
-                'description': item.get('short_description') or stream_info.get('short_description'),
-                **kwargs,
-                'chapters': [{
-                    'start_time': chapter.get('time'),
-                    'end_time': try_get(chapter, lambda x: x['time'] + x['duration']),
-                    'title': chapter.get('text'),
-                } for chapter in item['cuepoints']] if item.get('cuepoints') and type_ == 'concert' else None,
-            }
-
-    def _real_extract(self, url):
-        language, type_, video_id = self._match_valid_url(url).group('language', 'type', 'id')
-        if not language:
-            language = 'en'
-
-        thumbnail_url = self._html_search_regex(
-            r'(https?://images\.digitalconcerthall\.com/cms/thumbnails/.*\.jpg)',
-            self._download_webpage(url, video_id), 'thumbnail')
-        thumbnails = [{
-            'url': thumbnail_url,
-            **parse_resolution(thumbnail_url)
-        }]
-
-        vid_info = self._download_json(
-            f'https://api.digitalconcerthall.com/v2/{type_}/{video_id}', video_id, headers={
-                'Accept': 'application/json',
-                'Accept-Language': language
-            })
-        album_artist = ' / '.join(traverse_obj(vid_info, ('_links', 'artist', ..., 'name')) or '')
-        videos = [vid_info] if type_ == 'film' else traverse_obj(vid_info, ('_embedded', ..., ...))
-
-        return {
-            '_type': 'playlist',
-            'id': video_id,
-            'title': vid_info.get('title'),
-            'entries': self._entries(videos, language, thumbnails=thumbnails, album_artist=album_artist, type_=type_),
-            'thumbnails': thumbnails,
-            'album_artist': album_artist,
-        }

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

@@ -1,98 +0,0 @@
-from .common import InfoExtractor
-from ..utils import int_or_none
-
-
-class DigitekaIE(InfoExtractor):
-    _VALID_URL = r'''(?x)
-        https?://(?:www\.)?(?:digiteka\.net|ultimedia\.com)/
-        (?:
-            deliver/
-            (?P<embed_type>
-                generic|
-                musique
-            )
-            (?:/[^/]+)*/
-            (?:
-                src|
-                article
-            )|
-            default/index/video
-            (?P<site_type>
-                generic|
-                music
-            )
-            /id
-        )/(?P<id>[\d+a-z]+)'''
-    _EMBED_REGEX = [r'<(?:iframe|script)[^>]+src=["\'](?P<url>(?:https?:)?//(?:www\.)?ultimedia\.com/deliver/(?:generic|musique)(?:/[^/]+)*/(?:src|article)/[\d+a-z]+)']
-    _TESTS = [{
-        # news
-        'url': 'https://www.ultimedia.com/default/index/videogeneric/id/s8uk0r',
-        'md5': '276a0e49de58c7e85d32b057837952a2',
-        'info_dict': {
-            'id': 's8uk0r',
-            'ext': 'mp4',
-            'title': 'Loi sur la fin de vie: le texte prévoit un renforcement des directives anticipées',
-            'thumbnail': r're:^https?://.*\.jpg',
-            'duration': 74,
-            'upload_date': '20150317',
-            'timestamp': 1426604939,
-            'uploader_id': '3fszv',
-        },
-    }, {
-        # music
-        'url': 'https://www.ultimedia.com/default/index/videomusic/id/xvpfp8',
-        'md5': '2ea3513813cf230605c7e2ffe7eca61c',
-        'info_dict': {
-            'id': 'xvpfp8',
-            'ext': 'mp4',
-            'title': 'Two - C\'est La Vie (clip)',
-            'thumbnail': r're:^https?://.*\.jpg',
-            'duration': 233,
-            'upload_date': '20150224',
-            'timestamp': 1424760500,
-            'uploader_id': '3rfzk',
-        },
-    }, {
-        'url': 'https://www.digiteka.net/deliver/generic/iframe/mdtk/01637594/src/lqm3kl/zone/1/showtitle/1/autoplay/yes',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        mobj = self._match_valid_url(url)
-        video_id = mobj.group('id')
-        video_type = mobj.group('embed_type') or mobj.group('site_type')
-        if video_type == 'music':
-            video_type = 'musique'
-
-        deliver_info = self._download_json(
-            'http://www.ultimedia.com/deliver/video?video=%s&topic=%s' % (video_id, video_type),
-            video_id)
-
-        yt_id = deliver_info.get('yt_id')
-        if yt_id:
-            return self.url_result(yt_id, 'Youtube')
-
-        jwconf = deliver_info['jwconf']
-
-        formats = []
-        for source in jwconf['playlist'][0]['sources']:
-            formats.append({
-                'url': source['file'],
-                'format_id': source.get('label'),
-            })
-
-        title = deliver_info['title']
-        thumbnail = jwconf.get('image')
-        duration = int_or_none(deliver_info.get('duration'))
-        timestamp = int_or_none(deliver_info.get('release_time'))
-        uploader_id = deliver_info.get('owner_id')
-
-        return {
-            'id': video_id,
-            'title': title,
-            'thumbnail': thumbnail,
-            'duration': duration,
-            'timestamp': timestamp,
-            'uploader_id': uploader_id,
-            'formats': formats,
-        }

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

@@ -1,35 +0,0 @@
-from .common import InfoExtractor
-from .youtube import YoutubeIE
-from ..utils import traverse_obj
-
-
-class DiscogsReleasePlaylistIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?discogs\.com/(?P<type>release|master)/(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://www.discogs.com/release/1-The-Persuader-Stockholm',
-        'info_dict': {
-            'id': 'release1',
-            'title': 'Stockholm',
-        },
-        'playlist_mincount': 7,
-    }, {
-        'url': 'https://www.discogs.com/master/113-Vince-Watson-Moments-In-Time',
-        'info_dict': {
-            'id': 'master113',
-            'title': 'Moments In Time',
-        },
-        'playlist_mincount': 53,
-    }]
-
-    def _real_extract(self, url):
-        playlist_id, playlist_type = self._match_valid_url(url).group('id', 'type')
-
-        display_id = f'{playlist_type}{playlist_id}'
-        response = self._download_json(
-            f'https://api.discogs.com/{playlist_type}s/{playlist_id}', display_id)
-
-        entries = [
-            self.url_result(video['uri'], YoutubeIE, video_title=video.get('title'))
-            for video in traverse_obj(response, ('videos', lambda _, v: YoutubeIE.suitable(v['uri'])))]
-
-        return self.playlist_result(entries, display_id, response.get('title'))

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

@@ -1,115 +0,0 @@
-import random
-import string
-
-from .discoverygo import DiscoveryGoBaseIE
-from ..compat import compat_urllib_parse_unquote
-from ..networking.exceptions import HTTPError
-from ..utils import ExtractorError
-
-
-class DiscoveryIE(DiscoveryGoBaseIE):
-    _VALID_URL = r'''(?x)https?://
-        (?P<site>
-            go\.discovery|
-            www\.
-                (?:
-                    investigationdiscovery|
-                    discoverylife|
-                    animalplanet|
-                    ahctv|
-                    destinationamerica|
-                    sciencechannel|
-                    tlc
-                )|
-            watch\.
-                (?:
-                    hgtv|
-                    foodnetwork|
-                    travelchannel|
-                    diynetwork|
-                    cookingchanneltv|
-                    motortrend
-                )
-        )\.com/tv-shows/(?P<show_slug>[^/]+)/(?:video|full-episode)s/(?P<id>[^./?#]+)'''
-    _TESTS = [{
-        'url': 'https://go.discovery.com/tv-shows/cash-cab/videos/riding-with-matthew-perry',
-        'info_dict': {
-            'id': '5a2f35ce6b66d17a5026e29e',
-            'ext': 'mp4',
-            'title': 'Riding with Matthew Perry',
-            'description': 'md5:a34333153e79bc4526019a5129e7f878',
-            'duration': 84,
-        },
-        'params': {
-            'skip_download': True,  # requires ffmpeg
-        }
-    }, {
-        'url': 'https://www.investigationdiscovery.com/tv-shows/final-vision/full-episodes/final-vision',
-        'only_matching': True,
-    }, {
-        'url': 'https://go.discovery.com/tv-shows/alaskan-bush-people/videos/follow-your-own-road',
-        'only_matching': True,
-    }, {
-        # using `show_slug` is important to get the correct video data
-        'url': 'https://www.sciencechannel.com/tv-shows/mythbusters-on-science/full-episodes/christmas-special',
-        'only_matching': True,
-    }]
-    _GEO_COUNTRIES = ['US']
-    _GEO_BYPASS = False
-    _API_BASE_URL = 'https://api.discovery.com/v1/'
-
-    def _real_extract(self, url):
-        site, show_slug, display_id = self._match_valid_url(url).groups()
-
-        access_token = None
-        cookies = self._get_cookies(url)
-
-        # prefer Affiliate Auth Token over Anonymous Auth Token
-        auth_storage_cookie = cookies.get('eosAf') or cookies.get('eosAn')
-        if auth_storage_cookie and auth_storage_cookie.value:
-            auth_storage = self._parse_json(compat_urllib_parse_unquote(
-                compat_urllib_parse_unquote(auth_storage_cookie.value)),
-                display_id, fatal=False) or {}
-            access_token = auth_storage.get('a') or auth_storage.get('access_token')
-
-        if not access_token:
-            access_token = self._download_json(
-                'https://%s.com/anonymous' % site, display_id,
-                'Downloading token JSON metadata', query={
-                    'authRel': 'authorization',
-                    'client_id': '3020a40c2356a645b4b4',
-                    'nonce': ''.join(random.choices(string.ascii_letters, k=32)),
-                    'redirectUri': 'https://www.discovery.com/',
-                })['access_token']
-
-        headers = self.geo_verification_headers()
-        headers['Authorization'] = 'Bearer ' + access_token
-
-        try:
-            video = self._download_json(
-                self._API_BASE_URL + 'content/videos',
-                display_id, 'Downloading content JSON metadata',
-                headers=headers, query={
-                    'embed': 'show.name',
-                    'fields': 'authenticated,description.detailed,duration,episodeNumber,id,name,parental.rating,season.number,show,tags',
-                    'slug': display_id,
-                    'show_slug': show_slug,
-                })[0]
-            video_id = video['id']
-            stream = self._download_json(
-                self._API_BASE_URL + 'streaming/video/' + video_id,
-                display_id, 'Downloading streaming JSON metadata', headers=headers)
-        except ExtractorError as e:
-            if isinstance(e.cause, HTTPError) and e.cause.status in (401, 403):
-                e_description = self._parse_json(
-                    e.cause.response.read().decode(), display_id)['description']
-                if 'resource not available for country' in e_description:
-                    self.raise_geo_restricted(countries=self._GEO_COUNTRIES)
-                if 'Authorized Networks' in e_description:
-                    raise ExtractorError(
-                        'This video is only available via cable service provider subscription that'
-                        ' is not currently supported. You may want to use --cookies.', expected=True)
-                raise ExtractorError(e_description)
-            raise
-
-        return self._extract_video_info(video, stream, display_id)

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

@@ -1,172 +0,0 @@
-import re
-
-from .common import InfoExtractor
-from ..utils import (
-    determine_ext,
-    extract_attributes,
-    ExtractorError,
-    int_or_none,
-    parse_age_limit,
-    remove_end,
-    unescapeHTML,
-    url_or_none,
-)
-
-
-class DiscoveryGoBaseIE(InfoExtractor):
-    _VALID_URL_TEMPLATE = r'''(?x)https?://(?:www\.)?(?:
-            discovery|
-            investigationdiscovery|
-            discoverylife|
-            animalplanet|
-            ahctv|
-            destinationamerica|
-            sciencechannel|
-            tlc|
-            velocitychannel
-        )go\.com/%s(?P<id>[^/?#&]+)'''
-
-    def _extract_video_info(self, video, stream, display_id):
-        title = video['name']
-
-        if not stream:
-            if video.get('authenticated') is True:
-                raise ExtractorError(
-                    'This video is only available via cable service provider subscription that'
-                    ' is not currently supported. You may want to use --cookies.', expected=True)
-            else:
-                raise ExtractorError('Unable to find stream')
-        STREAM_URL_SUFFIX = 'streamUrl'
-        formats = []
-        for stream_kind in ('', 'hds'):
-            suffix = STREAM_URL_SUFFIX.capitalize() if stream_kind else STREAM_URL_SUFFIX
-            stream_url = stream.get('%s%s' % (stream_kind, suffix))
-            if not stream_url:
-                continue
-            if stream_kind == '':
-                formats.extend(self._extract_m3u8_formats(
-                    stream_url, display_id, 'mp4', entry_protocol='m3u8_native',
-                    m3u8_id='hls', fatal=False))
-            elif stream_kind == 'hds':
-                formats.extend(self._extract_f4m_formats(
-                    stream_url, display_id, f4m_id=stream_kind, fatal=False))
-
-        video_id = video.get('id') or display_id
-        description = video.get('description', {}).get('detailed')
-        duration = int_or_none(video.get('duration'))
-
-        series = video.get('show', {}).get('name')
-        season_number = int_or_none(video.get('season', {}).get('number'))
-        episode_number = int_or_none(video.get('episodeNumber'))
-
-        tags = video.get('tags')
-        age_limit = parse_age_limit(video.get('parental', {}).get('rating'))
-
-        subtitles = {}
-        captions = stream.get('captions')
-        if isinstance(captions, list):
-            for caption in captions:
-                subtitle_url = url_or_none(caption.get('fileUrl'))
-                if not subtitle_url or not subtitle_url.startswith('http'):
-                    continue
-                lang = caption.get('fileLang', 'en')
-                ext = determine_ext(subtitle_url)
-                subtitles.setdefault(lang, []).append({
-                    'url': subtitle_url,
-                    'ext': 'ttml' if ext == 'xml' else ext,
-                })
-
-        return {
-            'id': video_id,
-            'display_id': display_id,
-            'title': title,
-            'description': description,
-            'duration': duration,
-            'series': series,
-            'season_number': season_number,
-            'episode_number': episode_number,
-            'tags': tags,
-            'age_limit': age_limit,
-            'formats': formats,
-            'subtitles': subtitles,
-        }
-
-
-class DiscoveryGoIE(DiscoveryGoBaseIE):
-    _VALID_URL = DiscoveryGoBaseIE._VALID_URL_TEMPLATE % r'(?:[^/]+/)+'
-    _GEO_COUNTRIES = ['US']
-    _TEST = {
-        'url': 'https://www.discoverygo.com/bering-sea-gold/reaper-madness/',
-        'info_dict': {
-            'id': '58c167d86b66d12f2addeb01',
-            'ext': 'mp4',
-            'title': 'Reaper Madness',
-            'description': 'md5:09f2c625c99afb8946ed4fb7865f6e78',
-            'duration': 2519,
-            'series': 'Bering Sea Gold',
-            'season_number': 8,
-            'episode_number': 6,
-            'age_limit': 14,
-        },
-    }
-
-    def _real_extract(self, url):
-        display_id = self._match_id(url)
-
-        webpage = self._download_webpage(url, display_id)
-
-        container = extract_attributes(
-            self._search_regex(
-                r'(<div[^>]+class=["\']video-player-container[^>]+>)',
-                webpage, 'video container'))
-
-        video = self._parse_json(
-            container.get('data-video') or container.get('data-json'),
-            display_id)
-
-        stream = video.get('stream')
-
-        return self._extract_video_info(video, stream, display_id)
-
-
-class DiscoveryGoPlaylistIE(DiscoveryGoBaseIE):
-    _VALID_URL = DiscoveryGoBaseIE._VALID_URL_TEMPLATE % ''
-    _TEST = {
-        'url': 'https://www.discoverygo.com/bering-sea-gold/',
-        'info_dict': {
-            'id': 'bering-sea-gold',
-            'title': 'Bering Sea Gold',
-            'description': 'md5:cc5c6489835949043c0cc3ad66c2fa0e',
-        },
-        'playlist_mincount': 6,
-    }
-
-    @classmethod
-    def suitable(cls, url):
-        return False if DiscoveryGoIE.suitable(url) else super(
-            DiscoveryGoPlaylistIE, cls).suitable(url)
-
-    def _real_extract(self, url):
-        display_id = self._match_id(url)
-
-        webpage = self._download_webpage(url, display_id)
-
-        entries = []
-        for mobj in re.finditer(r'data-json=(["\'])(?P<json>{.+?})\1', webpage):
-            data = self._parse_json(
-                mobj.group('json'), display_id,
-                transform_source=unescapeHTML, fatal=False)
-            if not isinstance(data, dict) or data.get('type') != 'episode':
-                continue
-            episode_url = data.get('socialUrl')
-            if not episode_url:
-                continue
-            entries.append(self.url_result(
-                episode_url, ie=DiscoveryGoIE.ie_key(),
-                video_id=data.get('id')))
-
-        return self.playlist_result(
-            entries, display_id,
-            remove_end(self._og_search_title(
-                webpage, fatal=False), ' | Discovery GO'),
-            self._og_search_description(webpage))