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

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

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

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

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

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

@@ -0,0 +1,86 @@
+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']