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

@@ -1,52 +0,0 @@
-from .common import InfoExtractor
-from ..utils import js_to_json
-
-
-class PeerTVIE(InfoExtractor):
-    IE_NAME = 'peer.tv'
-    _VALID_URL = r'https?://(?:www\.)?peer\.tv/(?:de|it|en)/(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://www.peer.tv/de/841',
-        'info_dict': {
-            'id': '841',
-            'ext': 'mp4',
-            'title': 'Die Brunnenburg',
-            'description': 'md5:4395f6142b090338340ab88a3aae24ed',
-        },
-    }, {
-        'url': 'https://www.peer.tv/it/404',
-        'info_dict': {
-            'id': '404',
-            'ext': 'mp4',
-            'title': 'Cascate di ghiaccio in Val Gardena',
-            'description': 'md5:e8e5907f236171842674e8090e3577b8',
-        },
-    }]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        webpage = self._download_webpage(url, video_id)
-
-        video_key = self._html_search_regex(r'player\.peer\.tv/js/([a-zA-Z0-9]+)', webpage, 'video key')
-
-        js = self._download_webpage(f'https://player.peer.tv/js/{video_key}/', video_id,
-                                    headers={'Referer': 'https://www.peer.tv/'}, note='Downloading session id')
-
-        session_id = self._search_regex(r'["\']session_id["\']:\s*["\']([a-zA-Z0-9]+)["\']', js, 'session id')
-
-        player_webpage = self._download_webpage(
-            f'https://player.peer.tv/jsc/{video_key}/{session_id}?jsr=aHR0cHM6Ly93d3cucGVlci50di9kZS84NDE=&cs=UTF-8&mq=2&ua=0&webm=p&mp4=p&hls=1',
-            video_id, note='Downloading player webpage')
-
-        m3u8_url = self._search_regex(r'["\']playlist_url["\']:\s*(["\'][^"\']+["\'])', player_webpage, 'm3u8 url')
-        m3u8_url = self._parse_json(m3u8_url, video_id, transform_source=js_to_json)
-
-        formats = self._extract_m3u8_formats(m3u8_url, video_id, m3u8_id='hls')
-
-        return {
-            'id': video_id,
-            'title': self._html_search_regex(r'<h1>(.+?)</h1>', webpage, 'title').replace('\xa0', ' '),
-            'formats': formats,
-            'description': self._html_search_meta(('og:description', 'description'), webpage),
-            'thumbnail': self._html_search_meta(('og:image', 'image'), webpage)
-        }

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

@@ -1,215 +0,0 @@
-import json
-import re
-import urllib.parse
-
-from .common import InfoExtractor
-from ..networking.exceptions import HTTPError
-from ..utils import (
-    ExtractorError,
-    float_or_none,
-    str_or_none,
-    traverse_obj,
-    url_or_none,
-)
-
-
-class PelotonIE(InfoExtractor):
-    IE_NAME = 'peloton'
-    _NETRC_MACHINE = 'peloton'
-    _VALID_URL = r'https?://members\.onepeloton\.com/classes/player/(?P<id>[a-f0-9]+)'
-    _TESTS = [{
-        'url': 'https://members.onepeloton.com/classes/player/0e9653eb53544eeb881298c8d7a87b86',
-        'info_dict': {
-            'id': '0e9653eb53544eeb881298c8d7a87b86',
-            'title': '20 min Chest & Back Strength',
-            'ext': 'mp4',
-            'thumbnail': r're:^https?://.+\.jpg',
-            'description': 'md5:fcd5be9b9eda0194b470e13219050a66',
-            'creator': 'Chase Tucker',
-            'release_timestamp': 1556141400,
-            'timestamp': 1556141400,
-            'upload_date': '20190424',
-            'duration': 1389,
-            'categories': ['Strength'],
-            'tags': ['Workout Mat', 'Light Weights', 'Medium Weights'],
-            'is_live': False,
-            'chapters': 'count:1',
-            'subtitles': {'en': [{
-                'url': r're:^https?://.+',
-                'ext': 'vtt'
-            }]},
-        }, 'params': {
-            'skip_download': 'm3u8',
-        },
-        '_skip': 'Account needed'
-    }, {
-        'url': 'https://members.onepeloton.com/classes/player/26603d53d6bb4de1b340514864a6a6a8',
-        'info_dict': {
-            'id': '26603d53d6bb4de1b340514864a6a6a8',
-            'title': '30 min Earth Day Run',
-            'ext': 'm4a',
-            'thumbnail': r're:https://.+\.jpg',
-            'description': 'md5:adc065a073934d7ee0475d217afe0c3d',
-            'creator': 'Selena Samuela',
-            'release_timestamp': 1587567600,
-            'timestamp': 1587567600,
-            'upload_date': '20200422',
-            'duration': 1802,
-            'categories': ['Running'],
-            'is_live': False,
-            'chapters': 'count:3'
-        }, 'params': {
-            'skip_download': 'm3u8',
-        },
-        '_skip': 'Account needed'
-    }]
-
-    _MANIFEST_URL_TEMPLATE = '%s?hdnea=%s'
-
-    def _start_session(self, video_id):
-        self._download_webpage('https://api.onepeloton.com/api/started_client_session', video_id, note='Starting session')
-
-    def _login(self, video_id):
-        username, password = self._get_login_info()
-        if not (username and password):
-            self.raise_login_required()
-        try:
-            self._download_json(
-                'https://api.onepeloton.com/auth/login', video_id, note='Logging in',
-                data=json.dumps({
-                    'username_or_email': username,
-                    'password': password,
-                    'with_pubsub': False
-                }).encode(),
-                headers={'Content-Type': 'application/json', 'User-Agent': 'web'})
-        except ExtractorError as e:
-            if isinstance(e.cause, HTTPError) and e.cause.status == 401:
-                json_string = self._webpage_read_content(e.cause.response, None, video_id)
-                res = self._parse_json(json_string, video_id)
-                raise ExtractorError(res['message'], expected=res['message'] == 'Login failed')
-            else:
-                raise
-
-    def _get_token(self, video_id):
-        try:
-            subscription = self._download_json(
-                'https://api.onepeloton.com/api/subscription/stream', video_id, note='Downloading token',
-                data=json.dumps({}).encode(), headers={'Content-Type': 'application/json'})
-        except ExtractorError as e:
-            if isinstance(e.cause, HTTPError) and e.cause.status == 403:
-                json_string = self._webpage_read_content(e.cause.response, None, video_id)
-                res = self._parse_json(json_string, video_id)
-                raise ExtractorError(res['message'], expected=res['message'] == 'Stream limit reached')
-            else:
-                raise
-        return subscription['token']
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        try:
-            self._start_session(video_id)
-        except ExtractorError as e:
-            if isinstance(e.cause, HTTPError) and e.cause.status == 401:
-                self._login(video_id)
-                self._start_session(video_id)
-            else:
-                raise
-
-        metadata = self._download_json('https://api.onepeloton.com/api/ride/%s/details?stream_source=multichannel' % video_id, video_id)
-        ride_data = metadata.get('ride')
-        if not ride_data:
-            raise ExtractorError('Missing stream metadata')
-        token = self._get_token(video_id)
-
-        is_live = False
-        if ride_data.get('content_format') == 'audio':
-            url = self._MANIFEST_URL_TEMPLATE % (ride_data.get('vod_stream_url'), urllib.parse.quote(token))
-            formats = [{
-                'url': url,
-                'ext': 'm4a',
-                'format_id': 'audio',
-                'vcodec': 'none',
-            }]
-            subtitles = {}
-        else:
-            if ride_data.get('vod_stream_url'):
-                url = 'https://members.onepeloton.com/.netlify/functions/m3u8-proxy?displayLanguage=en&acceptedSubtitles=%s&url=%s?hdnea=%s' % (
-                    ','.join([re.sub('^([a-z]+)-([A-Z]+)$', r'\1', caption) for caption in ride_data['captions']]),
-                    ride_data['vod_stream_url'],
-                    urllib.parse.quote(urllib.parse.quote(token)))
-            elif ride_data.get('live_stream_url'):
-                url = self._MANIFEST_URL_TEMPLATE % (ride_data.get('live_stream_url'), urllib.parse.quote(token))
-                is_live = True
-            else:
-                raise ExtractorError('Missing video URL')
-            formats, subtitles = self._extract_m3u8_formats_and_subtitles(url, video_id, 'mp4')
-
-        if metadata.get('instructor_cues'):
-            subtitles['cues'] = [{
-                'data': json.dumps(metadata.get('instructor_cues')),
-                'ext': 'json'
-            }]
-
-        category = ride_data.get('fitness_discipline_display_name')
-        chapters = [{
-            'start_time': segment.get('start_time_offset'),
-            'end_time': segment.get('start_time_offset') + segment.get('length'),
-            'title': segment.get('name')
-        } for segment in traverse_obj(metadata, ('segments', 'segment_list'))]
-
-        return {
-            'id': video_id,
-            'title': ride_data.get('title'),
-            'formats': formats,
-            'thumbnail': url_or_none(ride_data.get('image_url')),
-            'description': str_or_none(ride_data.get('description')),
-            'creator': traverse_obj(ride_data, ('instructor', 'name')),
-            'release_timestamp': ride_data.get('original_air_time'),
-            'timestamp': ride_data.get('original_air_time'),
-            'subtitles': subtitles,
-            'duration': float_or_none(ride_data.get('length')),
-            'categories': [category] if category else None,
-            'tags': traverse_obj(ride_data, ('equipment_tags', ..., 'name')),
-            'is_live': is_live,
-            'chapters': chapters
-        }
-
-
-class PelotonLiveIE(InfoExtractor):
-    IE_NAME = 'peloton:live'
-    IE_DESC = 'Peloton Live'
-    _VALID_URL = r'https?://members\.onepeloton\.com/player/live/(?P<id>[a-f0-9]+)'
-    _TEST = {
-        'url': 'https://members.onepeloton.com/player/live/eedee2d19f804a9788f53aa8bd38eb1b',
-        'info_dict': {
-            'id': '32edc92d28044be5bf6c7b6f1f8d1cbc',
-            'title': '30 min HIIT Ride: Live from Home',
-            'ext': 'mp4',
-            'thumbnail': r're:^https?://.+\.png',
-            'description': 'md5:f0d7d8ed3f901b7ee3f62c1671c15817',
-            'creator': 'Alex Toussaint',
-            'release_timestamp': 1587736620,
-            'timestamp': 1587736620,
-            'upload_date': '20200424',
-            'duration': 2014,
-            'categories': ['Cycling'],
-            'is_live': False,
-            'chapters': 'count:3'
-        },
-        'params': {
-            'skip_download': 'm3u8',
-        },
-        '_skip': 'Account needed'
-    }
-
-    def _real_extract(self, url):
-        workout_id = self._match_id(url)
-        peloton = self._download_json(f'https://api.onepeloton.com/api/peloton/{workout_id}', workout_id)
-
-        if peloton.get('ride_id'):
-            if not peloton.get('is_live') or peloton.get('is_encore') or peloton.get('status') != 'PRE_START':
-                return self.url_result('https://members.onepeloton.com/classes/player/%s' % peloton['ride_id'])
-            else:
-                raise ExtractorError('Ride has not started', expected=True)
-        else:
-            raise ExtractorError('Missing video ID')

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

@@ -1,77 +0,0 @@
-from .common import InfoExtractor
-from ..utils import int_or_none
-
-
-class PerformGroupIE(InfoExtractor):
-    _VALID_URL = r'https?://player\.performgroup\.com/eplayer(?:/eplayer\.html|\.js)#/?(?P<id>[0-9a-f]{26})\.(?P<auth_token>[0-9a-z]{26})'
-    _TESTS = [{
-        # http://www.faz.net/aktuell/sport/fussball/wm-2018-playoffs-schweiz-besiegt-nordirland-1-0-15286104.html
-        'url': 'http://player.performgroup.com/eplayer/eplayer.html#d478c41c5d192f56b9aa859de8.1w4crrej5w14e1ed4s1ce4ykab',
-        'md5': '259cb03d142e2e52471e8837ecacb29f',
-        'info_dict': {
-            'id': 'xgrwobuzumes1lwjxtcdpwgxd',
-            'ext': 'mp4',
-            'title': 'Liga MX: Keine Einsicht nach Horrorfoul',
-            'description': 'md5:7cd3b459c82725b021e046ab10bf1c5b',
-            'timestamp': 1511533477,
-            'upload_date': '20171124',
-        }
-    }]
-
-    def _call_api(self, service, auth_token, content_id, referer_url):
-        return self._download_json(
-            'http://ep3.performfeeds.com/ep%s/%s/%s/' % (service, auth_token, content_id),
-            content_id, headers={
-                'Referer': referer_url,
-                'Origin': 'http://player.performgroup.com',
-            }, query={
-                '_fmt': 'json',
-            })
-
-    def _real_extract(self, url):
-        player_id, auth_token = self._match_valid_url(url).groups()
-        bootstrap = self._call_api('bootstrap', auth_token, player_id, url)
-        video = bootstrap['config']['dataSource']['sourceItems'][0]['videos'][0]
-        video_id = video['uuid']
-        vod = self._call_api('vod', auth_token, video_id, url)
-        media = vod['videos']['video'][0]['media']
-
-        formats = []
-        hls_url = media.get('hls', {}).get('url')
-        if hls_url:
-            formats.extend(self._extract_m3u8_formats(hls_url, video_id, 'mp4', 'm3u8_native', m3u8_id='hls', fatal=False))
-
-        hds_url = media.get('hds', {}).get('url')
-        if hds_url:
-            formats.extend(self._extract_f4m_formats(hds_url + '?hdcore', video_id, f4m_id='hds', fatal=False))
-
-        for c in media.get('content', []):
-            c_url = c.get('url')
-            if not c_url:
-                continue
-            tbr = int_or_none(c.get('bitrate'), 1000)
-            format_id = 'http'
-            if tbr:
-                format_id += '-%d' % tbr
-            formats.append({
-                'format_id': format_id,
-                'url': c_url,
-                'tbr': tbr,
-                'width': int_or_none(c.get('width')),
-                'height': int_or_none(c.get('height')),
-                'filesize': int_or_none(c.get('fileSize')),
-                'vcodec': c.get('type'),
-                'fps': int_or_none(c.get('videoFrameRate')),
-                'vbr': int_or_none(c.get('videoRate'), 1000),
-                'abr': int_or_none(c.get('audioRate'), 1000),
-            })
-
-        return {
-            'id': video_id,
-            'title': video['title'],
-            'description': video.get('description'),
-            'thumbnail': video.get('poster'),
-            'duration': int_or_none(video.get('duration')),
-            'timestamp': int_or_none(video.get('publishedTime'), 1000),
-            'formats': formats,
-        }

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

@@ -1,188 +0,0 @@
-from .common import InfoExtractor
-from ..utils import (
-    int_or_none,
-    parse_iso8601,
-    unescapeHTML,
-)
-from ..utils.traversal import traverse_obj
-
-
-class PeriscopeBaseIE(InfoExtractor):
-    _M3U8_HEADERS = {
-        'Referer': 'https://www.periscope.tv/'
-    }
-
-    def _call_api(self, method, query, item_id):
-        return self._download_json(
-            'https://api.periscope.tv/api/v2/%s' % method,
-            item_id, query=query)
-
-    def _parse_broadcast_data(self, broadcast, video_id):
-        title = broadcast.get('status') or 'Periscope Broadcast'
-        uploader = broadcast.get('user_display_name') or broadcast.get('username')
-        title = '%s - %s' % (uploader, title) if uploader else title
-        thumbnails = [{
-            'url': broadcast[image],
-        } for image in ('image_url', 'image_url_medium', 'image_url_small') if broadcast.get(image)]
-
-        return {
-            'id': broadcast.get('id') or video_id,
-            'title': title,
-            'timestamp': parse_iso8601(broadcast.get('created_at')) or int_or_none(
-                broadcast.get('created_at_ms'), scale=1000),
-            'release_timestamp': int_or_none(broadcast.get('scheduled_start_ms'), scale=1000),
-            'uploader': uploader,
-            'uploader_id': broadcast.get('user_id') or broadcast.get('username'),
-            'thumbnails': thumbnails,
-            'view_count': int_or_none(broadcast.get('total_watched')),
-            'concurrent_view_count': int_or_none(broadcast.get('total_watching')),
-            'tags': broadcast.get('tags'),
-            'live_status': {
-                'running': 'is_live',
-                'not_started': 'is_upcoming',
-            }.get(traverse_obj(broadcast, ('state', {str.lower}))) or 'was_live'
-        }
-
-    @staticmethod
-    def _extract_common_format_info(broadcast):
-        return broadcast.get('state').lower(), int_or_none(broadcast.get('width')), int_or_none(broadcast.get('height'))
-
-    @staticmethod
-    def _add_width_and_height(f, width, height):
-        for key, val in (('width', width), ('height', height)):
-            if not f.get(key):
-                f[key] = val
-
-    def _extract_pscp_m3u8_formats(self, m3u8_url, video_id, format_id, state, width, height, fatal=True):
-        m3u8_formats = self._extract_m3u8_formats(
-            m3u8_url, video_id, 'mp4',
-            entry_protocol='m3u8_native'
-            if state in ('ended', 'timed_out') else 'm3u8',
-            m3u8_id=format_id, fatal=fatal, headers=self._M3U8_HEADERS)
-        if len(m3u8_formats) == 1:
-            self._add_width_and_height(m3u8_formats[0], width, height)
-        for f in m3u8_formats:
-            f.setdefault('http_headers', {}).update(self._M3U8_HEADERS)
-        return m3u8_formats
-
-
-class PeriscopeIE(PeriscopeBaseIE):
-    IE_DESC = 'Periscope'
-    IE_NAME = 'periscope'
-    _VALID_URL = r'https?://(?:www\.)?(?:periscope|pscp)\.tv/[^/]+/(?P<id>[^/?#]+)'
-    _EMBED_REGEX = [r'<iframe[^>]+src=([\'"])(?P<url>(?:https?:)?//(?:www\.)?(?:periscope|pscp)\.tv/(?:(?!\1).)+)\1']
-    # Alive example URLs can be found here https://www.periscope.tv/
-    _TESTS = [{
-        'url': 'https://www.periscope.tv/w/aJUQnjY3MjA3ODF8NTYxMDIyMDl2zCg2pECBgwTqRpQuQD352EMPTKQjT4uqlM3cgWFA-g==',
-        'md5': '65b57957972e503fcbbaeed8f4fa04ca',
-        'info_dict': {
-            'id': '56102209',
-            'ext': 'mp4',
-            'title': 'Bec Boop - 🚠✈️🇬🇧 Fly above #London in Emirates Air Line cable car at night 🇬🇧✈️🚠 #BoopScope 🎀💗',
-            'timestamp': 1438978559,
-            'upload_date': '20150807',
-            'uploader': 'Bec Boop',
-            'uploader_id': '1465763',
-        },
-        'skip': 'Expires in 24 hours',
-    }, {
-        'url': 'https://www.periscope.tv/w/1ZkKzPbMVggJv',
-        'only_matching': True,
-    }, {
-        'url': 'https://www.periscope.tv/bastaakanoggano/1OdKrlkZZjOJX',
-        'only_matching': True,
-    }, {
-        'url': 'https://www.periscope.tv/w/1ZkKzPbMVggJv',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        token = self._match_id(url)
-
-        stream = self._call_api(
-            'accessVideoPublic', {'broadcast_id': token}, token)
-
-        broadcast = stream['broadcast']
-        info = self._parse_broadcast_data(broadcast, token)
-
-        state = broadcast.get('state').lower()
-        width = int_or_none(broadcast.get('width'))
-        height = int_or_none(broadcast.get('height'))
-
-        def add_width_and_height(f):
-            for key, val in (('width', width), ('height', height)):
-                if not f.get(key):
-                    f[key] = val
-
-        video_urls = set()
-        formats = []
-        for format_id in ('replay', 'rtmp', 'hls', 'https_hls', 'lhls', 'lhlsweb'):
-            video_url = stream.get(format_id + '_url')
-            if not video_url or video_url in video_urls:
-                continue
-            video_urls.add(video_url)
-            if format_id != 'rtmp':
-                m3u8_formats = self._extract_pscp_m3u8_formats(
-                    video_url, token, format_id, state, width, height, False)
-                formats.extend(m3u8_formats)
-                continue
-            rtmp_format = {
-                'url': video_url,
-                'ext': 'flv' if format_id == 'rtmp' else 'mp4',
-            }
-            self._add_width_and_height(rtmp_format)
-            formats.append(rtmp_format)
-
-        info['formats'] = formats
-        return info
-
-
-class PeriscopeUserIE(PeriscopeBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?(?:periscope|pscp)\.tv/(?P<id>[^/]+)/?$'
-    IE_DESC = 'Periscope user videos'
-    IE_NAME = 'periscope:user'
-
-    _TEST = {
-        'url': 'https://www.periscope.tv/LularoeHusbandMike/',
-        'info_dict': {
-            'id': 'LularoeHusbandMike',
-            'title': 'LULAROE HUSBAND MIKE',
-            'description': 'md5:6cf4ec8047768098da58e446e82c82f0',
-        },
-        # Periscope only shows videos in the last 24 hours, so it's possible to
-        # get 0 videos
-        'playlist_mincount': 0,
-    }
-
-    def _real_extract(self, url):
-        user_name = self._match_id(url)
-
-        webpage = self._download_webpage(url, user_name)
-
-        data_store = self._parse_json(
-            unescapeHTML(self._search_regex(
-                r'data-store=(["\'])(?P<data>.+?)\1',
-                webpage, 'data store', default='{}', group='data')),
-            user_name)
-
-        user = list(data_store['UserCache']['users'].values())[0]['user']
-        user_id = user['id']
-        session_id = data_store['SessionToken']['public']['broadcastHistory']['token']['session_id']
-
-        broadcasts = self._call_api(
-            'getUserBroadcastsPublic',
-            {'user_id': user_id, 'session_id': session_id},
-            user_name)['broadcasts']
-
-        broadcast_ids = [
-            broadcast['id'] for broadcast in broadcasts if broadcast.get('id')]
-
-        title = user.get('display_name') or user.get('username') or user_name
-        description = user.get('description')
-
-        entries = [
-            self.url_result(
-                'https://www.periscope.tv/%s/%s' % (user_name, broadcast_id))
-            for broadcast_id in broadcast_ids]
-
-        return self.playlist_result(entries, user_id, title, description)

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

@@ -1,47 +0,0 @@
-from .brightcove import BrightcoveNewIE
-from .common import InfoExtractor
-
-
-class PGATourIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?pgatour\.com/video/[\w-]+/(?P<tc>T)?(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://www.pgatour.com/video/competition/T6322447785112/adam-hadwin-2023-the-players-round-4-18th-hole-shot-1',
-        'info_dict': {
-            'id': '6322447785112',
-            'ext': 'mp4',
-            'title': 'Adam Hadwin | 2023 THE PLAYERS | Round 4 | 18th hole | Shot 1',
-            'uploader_id': '6116716431001',
-            'upload_date': '20230312',
-            'timestamp': 1678653136,
-            'duration': 20.011,
-            'thumbnail': r're:^https://.+\.jpg',
-            'tags': 'count:7',
-        },
-        'params': {'skip_download': 'm3u8'},
-    }, {
-        'url': 'https://www.pgatour.com/video/features/6322506425112/follow-the-players-trophy-on-championship-sunday',
-        'info_dict': {
-            'id': '6322506425112',
-            'ext': 'mp4',
-            'title': 'Follow THE PLAYERS trophy on Championship Sunday',
-            'description': 'md5:4d29e4bdfa03694a0ebfd08950398568',
-            'uploader_id': '6082840763001',
-            'upload_date': '20230313',
-            'timestamp': 1678739835,
-            'duration': 123.435,
-            'thumbnail': r're:^https://.+\.jpg',
-            'tags': 'count:8',
-        },
-        'params': {'skip_download': 'm3u8'},
-    }]
-
-    def _real_extract(self, url):
-        video_id, is_tourcast = self._match_valid_url(url).group('id', 'tc')
-
-        # From https://www.pgatour.com/_next/static/chunks/pages/_app-8bcf849560daf38d.js
-        account_id = '6116716431001' if is_tourcast else '6082840763001'
-        player_id = 'Vsd5Umu8r' if is_tourcast else 'FWIBYMBPj'
-
-        return self.url_result(
-            f'https://players.brightcove.net/{account_id}/{player_id}_default/index.html?videoId={video_id}',
-            BrightcoveNewIE)