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

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

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

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

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