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

@@ -1,261 +0,0 @@
-import base64
-import random
-import re
-import urllib.parse
-
-from .common import InfoExtractor
-from ..utils import (
-    ExtractorError,
-    clean_html,
-    time_seconds,
-    try_call,
-    unified_timestamp,
-    update_url_query,
-)
-from ..utils.traversal import traverse_obj
-
-
-class RadikoBaseIE(InfoExtractor):
-    _GEO_BYPASS = False
-    _FULL_KEY = None
-    _HOSTS_FOR_TIME_FREE_FFMPEG_UNSUPPORTED = (
-        'https://c-rpaa.smartstream.ne.jp',
-        'https://si-c-radiko.smartstream.ne.jp',
-        'https://tf-f-rpaa-radiko.smartstream.ne.jp',
-        'https://tf-c-rpaa-radiko.smartstream.ne.jp',
-        'https://si-f-radiko.smartstream.ne.jp',
-        'https://rpaa.smartstream.ne.jp',
-    )
-    _HOSTS_FOR_TIME_FREE_FFMPEG_SUPPORTED = (
-        'https://rd-wowza-radiko.radiko-cf.com',
-        'https://radiko.jp',
-        'https://f-radiko.smartstream.ne.jp',
-    )
-    # Following URL forcibly connects not Time Free but Live
-    _HOSTS_FOR_LIVE = (
-        'https://c-radiko.smartstream.ne.jp',
-    )
-
-    def _negotiate_token(self):
-        _, auth1_handle = self._download_webpage_handle(
-            'https://radiko.jp/v2/api/auth1', None, 'Downloading authentication page',
-            headers={
-                'x-radiko-app': 'pc_html5',
-                'x-radiko-app-version': '0.0.1',
-                'x-radiko-device': 'pc',
-                'x-radiko-user': 'dummy_user',
-            })
-        auth1_header = auth1_handle.headers
-
-        auth_token = auth1_header['X-Radiko-AuthToken']
-        kl = int(auth1_header['X-Radiko-KeyLength'])
-        ko = int(auth1_header['X-Radiko-KeyOffset'])
-        raw_partial_key = self._extract_full_key()[ko:ko + kl]
-        partial_key = base64.b64encode(raw_partial_key).decode()
-
-        area_id = self._download_webpage(
-            'https://radiko.jp/v2/api/auth2', None, 'Authenticating',
-            headers={
-                'x-radiko-device': 'pc',
-                'x-radiko-user': 'dummy_user',
-                'x-radiko-authtoken': auth_token,
-                'x-radiko-partialkey': partial_key,
-            }).split(',')[0]
-
-        if area_id == 'OUT':
-            self.raise_geo_restricted(countries=['JP'])
-
-        auth_data = (auth_token, area_id)
-        self.cache.store('radiko', 'auth_data', auth_data)
-        return auth_data
-
-    def _auth_client(self):
-        cachedata = self.cache.load('radiko', 'auth_data')
-        if cachedata is not None:
-            response = self._download_webpage(
-                'https://radiko.jp/v2/api/auth_check', None, 'Checking cached token', expected_status=401,
-                headers={'X-Radiko-AuthToken': cachedata[0], 'X-Radiko-AreaId': cachedata[1]})
-            if response == 'OK':
-                return cachedata
-        return self._negotiate_token()
-
-    def _extract_full_key(self):
-        if self._FULL_KEY:
-            return self._FULL_KEY
-
-        jscode = self._download_webpage(
-            'https://radiko.jp/apps/js/playerCommon.js', None,
-            note='Downloading player js code')
-        full_key = self._search_regex(
-            (r"RadikoJSPlayer\([^,]*,\s*(['\"])pc_html5\1,\s*(['\"])(?P<fullkey>[0-9a-f]+)\2,\s*{"),
-            jscode, 'full key', fatal=False, group='fullkey')
-
-        if full_key:
-            full_key = full_key.encode()
-        else:  # use only full key ever known
-            full_key = b'bcd151073c03b352e1ef2fd66c32209da9ca0afa'
-
-        self._FULL_KEY = full_key
-        return full_key
-
-    def _find_program(self, video_id, station, cursor):
-        station_program = self._download_xml(
-            'https://radiko.jp/v3/program/station/weekly/%s.xml' % station, video_id,
-            note='Downloading radio program for %s station' % station)
-
-        prog = None
-        for p in station_program.findall('.//prog'):
-            ft_str, to_str = p.attrib['ft'], p.attrib['to']
-            ft = unified_timestamp(ft_str, False)
-            to = unified_timestamp(to_str, False)
-            if ft <= cursor and cursor < to:
-                prog = p
-                break
-        if not prog:
-            raise ExtractorError('Cannot identify radio program to download!')
-        assert ft, to
-        return prog, station_program, ft, ft_str, to_str
-
-    def _extract_formats(self, video_id, station, is_onair, ft, cursor, auth_token, area_id, query):
-        m3u8_playlist_data = self._download_xml(
-            f'https://radiko.jp/v3/station/stream/pc_html5/{station}.xml', video_id,
-            note='Downloading stream information')
-
-        formats = []
-        found = set()
-
-        timefree_int = 0 if is_onair else 1
-
-        for element in m3u8_playlist_data.findall(f'.//url[@timefree="{timefree_int}"]/playlist_create_url'):
-            pcu = element.text
-            if pcu in found:
-                continue
-            found.add(pcu)
-            playlist_url = update_url_query(pcu, {
-                'station_id': station,
-                **query,
-                'l': '15',
-                'lsid': ''.join(random.choices('0123456789abcdef', k=32)),
-                'type': 'b',
-            })
-
-            time_to_skip = None if is_onair else cursor - ft
-
-            domain = urllib.parse.urlparse(playlist_url).netloc
-            subformats = self._extract_m3u8_formats(
-                playlist_url, video_id, ext='m4a',
-                live=True, fatal=False, m3u8_id=domain,
-                note=f'Downloading m3u8 information from {domain}',
-                headers={
-                    'X-Radiko-AreaId': area_id,
-                    'X-Radiko-AuthToken': auth_token,
-                })
-            for sf in subformats:
-                if (is_onair ^ pcu.startswith(self._HOSTS_FOR_LIVE)) or (
-                        not is_onair and pcu.startswith(self._HOSTS_FOR_TIME_FREE_FFMPEG_UNSUPPORTED)):
-                    sf['preference'] = -100
-                    sf['format_note'] = 'not preferred'
-                if not is_onair and timefree_int == 1 and time_to_skip:
-                    sf['downloader_options'] = {'ffmpeg_args': ['-ss', str(time_to_skip)]}
-            formats.extend(subformats)
-
-        return formats
-
-    def _extract_performers(self, prog):
-        return traverse_obj(prog, (
-            'pfm/text()', ..., {lambda x: re.split(r'[/／、　,，]', x)}, ..., {str.strip})) or None
-
-
-class RadikoIE(RadikoBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?radiko\.jp/#!/ts/(?P<station>[A-Z0-9-]+)/(?P<id>\d+)'
-
-    _TESTS = [{
-        # QRR (文化放送) station provides <desc>
-        'url': 'https://radiko.jp/#!/ts/QRR/20210425101300',
-        'only_matching': True,
-    }, {
-        # FMT (TOKYO FM) station does not provide <desc>
-        'url': 'https://radiko.jp/#!/ts/FMT/20210810150000',
-        'only_matching': True,
-    }, {
-        'url': 'https://radiko.jp/#!/ts/JOAK-FM/20210509090000',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        station, video_id = self._match_valid_url(url).groups()
-        vid_int = unified_timestamp(video_id, False)
-        prog, station_program, ft, radio_begin, radio_end = self._find_program(video_id, station, vid_int)
-
-        auth_token, area_id = self._auth_client()
-
-        return {
-            'id': video_id,
-            'title': try_call(lambda: prog.find('title').text),
-            'cast': self._extract_performers(prog),
-            'description': clean_html(try_call(lambda: prog.find('info').text)),
-            'uploader': try_call(lambda: station_program.find('.//name').text),
-            'uploader_id': station,
-            'timestamp': vid_int,
-            'duration': try_call(lambda: unified_timestamp(radio_end, False) - unified_timestamp(radio_begin, False)),
-            'is_live': True,
-            'formats': self._extract_formats(
-                video_id=video_id, station=station, is_onair=False,
-                ft=ft, cursor=vid_int, auth_token=auth_token, area_id=area_id,
-                query={
-                    'start_at': radio_begin,
-                    'ft': radio_begin,
-                    'end_at': radio_end,
-                    'to': radio_end,
-                    'seek': video_id
-                }
-            ),
-        }
-
-
-class RadikoRadioIE(RadikoBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?radiko\.jp/#!/live/(?P<id>[A-Z0-9-]+)'
-
-    _TESTS = [{
-        # QRR (文化放送) station provides <desc>
-        'url': 'https://radiko.jp/#!/live/QRR',
-        'only_matching': True,
-    }, {
-        # FMT (TOKYO FM) station does not provide <desc>
-        'url': 'https://radiko.jp/#!/live/FMT',
-        'only_matching': True,
-    }, {
-        'url': 'https://radiko.jp/#!/live/JOAK-FM',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        station = self._match_id(url)
-        self.report_warning('Downloader will not stop at the end of the program! Press Ctrl+C to stop')
-
-        auth_token, area_id = self._auth_client()
-        # get current time in JST (GMT+9:00 w/o DST)
-        vid_now = time_seconds(hours=9)
-
-        prog, station_program, ft, _, _ = self._find_program(station, station, vid_now)
-
-        title = prog.find('title').text
-        description = clean_html(prog.find('info').text)
-        station_name = station_program.find('.//name').text
-
-        formats = self._extract_formats(
-            video_id=station, station=station, is_onair=True,
-            ft=ft, cursor=vid_now, auth_token=auth_token, area_id=area_id,
-            query={})
-
-        return {
-            'id': station,
-            'title': title,
-            'cast': self._extract_performers(prog),
-            'description': description,
-            'uploader': station_name,
-            'uploader_id': station,
-            'timestamp': ft,
-            'formats': formats,
-            'is_live': True,
-        }

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

@@ -1,165 +0,0 @@
-from .common import InfoExtractor
-from ..networking.exceptions import HTTPError
-from ..utils import (
-    determine_ext,
-    ExtractorError,
-    int_or_none,
-    unified_strdate,
-)
-
-
-class RadioCanadaIE(InfoExtractor):
-    IE_NAME = 'radiocanada'
-    _VALID_URL = r'(?:radiocanada:|https?://ici\.radio-canada\.ca/widgets/mediaconsole/)(?P<app_code>[^:/]+)[:/](?P<id>[0-9]+)'
-    _TESTS = [
-        {
-            'url': 'http://ici.radio-canada.ca/widgets/mediaconsole/medianet/7184272',
-            'info_dict': {
-                'id': '7184272',
-                'ext': 'mp4',
-                'title': 'Le parcours du tireur capté sur vidéo',
-                'description': 'Images des caméras de surveillance fournies par la GRC montrant le parcours du tireur d\'Ottawa',
-                'upload_date': '20141023',
-            },
-            'params': {
-                # m3u8 download
-                'skip_download': True,
-            }
-        },
-        {
-            # empty Title
-            'url': 'http://ici.radio-canada.ca/widgets/mediaconsole/medianet/7754998/',
-            'info_dict': {
-                'id': '7754998',
-                'ext': 'mp4',
-                'title': 'letelejournal22h',
-                'description': 'INTEGRALE WEB 22H-TJ',
-                'upload_date': '20170720',
-            },
-            'params': {
-                # m3u8 download
-                'skip_download': True,
-            },
-        },
-        {
-            # with protectionType but not actually DRM protected
-            'url': 'radiocanada:toutv:140872',
-            'info_dict': {
-                'id': '140872',
-                'title': 'Épisode 1',
-                'series': 'District 31',
-            },
-            'only_matching': True,
-        }
-    ]
-    _GEO_COUNTRIES = ['CA']
-    _access_token = None
-    _claims = None
-
-    def _call_api(self, path, video_id=None, app_code=None, query=None):
-        if not query:
-            query = {}
-        query.update({
-            'client_key': '773aea60-0e80-41bb-9c7f-e6d7c3ad17fb',
-            'output': 'json',
-        })
-        if video_id:
-            query.update({
-                'appCode': app_code,
-                'idMedia': video_id,
-            })
-        if self._access_token:
-            query['access_token'] = self._access_token
-        try:
-            return self._download_json(
-                'https://services.radio-canada.ca/media/' + path, video_id, query=query)
-        except ExtractorError as e:
-            if isinstance(e.cause, HTTPError) and e.cause.status in (401, 422):
-                data = self._parse_json(e.cause.response.read().decode(), None)
-                error = data.get('error_description') or data['errorMessage']['text']
-                raise ExtractorError(error, expected=True)
-            raise
-
-    def _extract_info(self, app_code, video_id):
-        metas = self._call_api('meta/v1/index.ashx', video_id, app_code)['Metas']
-
-        def get_meta(name):
-            for meta in metas:
-                if meta.get('name') == name:
-                    text = meta.get('text')
-                    if text:
-                        return text
-
-        # protectionType does not necessarily mean the video is DRM protected (see
-        # https://github.com/ytdl-org/youtube-dl/pull/18609).
-        if get_meta('protectionType'):
-            self.report_warning('This video is probably DRM protected.')
-
-        query = {
-            'connectionType': 'hd',
-            'deviceType': 'ipad',
-            'multibitrate': 'true',
-        }
-        if self._claims:
-            query['claims'] = self._claims
-        v_data = self._call_api('validation/v2/', video_id, app_code, query)
-        v_url = v_data.get('url')
-        if not v_url:
-            error = v_data['message']
-            if error == "Le contenu sélectionné n'est pas disponible dans votre pays":
-                raise self.raise_geo_restricted(error, self._GEO_COUNTRIES)
-            if error == 'Le contenu sélectionné est disponible seulement en premium':
-                self.raise_login_required(error)
-            raise ExtractorError(
-                '%s said: %s' % (self.IE_NAME, error), expected=True)
-        formats = self._extract_m3u8_formats(v_url, video_id, 'mp4')
-
-        subtitles = {}
-        closed_caption_url = get_meta('closedCaption') or get_meta('closedCaptionHTML5')
-        if closed_caption_url:
-            subtitles['fr'] = [{
-                'url': closed_caption_url,
-                'ext': determine_ext(closed_caption_url, 'vtt'),
-            }]
-
-        return {
-            'id': video_id,
-            'title': get_meta('Title') or get_meta('AV-nomEmission'),
-            'description': get_meta('Description') or get_meta('ShortDescription'),
-            'thumbnail': get_meta('imageHR') or get_meta('imageMR') or get_meta('imageBR'),
-            'duration': int_or_none(get_meta('length')),
-            'series': get_meta('Emission'),
-            'season_number': int_or_none('SrcSaison'),
-            'episode_number': int_or_none('SrcEpisode'),
-            'upload_date': unified_strdate(get_meta('Date')),
-            'subtitles': subtitles,
-            'formats': formats,
-        }
-
-    def _real_extract(self, url):
-        return self._extract_info(*self._match_valid_url(url).groups())
-
-
-class RadioCanadaAudioVideoIE(InfoExtractor):
-    IE_NAME = 'radiocanada:audiovideo'
-    _VALID_URL = r'https?://ici\.radio-canada\.ca/([^/]+/)*media-(?P<id>[0-9]+)'
-    _TESTS = [{
-        'url': 'http://ici.radio-canada.ca/audio-video/media-7527184/barack-obama-au-vietnam',
-        'info_dict': {
-            'id': '7527184',
-            'ext': 'mp4',
-            'title': 'Barack Obama au Vietnam',
-            'description': 'Les États-Unis lèvent l\'embargo sur la vente d\'armes qui datait de la guerre du Vietnam',
-            'upload_date': '20160523',
-        },
-        'params': {
-            # m3u8 download
-            'skip_download': True,
-        },
-    }, {
-        'url': 'https://ici.radio-canada.ca/info/videos/media-7527184/barack-obama-au-vietnam',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        return self.url_result('radiocanada:medianet:%s' % self._match_id(url))

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

@@ -1,154 +0,0 @@
-import itertools
-
-from .common import InfoExtractor
-from ..networking.exceptions import HTTPError
-from ..utils import (
-    ExtractorError,
-    extract_attributes,
-    get_element_by_class,
-    get_element_html_by_class,
-    get_element_text_and_html_by_tag,
-    get_elements_html_by_class,
-    int_or_none,
-    join_nonempty,
-    try_call,
-    unified_strdate,
-    update_url,
-    urljoin
-)
-from ..utils.traversal import traverse_obj
-
-
-class RadioComercialIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?radiocomercial\.pt/podcasts/[^/?#]+/t?(?P<season>\d+)/(?P<id>[\w-]+)'
-    _TESTS = [{
-        'url': 'https://radiocomercial.pt/podcasts/o-homem-que-mordeu-o-cao/t6/taylor-swift-entranhando-se-que-nem-uma-espada-no-ventre-dos-fas#page-content-wrapper',
-        'md5': '5f4fe8e485b29d2e8fd495605bc2c7e4',
-        'info_dict': {
-            'id': 'taylor-swift-entranhando-se-que-nem-uma-espada-no-ventre-dos-fas',
-            'ext': 'mp3',
-            'title': 'Taylor Swift entranhando-se que nem uma espada no ventre dos fãs.',
-            'release_date': '20231025',
-            'thumbnail': r're:https://radiocomercial.pt/upload/[^.]+.jpg',
-            'season': 'Season 6',
-            'season_number': 6,
-        }
-    }, {
-        'url': 'https://radiocomercial.pt/podcasts/convenca-me-num-minuto/t3/convenca-me-num-minuto-que-os-lobisomens-existem',
-        'md5': '47e96c273aef96a8eb160cd6cf46d782',
-        'info_dict': {
-            'id': 'convenca-me-num-minuto-que-os-lobisomens-existem',
-            'ext': 'mp3',
-            'title': 'Convença-me num minuto que os lobisomens existem',
-            'release_date': '20231026',
-            'thumbnail': r're:https://radiocomercial.pt/upload/[^.]+.jpg',
-            'season': 'Season 3',
-            'season_number': 3,
-        }
-    }, {
-        'url': 'https://radiocomercial.pt/podcasts/inacreditavel-by-ines-castel-branco/t2/o-desastre-de-aviao',
-        'md5': '69be64255420fec23b7259955d771e54',
-        'info_dict': {
-            'id': 'o-desastre-de-aviao',
-            'ext': 'mp3',
-            'title': 'O desastre de avião',
-            'description': 'md5:8a82beeb372641614772baab7246245f',
-            'release_date': '20231101',
-            'thumbnail': r're:https://radiocomercial.pt/upload/[^.]+.jpg',
-            'season': 'Season 2',
-            'season_number': 2,
-        },
-        'params': {
-            # inconsistant md5
-            'skip_download': True,
-        },
-    }, {
-        'url': 'https://radiocomercial.pt/podcasts/tnt-todos-no-top/2023/t-n-t-29-de-outubro',
-        'md5': '91d32d4d4b1407272068b102730fc9fa',
-        'info_dict': {
-            'id': 't-n-t-29-de-outubro',
-            'ext': 'mp3',
-            'title': 'T.N.T 29 de outubro',
-            'release_date': '20231029',
-            'thumbnail': r're:https://radiocomercial.pt/upload/[^.]+.jpg',
-            'season': 'Season 2023',
-            'season_number': 2023,
-        }
-    }]
-
-    def _real_extract(self, url):
-        video_id, season = self._match_valid_url(url).group('id', 'season')
-        webpage = self._download_webpage(url, video_id)
-        return {
-            'id': video_id,
-            'title': self._html_extract_title(webpage),
-            'description': self._og_search_description(webpage, default=None),
-            'release_date': unified_strdate(get_element_by_class(
-                'date', get_element_html_by_class('descriptions', webpage) or '')),
-            'thumbnail': self._og_search_thumbnail(webpage),
-            'season_number': int_or_none(season),
-            'url': extract_attributes(get_element_html_by_class('audiofile', webpage) or '').get('href'),
-        }
-
-
-class RadioComercialPlaylistIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:www\.)?radiocomercial\.pt/podcasts/(?P<id>[\w-]+)(?:/t?(?P<season>\d+))?/?(?:$|[?#])'
-    _TESTS = [{
-        'url': 'https://radiocomercial.pt/podcasts/convenca-me-num-minuto/t3',
-        'info_dict': {
-            'id': 'convenca-me-num-minuto_t3',
-            'title': 'Convença-me num Minuto - Temporada 3',
-        },
-        'playlist_mincount': 32
-    }, {
-        'url': 'https://radiocomercial.pt/podcasts/o-homem-que-mordeu-o-cao',
-        'info_dict': {
-            'id': 'o-homem-que-mordeu-o-cao',
-            'title': 'O Homem Que Mordeu o Cão',
-        },
-        'playlist_mincount': 19
-    }, {
-        'url': 'https://radiocomercial.pt/podcasts/as-minhas-coisas-favoritas',
-        'info_dict': {
-            'id': 'as-minhas-coisas-favoritas',
-            'title': 'As Minhas Coisas Favoritas',
-        },
-        'playlist_mincount': 131
-    }, {
-        'url': 'https://radiocomercial.pt/podcasts/tnt-todos-no-top/t2023',
-        'info_dict': {
-            'id': 'tnt-todos-no-top_t2023',
-            'title': 'TNT - Todos No Top - Temporada 2023',
-        },
-        'playlist_mincount': 39
-    }]
-
-    def _entries(self, url, playlist_id):
-        for page in itertools.count(1):
-            try:
-                webpage = self._download_webpage(
-                    f'{url}/{page}', playlist_id, f'Downloading page {page}')
-            except ExtractorError as e:
-                if isinstance(e.cause, HTTPError) and e.cause.status == 404:
-                    break
-                raise
-
-            episodes = get_elements_html_by_class('tm-ouvir-podcast', webpage)
-            if not episodes:
-                break
-            for url_path in traverse_obj(episodes, (..., {extract_attributes}, 'href')):
-                episode_url = urljoin(url, url_path)
-                if RadioComercialIE.suitable(episode_url):
-                    yield episode_url
-
-    def _real_extract(self, url):
-        podcast, season = self._match_valid_url(url).group('id', 'season')
-        playlist_id = join_nonempty(podcast, season, delim='_t')
-        url = update_url(url, query=None, fragment=None)
-        webpage = self._download_webpage(url, playlist_id)
-
-        name = try_call(lambda: get_element_text_and_html_by_tag('h1', webpage)[0])
-        title = name if name == season else join_nonempty(name, season, delim=' - Temporada ')
-
-        return self.playlist_from_matches(
-            self._entries(url, playlist_id), playlist_id, title, ie=RadioComercialIE)

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

@@ -1,50 +0,0 @@
-from .common import InfoExtractor
-
-
-class RadioDeIE(InfoExtractor):
-    _WORKING = False
-    IE_NAME = 'radio.de'
-    _VALID_URL = r'https?://(?P<id>.+?)\.(?:radio\.(?:de|at|fr|pt|es|pl|it)|rad\.io)'
-    _TEST = {
-        'url': 'http://ndr2.radio.de/',
-        'info_dict': {
-            'id': 'ndr2',
-            'ext': 'mp3',
-            'title': 're:^NDR 2 [0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}$',
-            'description': 'md5:591c49c702db1a33751625ebfb67f273',
-            'thumbnail': r're:^https?://.*\.png',
-            'is_live': True,
-        },
-        'params': {
-            'skip_download': True,
-        }
-    }
-
-    def _real_extract(self, url):
-        radio_id = self._match_id(url)
-        webpage = self._download_webpage(url, radio_id)
-        jscode = self._search_regex(
-            r"'components/station/stationService':\s*\{\s*'?station'?:\s*(\{.*?\s*\}),\n",
-            webpage, 'broadcast')
-
-        broadcast = self._parse_json(jscode, radio_id)
-        title = broadcast['name']
-        description = broadcast.get('description') or broadcast.get('shortDescription')
-        thumbnail = broadcast.get('picture4Url') or broadcast.get('picture4TransUrl') or broadcast.get('logo100x100')
-
-        formats = [{
-            'url': stream['streamUrl'],
-            'ext': stream['streamContentFormat'].lower(),
-            'acodec': stream['streamContentFormat'],
-            'abr': stream['bitRate'],
-            'asr': stream['sampleRate']
-        } for stream in broadcast['streamUrls']]
-
-        return {
-            'id': radio_id,
-            'title': title,
-            'description': description,
-            'thumbnail': thumbnail,
-            'is_live': True,
-            'formats': formats,
-        }