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

@@ -1,75 +0,0 @@
-from .common import InfoExtractor
-from ..utils import OnDemandPagedList, int_or_none, jwt_decode_hs256, try_call
-
-
-def result_from_props(props, episode_id=None):
-    return {
-        'id': props.get('podcast_id') or episode_id,
-        'title': props.get('title'),
-        'url': props['mediaURL'],
-        'ext': 'mp3',
-        'thumbnail': try_call(lambda: jwt_decode_hs256(props['image'])['url']),
-        'timestamp': props.get('timestamp'),
-        'duration': int_or_none(props.get('duration')),
-    }
-
-
-class PodbayFMIE(InfoExtractor):
-    _VALID_URL = r'https?://podbay\.fm/p/[^/]*/e/(?P<id>[^/]*)/?(?:[\?#].*)?$'
-    _TESTS = [{
-        'url': 'https://podbay.fm/p/behind-the-bastards/e/1647338400',
-        'md5': '98b41285dcf7989d105a4ed0404054cf',
-        'info_dict': {
-            'id': '1647338400',
-            'title': 'Part One: Kissinger',
-            'ext': 'mp3',
-            'thumbnail': r're:^https?://.*\.jpg',
-            'timestamp': 1647338400,
-            'duration': 5001,
-            'upload_date': '20220315',
-        },
-    }]
-
-    def _real_extract(self, url):
-        episode_id = self._match_id(url)
-        webpage = self._download_webpage(url, episode_id)
-        data = self._search_nextjs_data(webpage, episode_id)
-        return result_from_props(data['props']['pageProps']['episode'], episode_id)
-
-
-class PodbayFMChannelIE(InfoExtractor):
-    _VALID_URL = r'https?://podbay\.fm/p/(?P<id>[^/]*)/?(?:[\?#].*)?$'
-    _TESTS = [{
-        'url': 'https://podbay.fm/p/behind-the-bastards',
-        'info_dict': {
-            'id': 'behind-the-bastards',
-            'title': 'Behind the Bastards',
-        },
-    }]
-    _PAGE_SIZE = 10
-
-    def _fetch_page(self, channel_id, pagenum):
-        return self._download_json(
-            f'https://podbay.fm/api/podcast?reverse=true&page={pagenum}&slug={channel_id}',
-            channel_id)['podcast']
-
-    @staticmethod
-    def _results_from_page(channel_id, page):
-        return [{
-            **result_from_props(e),
-            'extractor': PodbayFMIE.IE_NAME,
-            'extractor_key': PodbayFMIE.ie_key(),
-            # somehow they use timestamps as the episode identifier
-            'webpage_url': f'https://podbay.fm/p/{channel_id}/e/{e["timestamp"]}',
-        } for e in page['episodes']]
-
-    def _real_extract(self, url):
-        channel_id = self._match_id(url)
-
-        first_page = self._fetch_page(channel_id, 0)
-        entries = OnDemandPagedList(
-            lambda pagenum: self._results_from_page(
-                channel_id, self._fetch_page(channel_id, pagenum) if pagenum else first_page),
-            self._PAGE_SIZE)
-
-        return self.playlist_result(entries, channel_id, first_page.get('title'))

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

@@ -1,97 +0,0 @@
-import functools
-import json
-
-from .common import InfoExtractor
-from ..utils import (
-    OnDemandPagedList,
-    float_or_none,
-    str_or_none,
-    str_to_int,
-    traverse_obj,
-    unified_timestamp,
-)
-
-
-class PodchaserIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?podchaser\.com/podcasts/[\w-]+-(?P<podcast_id>\d+)(?:/episodes/[\w-]+-(?P<id>\d+))?'
-    _PAGE_SIZE = 100
-    _TESTS = [{
-        'url': 'https://www.podchaser.com/podcasts/cum-town-36924/episodes/ep-285-freeze-me-off-104365585',
-        'info_dict': {
-            'id': '104365585',
-            'title': 'Ep. 285 – freeze me off',
-            'description': 'cam ahn',
-            'thumbnail': r're:^https?://.*\.jpg$',
-            'ext': 'mp3',
-            'categories': ['Comedy'],
-            'tags': ['comedy', 'dark humor'],
-            'series': 'Cum Town',
-            'duration': 3708,
-            'timestamp': 1636531259,
-            'upload_date': '20211110',
-            'average_rating': 4.0
-        }
-    }, {
-        'url': 'https://www.podchaser.com/podcasts/the-bone-zone-28853',
-        'info_dict': {
-            'id': '28853',
-            'title': 'The Bone Zone',
-            'description': 'Podcast by The Bone Zone',
-        },
-        'playlist_count': 275
-    }, {
-        'url': 'https://www.podchaser.com/podcasts/sean-carrolls-mindscape-scienc-699349/episodes',
-        'info_dict': {
-            'id': '699349',
-            'title': 'Sean Carroll\'s Mindscape: Science, Society, Philosophy, Culture, Arts, and Ideas',
-            'description': 'md5:2cbd8f4749891a84dc8235342e0b5ff1'
-        },
-        'playlist_mincount': 225
-    }]
-
-    @staticmethod
-    def _parse_episode(episode, podcast):
-        return {
-            'id': str(episode.get('id')),
-            'title': episode.get('title'),
-            'description': episode.get('description'),
-            'url': episode.get('audio_url'),
-            'thumbnail': episode.get('image_url'),
-            'duration': str_to_int(episode.get('length')),
-            'timestamp': unified_timestamp(episode.get('air_date')),
-            'average_rating': float_or_none(episode.get('rating')),
-            'categories': list(set(traverse_obj(podcast, (('summary', None), 'categories', ..., 'text')))),
-            'tags': traverse_obj(podcast, ('tags', ..., 'text')),
-            'series': podcast.get('title'),
-        }
-
-    def _call_api(self, path, *args, **kwargs):
-        return self._download_json(f'https://api.podchaser.com/{path}', *args, **kwargs)
-
-    def _fetch_page(self, podcast_id, podcast, page):
-        json_response = self._call_api(
-            'list/episode', podcast_id,
-            headers={'Content-Type': 'application/json;charset=utf-8'},
-            data=json.dumps({
-                'start': page * self._PAGE_SIZE,
-                'count': self._PAGE_SIZE,
-                'sort_order': 'SORT_ORDER_RECENT',
-                'filters': {
-                    'podcast_id': podcast_id
-                },
-                'options': {}
-            }).encode())
-
-        for episode in json_response['entities']:
-            yield self._parse_episode(episode, podcast)
-
-    def _real_extract(self, url):
-        podcast_id, episode_id = self._match_valid_url(url).group('podcast_id', 'id')
-        podcast = self._call_api(f'podcasts/{podcast_id}', episode_id or podcast_id)
-        if not episode_id:
-            return self.playlist_result(
-                OnDemandPagedList(functools.partial(self._fetch_page, podcast_id, podcast), self._PAGE_SIZE),
-                str_or_none(podcast.get('id')), podcast.get('title'), podcast.get('description'))
-
-        episode = self._call_api(f'episodes/{episode_id}', episode_id)
-        return self._parse_episode(episode, podcast)

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

@@ -1,74 +0,0 @@
-import json
-
-from .common import InfoExtractor
-from ..utils import int_or_none
-
-
-class PodomaticIE(InfoExtractor):
-    _WORKING = False
-    IE_NAME = 'podomatic'
-    _VALID_URL = r'''(?x)
-                    (?P<proto>https?)://
-                        (?:
-                            (?P<channel>[^.]+)\.podomatic\.com/entry|
-                            (?:www\.)?podomatic\.com/podcasts/(?P<channel_2>[^/]+)/episodes
-                        )/
-                        (?P<id>[^/?#&]+)
-                '''
-
-    _TESTS = [{
-        'url': 'http://scienceteachingtips.podomatic.com/entry/2009-01-02T16_03_35-08_00',
-        'md5': '84bb855fcf3429e6bf72460e1eed782d',
-        'info_dict': {
-            'id': '2009-01-02T16_03_35-08_00',
-            'ext': 'mp3',
-            'uploader': 'Science Teaching Tips',
-            'uploader_id': 'scienceteachingtips',
-            'title': '64.  When the Moon Hits Your Eye',
-            'duration': 446,
-        }
-    }, {
-        'url': 'http://ostbahnhof.podomatic.com/entry/2013-11-15T16_31_21-08_00',
-        'md5': 'd2cf443931b6148e27638650e2638297',
-        'info_dict': {
-            'id': '2013-11-15T16_31_21-08_00',
-            'ext': 'mp3',
-            'uploader': 'Ostbahnhof / Techno Mix',
-            'uploader_id': 'ostbahnhof',
-            'title': 'Einunddreizig',
-            'duration': 3799,
-        }
-    }, {
-        'url': 'https://www.podomatic.com/podcasts/scienceteachingtips/episodes/2009-01-02T16_03_35-08_00',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        mobj = self._match_valid_url(url)
-        video_id = mobj.group('id')
-        channel = mobj.group('channel') or mobj.group('channel_2')
-
-        json_url = (('%s://%s.podomatic.com/entry/embed_params/%s'
-                     + '?permalink=true&rtmp=0') %
-                    (mobj.group('proto'), channel, video_id))
-        data_json = self._download_webpage(
-            json_url, video_id, 'Downloading video info')
-        data = json.loads(data_json)
-
-        video_url = data['downloadLink']
-        if not video_url:
-            video_url = '%s/%s' % (data['streamer'].replace('rtmp', 'http'), data['mediaLocation'])
-        uploader = data['podcast']
-        title = data['title']
-        thumbnail = data['imageLocation']
-        duration = int_or_none(data.get('length'), 1000)
-
-        return {
-            'id': video_id,
-            'url': video_url,
-            'title': title,
-            'uploader': uploader,
-            'uploader_id': channel,
-            'thumbnail': thumbnail,
-            'duration': duration,
-        }

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

@@ -1,136 +0,0 @@
-from .common import InfoExtractor
-from ..utils import (
-    ExtractorError,
-    extract_attributes,
-    int_or_none,
-    js_to_json,
-    merge_dicts,
-)
-
-
-class PokemonIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?pokemon\.com/[a-z]{2}(?:.*?play=(?P<id>[a-z0-9]{32})|/(?:[^/]+/)+(?P<display_id>[^/?#&]+))'
-    _TESTS = [{
-        'url': 'https://www.pokemon.com/us/pokemon-episodes/20_30-the-ol-raise-and-switch/',
-        'md5': '2fe8eaec69768b25ef898cda9c43062e',
-        'info_dict': {
-            'id': 'afe22e30f01c41f49d4f1d9eab5cd9a4',
-            'ext': 'mp4',
-            'title': 'The Ol’ Raise and Switch!',
-            'description': 'md5:7db77f7107f98ba88401d3adc80ff7af',
-        },
-        'add_id': ['LimelightMedia'],
-    }, {
-        # no data-video-title
-        'url': 'https://www.pokemon.com/fr/episodes-pokemon/films-pokemon/pokemon-lascension-de-darkrai-2008',
-        'info_dict': {
-            'id': 'dfbaf830d7e54e179837c50c0c6cc0e1',
-            'ext': 'mp4',
-            'title': "Pokémon : L'ascension de Darkrai",
-            'description': 'md5:d1dbc9e206070c3e14a06ff557659fb5',
-        },
-        'add_id': ['LimelightMedia'],
-        'params': {
-            'skip_download': True,
-        },
-    }, {
-        'url': 'http://www.pokemon.com/uk/pokemon-episodes/?play=2e8b5c761f1d4a9286165d7748c1ece2',
-        'only_matching': True,
-    }, {
-        'url': 'http://www.pokemon.com/fr/episodes-pokemon/18_09-un-hiver-inattendu/',
-        'only_matching': True,
-    }, {
-        'url': 'http://www.pokemon.com/de/pokemon-folgen/01_20-bye-bye-smettbo/',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        video_id, display_id = self._match_valid_url(url).groups()
-        webpage = self._download_webpage(url, video_id or display_id)
-        video_data = extract_attributes(self._search_regex(
-            r'(<[^>]+data-video-id="%s"[^>]*>)' % (video_id if video_id else '[a-z0-9]{32}'),
-            webpage, 'video data element'))
-        video_id = video_data['data-video-id']
-        title = video_data.get('data-video-title') or self._html_search_meta(
-            'pkm-title', webpage, ' title', default=None) or self._search_regex(
-            r'<h1[^>]+\bclass=["\']us-title[^>]+>([^<]+)', webpage, 'title')
-        return {
-            '_type': 'url_transparent',
-            'id': video_id,
-            'url': 'limelight:media:%s' % video_id,
-            'title': title,
-            'description': video_data.get('data-video-summary'),
-            'thumbnail': video_data.get('data-video-poster'),
-            'series': 'Pokémon',
-            'season_number': int_or_none(video_data.get('data-video-season')),
-            'episode': title,
-            'episode_number': int_or_none(video_data.get('data-video-episode')),
-            'ie_key': 'LimelightMedia',
-        }
-
-
-class PokemonWatchIE(InfoExtractor):
-    _VALID_URL = r'https?://watch\.pokemon\.com/[a-z]{2}-[a-z]{2}/(?:#/)?player(?:\.html)?\?id=(?P<id>[a-z0-9]{32})'
-    _API_URL = 'https://www.pokemon.com/api/pokemontv/v2/channels/{0:}'
-    _TESTS = [{
-        'url': 'https://watch.pokemon.com/en-us/player.html?id=8309a40969894a8e8d5bc1311e9c5667',
-        'md5': '62833938a31e61ab49ada92f524c42ff',
-        'info_dict': {
-            'id': '8309a40969894a8e8d5bc1311e9c5667',
-            'ext': 'mp4',
-            'title': 'Lillier and the Staff!',
-            'description': 'md5:338841b8c21b283d24bdc9b568849f04',
-        }
-    }, {
-        'url': 'https://watch.pokemon.com/en-us/#/player?id=3fe7752ba09141f0b0f7756d1981c6b2',
-        'only_matching': True
-    }, {
-        'url': 'https://watch.pokemon.com/de-de/player.html?id=b3c402e111a4459eb47e12160ab0ba07',
-        'only_matching': True
-    }]
-
-    def _extract_media(self, channel_array, video_id):
-        for channel in channel_array:
-            for media in channel.get('media'):
-                if media.get('id') == video_id:
-                    return media
-        return None
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-
-        info = {
-            '_type': 'url',
-            'id': video_id,
-            'url': 'limelight:media:%s' % video_id,
-            'ie_key': 'LimelightMedia',
-        }
-
-        # API call can be avoided entirely if we are listing formats
-        if self.get_param('listformats', False):
-            return info
-
-        webpage = self._download_webpage(url, video_id)
-        build_vars = self._parse_json(self._search_regex(
-            r'(?s)buildVars\s*=\s*({.*?})', webpage, 'build vars'),
-            video_id, transform_source=js_to_json)
-        region = build_vars.get('region')
-        channel_array = self._download_json(self._API_URL.format(region), video_id)
-        video_data = self._extract_media(channel_array, video_id)
-
-        if video_data is None:
-            raise ExtractorError(
-                'Video %s does not exist' % video_id, expected=True)
-
-        info['_type'] = 'url_transparent'
-        images = video_data.get('images')
-
-        return merge_dicts(info, {
-            'title': video_data.get('title'),
-            'description': video_data.get('description'),
-            'thumbnail': images.get('medium') or images.get('small'),
-            'series': 'Pokémon',
-            'season_number': int_or_none(video_data.get('season')),
-            'episode': video_data.get('title'),
-            'episode_number': int_or_none(video_data.get('episode')),
-        })

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

@@ -1,106 +0,0 @@
-import base64
-
-from .common import InfoExtractor
-from ..utils import (
-    ExtractorError,
-    try_get,
-)
-
-
-class PokerGoBaseIE(InfoExtractor):
-    _NETRC_MACHINE = 'pokergo'
-    _AUTH_TOKEN = None
-    _PROPERTY_ID = '1dfb3940-7d53-4980-b0b0-f28b369a000d'
-
-    def _perform_login(self, username, password):
-        if self._AUTH_TOKEN:
-            return
-        self.report_login()
-        PokerGoBaseIE._AUTH_TOKEN = self._download_json(
-            f'https://subscription.pokergo.com/properties/{self._PROPERTY_ID}/sign-in', None,
-            headers={'authorization': f'Basic {base64.b64encode(f"{username}:{password}".encode()).decode()}'},
-            data=b'')['meta']['token']
-        if not self._AUTH_TOKEN:
-            raise ExtractorError('Unable to get Auth Token.', expected=True)
-
-    def _real_initialize(self):
-        if not self._AUTH_TOKEN:
-            self.raise_login_required(method='password')
-
-
-class PokerGoIE(PokerGoBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?pokergo\.com/videos/(?P<id>[^&$#/?]+)'
-
-    _TESTS = [{
-        'url': 'https://www.pokergo.com/videos/2a70ec4e-4a80-414b-97ec-725d9b72a7dc',
-        'info_dict': {
-            'id': 'aVLOxDzY',
-            'ext': 'mp4',
-            'title': 'Poker After Dark | Season 12 (2020) | Cry Me a River | Episode 2',
-            'description': 'md5:c7a8c29556cbfb6eb3c0d5d622251b71',
-            'thumbnail': 'https://cdn.jwplayer.com/v2/media/aVLOxDzY/poster.jpg?width=720',
-            'timestamp': 1608085715,
-            'duration': 2700.12,
-            'season_number': 12,
-            'episode_number': 2,
-            'series': 'poker after dark',
-            'upload_date': '20201216',
-            'season': 'Season 12',
-            'episode': 'Episode 2',
-            'display_id': '2a70ec4e-4a80-414b-97ec-725d9b72a7dc',
-        },
-        'params': {'skip_download': True}
-    }]
-
-    def _real_extract(self, url):
-        id = self._match_id(url)
-        data_json = self._download_json(f'https://api.pokergo.com/v2/properties/{self._PROPERTY_ID}/videos/{id}', id,
-                                        headers={'authorization': f'Bearer {self._AUTH_TOKEN}'})['data']
-        v_id = data_json['source']
-
-        thumbnails = [{
-            'url': image['url'],
-            'id': image.get('label'),
-            'width': image.get('width'),
-            'height': image.get('height')
-        } for image in data_json.get('images') or [] if image.get('url')]
-        series_json = next(dct for dct in data_json.get('show_tags') or [] if dct.get('video_id') == id) or {}
-
-        return {
-            '_type': 'url_transparent',
-            'display_id': id,
-            'title': data_json.get('title'),
-            'description': data_json.get('description'),
-            'duration': data_json.get('duration'),
-            'thumbnails': thumbnails,
-            'season_number': series_json.get('season'),
-            'episode_number': series_json.get('episode_number'),
-            'series': try_get(series_json, lambda x: x['tag']['name']),
-            'url': f'https://cdn.jwplayer.com/v2/media/{v_id}'
-        }
-
-
-class PokerGoCollectionIE(PokerGoBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?pokergo\.com/collections/(?P<id>[^&$#/?]+)'
-
-    _TESTS = [{
-        'url': 'https://www.pokergo.com/collections/19ffe481-5dae-481a-8869-75cc0e3c4700',
-        'playlist_mincount': 13,
-        'info_dict': {
-            'id': '19ffe481-5dae-481a-8869-75cc0e3c4700',
-        },
-    }]
-
-    def _entries(self, id):
-        data_json = self._download_json(f'https://api.pokergo.com/v2/properties/{self._PROPERTY_ID}/collections/{id}?include=entities',
-                                        id, headers={'authorization': f'Bearer {self._AUTH_TOKEN}'})['data']
-        for video in data_json.get('collection_video') or []:
-            video_id = video.get('id')
-            if video_id:
-                yield self.url_result(
-                    f'https://www.pokergo.com/videos/{video_id}',
-                    ie=PokerGoIE.ie_key(), video_id=video_id)
-
-    def _real_extract(self, url):
-        id = self._match_id(url)
-        return self.playlist_result(self._entries(id), playlist_id=id)

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

@@ -1,86 +0,0 @@
-from uuid import uuid4
-import json
-
-from .common import InfoExtractor
-from ..utils import (
-    int_or_none,
-    try_get,
-    url_or_none,
-    ExtractorError,
-)
-
-
-class PolsatGoIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?polsat(?:box)?go\.pl/.+/(?P<id>[0-9a-fA-F]+)(?:[/#?]|$)'
-    _TESTS = [{
-        'url': 'https://polsatgo.pl/wideo/seriale/swiat-wedlug-kiepskich/5024045/sezon-1/5028300/swiat-wedlug-kiepskich-odcinek-88/4121',
-        'info_dict': {
-            'id': '4121',
-            'ext': 'mp4',
-            'title': 'Świat według Kiepskich - Odcinek 88',
-            'age_limit': 12,
-        },
-    }]
-
-    def _extract_formats(self, sources, video_id):
-        for source in sources or []:
-            if not source.get('id'):
-                continue
-            url = url_or_none(self._call_api(
-                'drm', video_id, 'getPseudoLicense',
-                {'mediaId': video_id, 'sourceId': source['id']}).get('url'))
-            if not url:
-                continue
-            yield {
-                'url': url,
-                'height': int_or_none(try_get(source, lambda x: x['quality'][:-1]))
-            }
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        media = self._call_api('navigation', video_id, 'prePlayData', {'mediaId': video_id})['mediaItem']
-
-        formats = list(self._extract_formats(
-            try_get(media, lambda x: x['playback']['mediaSources']), video_id))
-
-        return {
-            'id': video_id,
-            'title': media['displayInfo']['title'],
-            'formats': formats,
-            'age_limit': int_or_none(media['displayInfo']['ageGroup'])
-        }
-
-    def _call_api(self, endpoint, media_id, method, params):
-        rand_uuid = str(uuid4())
-        res = self._download_json(
-            f'https://b2c-mobile.redefine.pl/rpc/{endpoint}/', media_id,
-            note=f'Downloading {method} JSON metadata',
-            data=json.dumps({
-                'method': method,
-                'id': '2137',
-                'jsonrpc': '2.0',
-                'params': {
-                    **params,
-                    'userAgentData': {
-                        'deviceType': 'mobile',
-                        'application': 'native',
-                        'os': 'android',
-                        'build': 10003,
-                        'widevine': False,
-                        'portal': 'pg',
-                        'player': 'cpplayer',
-                    },
-                    'deviceId': {
-                        'type': 'other',
-                        'value': rand_uuid,
-                    },
-                    'clientId': rand_uuid,
-                    'cpid': 1,
-                },
-            }).encode('utf-8'),
-            headers={'Content-type': 'application/json'})
-        if not res.get('result'):
-            if res['error']['code'] == 13404:
-                raise ExtractorError('This video is either unavailable in your region or is DRM protected', expected=True)
-            raise ExtractorError(f'Solorz said: {res["error"]["message"]} - {res["error"]["data"]["userMessage"]}')
-        return res['result']