[ie/niconico:live] Support age-restricted streams (#13549)

Authored by: doe1080

yt_dlp/extractor/_extractors.py

@@ -58,13 +58,7 @@ from .adn import (
     ADNSeasonIE,
 )
 from .adobeconnect import AdobeConnectIE
-from .adobetv import (
+from .adobetv import AdobeTVVideoIE
-    AdobeTVChannelIE,
-    AdobeTVEmbedIE,
-    AdobeTVIE,
-    AdobeTVShowIE,
-    AdobeTVVideoIE,
-)
 from .adultswim import AdultSwimIE
 from .aenetworks import (
     AENetworksCollectionIE,
@@ -152,7 +146,6 @@ from .ard import (
     ARDBetaMediathekIE,
     ARDMediathekCollectionIE,
 )
-from .arkena import ArkenaIE
 from .arnes import ArnesIE
 from .art19 import (
     Art19IE,
@@ -1548,7 +1541,6 @@ from .pixivsketch import (
     PixivSketchIE,
     PixivSketchUserIE,
 )
-from .pladform import PladformIE
 from .planetmarathi import PlanetMarathiIE
 from .platzi import (
     PlatziCourseIE,
@@ -2313,10 +2305,6 @@ from .varzesh3 import Varzesh3IE
 from .vbox7 import Vbox7IE
 from .veo import VeoIE
 from .vesti import VestiIE
-from .vevo import (
-    VevoIE,
-    VevoPlaylistIE,
-)
 from .vgtv import (
     VGTVIE,
     BTArticleIE,

yt_dlp/extractor/adobetv.py

@@ -1,297 +1,100 @@
-import functools
-import re
-
 from .common import InfoExtractor
 from ..utils import (
     ISO639Utils,
-    OnDemandPagedList,
+    clean_html,
+    determine_ext,
     float_or_none,
     int_or_none,
     join_nonempty,
-    parse_duration,
+    url_or_none,
-    str_or_none,
-    str_to_int,
-    unified_strdate,
 )
+from ..utils.traversal import traverse_obj
 
 
-class AdobeTVBaseIE(InfoExtractor):
+class AdobeTVVideoIE(InfoExtractor):
-    def _call_api(self, path, video_id, query, note=None):
-        return self._download_json(
-            'http://tv.adobe.com/api/v4/' + path,
-            video_id, note, query=query)['data']
-
-    def _parse_subtitles(self, video_data, url_key):
-        subtitles = {}
-        for translation in video_data.get('translations', []):
-            vtt_path = translation.get(url_key)
-            if not vtt_path:
-                continue
-            lang = translation.get('language_w3c') or ISO639Utils.long2short(translation['language_medium'])
-            subtitles.setdefault(lang, []).append({
-                'ext': 'vtt',
-                'url': vtt_path,
-            })
-        return subtitles
-
-    def _parse_video_data(self, video_data):
-        video_id = str(video_data['id'])
-        title = video_data['title']
-
-        s3_extracted = False
-        formats = []
-        for source in video_data.get('videos', []):
-            source_url = source.get('url')
-            if not source_url:
-                continue
-            f = {
-                'format_id': source.get('quality_level'),
-                'fps': int_or_none(source.get('frame_rate')),
-                'height': int_or_none(source.get('height')),
-                'tbr': int_or_none(source.get('video_data_rate')),
-                'width': int_or_none(source.get('width')),
-                'url': source_url,
-            }
-            original_filename = source.get('original_filename')
-            if original_filename:
-                if not (f.get('height') and f.get('width')):
-                    mobj = re.search(r'_(\d+)x(\d+)', original_filename)
-                    if mobj:
-                        f.update({
-                            'height': int(mobj.group(2)),
-                            'width': int(mobj.group(1)),
-                        })
-                if original_filename.startswith('s3://') and not s3_extracted:
-                    formats.append({
-                        'format_id': 'original',
-                        'quality': 1,
-                        'url': original_filename.replace('s3://', 'https://s3.amazonaws.com/'),
-                    })
-                    s3_extracted = True
-            formats.append(f)
-
-        return {
-            'id': video_id,
-            'title': title,
-            'description': video_data.get('description'),
-            'thumbnail': video_data.get('thumbnail'),
-            'upload_date': unified_strdate(video_data.get('start_date')),
-            'duration': parse_duration(video_data.get('duration')),
-            'view_count': str_to_int(video_data.get('playcount')),
-            'formats': formats,
-            'subtitles': self._parse_subtitles(video_data, 'vtt'),
-        }
-
-
-class AdobeTVEmbedIE(AdobeTVBaseIE):
-    _WORKING = False
-    IE_NAME = 'adobetv:embed'
-    _VALID_URL = r'https?://tv\.adobe\.com/embed/\d+/(?P<id>\d+)'
-    _TESTS = [{
-        'url': 'https://tv.adobe.com/embed/22/4153',
-        'md5': 'c8c0461bf04d54574fc2b4d07ac6783a',
-        'info_dict': {
-            'id': '4153',
-            'ext': 'flv',
-            'title': 'Creating Graphics Optimized for BlackBerry',
-            'description': 'md5:eac6e8dced38bdaae51cd94447927459',
-            'thumbnail': r're:https?://.+\.jpg',
-            'upload_date': '20091109',
-            'duration': 377,
-            'view_count': int,
-        },
-    }]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-
-        video_data = self._call_api(
-            'episode/' + video_id, video_id, {'disclosure': 'standard'})[0]
-        return self._parse_video_data(video_data)
-
-
-class AdobeTVIE(AdobeTVBaseIE):
-    _WORKING = False
     IE_NAME = 'adobetv'
-    _VALID_URL = r'https?://tv\.adobe\.com/(?:(?P<language>fr|de|es|jp)/)?watch/(?P<show_urlname>[^/]+)/(?P<id>[^/]+)'
-    _TESTS = [{
-        'url': 'http://tv.adobe.com/watch/the-complete-picture-with-julieanne-kost/quick-tip-how-to-draw-a-circle-around-an-object-in-photoshop/',
-        'md5': '9bc5727bcdd55251f35ad311ca74fa1e',
-        'info_dict': {
-            'id': '10981',
-            'ext': 'mp4',
-            'title': 'Quick Tip - How to Draw a Circle Around an Object in Photoshop',
-            'description': 'md5:99ec318dc909d7ba2a1f2b038f7d2311',
-            'thumbnail': r're:https?://.+\.jpg',
-            'upload_date': '20110914',
-            'duration': 60,
-            'view_count': int,
-        },
-    }]
-
-    def _real_extract(self, url):
-        language, show_urlname, urlname = self._match_valid_url(url).groups()
-        if not language:
-            language = 'en'
-
-        video_data = self._call_api(
-            'episode/get', urlname, {
-                'disclosure': 'standard',
-                'language': language,
-                'show_urlname': show_urlname,
-                'urlname': urlname,
-            })[0]
-        return self._parse_video_data(video_data)
-
-
-class AdobeTVPlaylistBaseIE(AdobeTVBaseIE):
-    _PAGE_SIZE = 25
-
-    def _fetch_page(self, display_id, query, page):
-        page += 1
-        query['page'] = page
-        for element_data in self._call_api(
-                self._RESOURCE, display_id, query, f'Download Page {page}'):
-            yield self._process_data(element_data)
-
-    def _extract_playlist_entries(self, display_id, query):
-        return OnDemandPagedList(functools.partial(
-            self._fetch_page, display_id, query), self._PAGE_SIZE)
-
-
-class AdobeTVShowIE(AdobeTVPlaylistBaseIE):
-    _WORKING = False
-    IE_NAME = 'adobetv:show'
-    _VALID_URL = r'https?://tv\.adobe\.com/(?:(?P<language>fr|de|es|jp)/)?show/(?P<id>[^/]+)'
-    _TESTS = [{
-        'url': 'http://tv.adobe.com/show/the-complete-picture-with-julieanne-kost',
-        'info_dict': {
-            'id': '36',
-            'title': 'The Complete Picture with Julieanne Kost',
-            'description': 'md5:fa50867102dcd1aa0ddf2ab039311b27',
-        },
-        'playlist_mincount': 136,
-    }]
-    _RESOURCE = 'episode'
-    _process_data = AdobeTVBaseIE._parse_video_data
-
-    def _real_extract(self, url):
-        language, show_urlname = self._match_valid_url(url).groups()
-        if not language:
-            language = 'en'
-        query = {
-            'disclosure': 'standard',
-            'language': language,
-            'show_urlname': show_urlname,
-        }
-
-        show_data = self._call_api(
-            'show/get', show_urlname, query)[0]
-
-        return self.playlist_result(
-            self._extract_playlist_entries(show_urlname, query),
-            str_or_none(show_data.get('id')),
-            show_data.get('show_name'),
-            show_data.get('show_description'))
-
-
-class AdobeTVChannelIE(AdobeTVPlaylistBaseIE):
-    _WORKING = False
-    IE_NAME = 'adobetv:channel'
-    _VALID_URL = r'https?://tv\.adobe\.com/(?:(?P<language>fr|de|es|jp)/)?channel/(?P<id>[^/]+)(?:/(?P<category_urlname>[^/]+))?'
-    _TESTS = [{
-        'url': 'http://tv.adobe.com/channel/development',
-        'info_dict': {
-            'id': 'development',
-        },
-        'playlist_mincount': 96,
-    }]
-    _RESOURCE = 'show'
-
-    def _process_data(self, show_data):
-        return self.url_result(
-            show_data['url'], 'AdobeTVShow', str_or_none(show_data.get('id')))
-
-    def _real_extract(self, url):
-        language, channel_urlname, category_urlname = self._match_valid_url(url).groups()
-        if not language:
-            language = 'en'
-        query = {
-            'channel_urlname': channel_urlname,
-            'language': language,
-        }
-        if category_urlname:
-            query['category_urlname'] = category_urlname
-
-        return self.playlist_result(
-            self._extract_playlist_entries(channel_urlname, query),
-            channel_urlname)
-
-
-class AdobeTVVideoIE(AdobeTVBaseIE):
-    IE_NAME = 'adobetv:video'
     _VALID_URL = r'https?://video\.tv\.adobe\.com/v/(?P<id>\d+)'
-    _EMBED_REGEX = [r'<iframe[^>]+src=[\'"](?P<url>(?:https?:)?//video\.tv\.adobe\.com/v/\d+[^"]+)[\'"]']
+    _EMBED_REGEX = [r'<iframe[^>]+src=["\'](?P<url>(?:https?:)?//video\.tv\.adobe\.com/v/\d+)']
     _TESTS = [{
-        # From https://helpx.adobe.com/acrobat/how-to/new-experience-acrobat-dc.html?set=acrobat--get-started--essential-beginners
+        'url': 'https://video.tv.adobe.com/v/2456',
-        'url': 'https://video.tv.adobe.com/v/2456/',
         'md5': '43662b577c018ad707a63766462b1e87',
         'info_dict': {
             'id': '2456',
             'ext': 'mp4',
             'title': 'New experience with Acrobat DC',
             'description': 'New experience with Acrobat DC',
-            'duration': 248.667,
+            'duration': 248.522,
+            'thumbnail': r're:https?://images-tv\.adobe\.com/.+\.jpg',
+        },
+    }, {
+        'url': 'https://video.tv.adobe.com/v/3463980/adobe-acrobat',
+        'info_dict': {
+            'id': '3463980',
+            'ext': 'mp4',
+            'title': 'Adobe Acrobat: How to Customize the Toolbar for Faster PDF Editing',
+            'description': 'md5:94368ab95ae24f9c1bee0cb346e03dc3',
+            'duration': 97.514,
             'thumbnail': r're:https?://images-tv\.adobe\.com/.+\.jpg',
         },
     }]
     _WEBPAGE_TESTS = [{
-        # FIXME: Invalid extension
+        # https://video.tv.adobe.com/v/3442499
-        'url': 'https://www.adobe.com/learn/acrobat/web/customize-toolbar',
+        'url': 'https://business.adobe.com/dx-fragments/summit/2025/marquees/S335/ondemand.live.html',
         'info_dict': {
-            'id': '3463980',
+            'id': '3442499',
-            'ext': 'm3u8',
+            'ext': 'mp4',
-            'title': 'Adobe Acrobat: How to Customize the Toolbar for Faster PDF Editing',
+            'title': 'S335 - Beyond Personalization: Creating Intent-Based Experiences at Scale',
-            'description': 'md5:94368ab95ae24f9c1bee0cb346e03dc3',
+            'description': 'Beyond Personalization: Creating Intent-Based Experiences at Scale',
-            'duration': 97.557,
+            'duration': 2906.8,
+            'thumbnail': r're:https?://images-tv\.adobe\.com/.+\.jpg',
         },
     }]
 
     def _real_extract(self, url):
         video_id = self._match_id(url)
         webpage = self._download_webpage(url, video_id)
-
+        video_data = self._search_json(
-        video_data = self._parse_json(self._search_regex(
+            r'var\s+bridge\s*=', webpage, 'bridged data', video_id)
-            r'var\s+bridge\s*=\s*([^;]+);', webpage, 'bridged data'), video_id)
-        title = video_data['title']
 
         formats = []
-        sources = video_data.get('sources') or []
+        for source in traverse_obj(video_data, (
-        for source in sources:
+            'sources', lambda _, v: v['format'] != 'playlist' and url_or_none(v['src']),
-            source_src = source.get('src')
+        )):
-            if not source_src:
+            source_url = self._proto_relative_url(source['src'])
-                continue
+            if determine_ext(source_url) == 'm3u8':
-            formats.append({
+                fmts = self._extract_m3u8_formats(
-                'filesize': int_or_none(source.get('kilobytes') or None, invscale=1000),
+                    source_url, video_id, 'mp4', m3u8_id='hls', fatal=False)
-                'format_id': join_nonempty(source.get('format'), source.get('label')),
+            else:
-                'height': int_or_none(source.get('height') or None),
+                fmts = [{'url': source_url}]
-                'tbr': int_or_none(source.get('bitrate') or None),
-                'width': int_or_none(source.get('width') or None),
-                'url': source_src,
-            })
 
-        # For both metadata and downloaded files the duration varies among
+            for fmt in fmts:
-        # formats. I just pick the max one
+                fmt.update(traverse_obj(source, {
-        duration = max(filter(None, [
+                    'duration': ('duration', {float_or_none(scale=1000)}),
-            float_or_none(source.get('duration'), scale=1000)
+                    'filesize': ('kilobytes', {float_or_none(invscale=1000)}),
-            for source in sources]))
+                    'format_id': (('format', 'label'), {str}, all, {lambda x: join_nonempty(*x)}),
+                    'height': ('height', {int_or_none}),
+                    'tbr': ('bitrate', {int_or_none}),
+                    'width': ('width', {int_or_none}),
+                }))
+            formats.extend(fmts)
+
+        subtitles = {}
+        for translation in traverse_obj(video_data, (
+            'translations', lambda _, v: url_or_none(v['vttPath']),
+        )):
+            lang = translation.get('language_w3c') or ISO639Utils.long2short(translation.get('language_medium')) or 'und'
+            subtitles.setdefault(lang, []).append({
+                'ext': 'vtt',
+                'url': self._proto_relative_url(translation['vttPath']),
+            })
 
         return {
             'id': video_id,
             'formats': formats,
-            'title': title,
+            'subtitles': subtitles,
-            'description': video_data.get('description'),
+            **traverse_obj(video_data, {
-            'thumbnail': video_data.get('video', {}).get('poster'),
+                'title': ('title', {clean_html}),
-            'duration': duration,
+                'description': ('description', {clean_html}, filter),
-            'subtitles': self._parse_subtitles(video_data, 'vttPath'),
+                'thumbnail': ('video', 'poster', {self._proto_relative_url}, {url_or_none}),
+            }),
         }

yt_dlp/extractor/arkena.py

@@ -1,150 +0,0 @@
-from .common import InfoExtractor
-from ..utils import (
-    ExtractorError,
-    float_or_none,
-    int_or_none,
-    parse_iso8601,
-    parse_qs,
-    try_get,
-)
-
-
-class ArkenaIE(InfoExtractor):
-    _VALID_URL = r'''(?x)
-                        https?://
-                            (?:
-                                video\.(?:arkena|qbrick)\.com/play2/embed/player\?|
-                                play\.arkena\.com/(?:config|embed)/avp/v\d/player/media/(?P<id>[^/]+)/[^/]+/(?P<account_id>\d+)
-                            )
-                        '''
-    # See https://support.arkena.com/display/PLAY/Ways+to+embed+your+video
-    _EMBED_REGEX = [r'<iframe[^>]+src=(["\'])(?P<url>(?:https?:)?//play\.arkena\.com/embed/avp/.+?)\1']
-    _TESTS = [{
-        'url': 'https://video.qbrick.com/play2/embed/player?accountId=1034090&mediaId=d8ab4607-00090107-aab86310',
-        'md5': '97f117754e5f3c020f5f26da4a44ebaf',
-        'info_dict': {
-            'id': 'd8ab4607-00090107-aab86310',
-            'ext': 'mp4',
-            'title': 'EM_HT20_117_roslund_v2.mp4',
-            'timestamp': 1608285912,
-            'upload_date': '20201218',
-            'duration': 1429.162667,
-            'subtitles': {
-                'sv': 'count:3',
-            },
-        },
-    }, {
-        'url': 'https://play.arkena.com/embed/avp/v2/player/media/b41dda37-d8e7-4d3f-b1b5-9a9db578bdfe/1/129411',
-        'only_matching': True,
-    }, {
-        'url': 'https://play.arkena.com/config/avp/v2/player/media/b41dda37-d8e7-4d3f-b1b5-9a9db578bdfe/1/129411/?callbackMethod=jQuery1111023664739129262213_1469227693893',
-        'only_matching': True,
-    }, {
-        'url': 'http://play.arkena.com/config/avp/v1/player/media/327336/darkmatter/131064/?callbackMethod=jQuery1111002221189684892677_1469227595972',
-        'only_matching': True,
-    }, {
-        'url': 'http://play.arkena.com/embed/avp/v1/player/media/327336/darkmatter/131064/',
-        'only_matching': True,
-    }, {
-        'url': 'http://video.arkena.com/play2/embed/player?accountId=472718&mediaId=35763b3b-00090078-bf604299&pageStyling=styled',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        mobj = self._match_valid_url(url)
-        video_id = mobj.group('id')
-        account_id = mobj.group('account_id')
-
-        # Handle http://video.arkena.com/play2/embed/player URL
-        if not video_id:
-            qs = parse_qs(url)
-            video_id = qs.get('mediaId', [None])[0]
-            account_id = qs.get('accountId', [None])[0]
-            if not video_id or not account_id:
-                raise ExtractorError('Invalid URL', expected=True)
-
-        media = self._download_json(
-            f'https://video.qbrick.com/api/v1/public/accounts/{account_id}/medias/{video_id}',
-            video_id, query={
-                # https://video.qbrick.com/docs/api/examples/library-api.html
-                'fields': 'asset/resources/*/renditions/*(height,id,language,links/*(href,mimeType),type,size,videos/*(audios/*(codec,sampleRate),bitrate,codec,duration,height,width),width),created,metadata/*(title,description),tags',
-            })
-        metadata = media.get('metadata') or {}
-        title = metadata['title']
-
-        duration = None
-        formats = []
-        thumbnails = []
-        subtitles = {}
-        for resource in media['asset']['resources']:
-            for rendition in (resource.get('renditions') or []):
-                rendition_type = rendition.get('type')
-                for i, link in enumerate(rendition.get('links') or []):
-                    href = link.get('href')
-                    if not href:
-                        continue
-                    if rendition_type == 'image':
-                        thumbnails.append({
-                            'filesize': int_or_none(rendition.get('size')),
-                            'height': int_or_none(rendition.get('height')),
-                            'id': rendition.get('id'),
-                            'url': href,
-                            'width': int_or_none(rendition.get('width')),
-                        })
-                    elif rendition_type == 'subtitle':
-                        subtitles.setdefault(rendition.get('language') or 'en', []).append({
-                            'url': href,
-                        })
-                    elif rendition_type == 'video':
-                        f = {
-                            'filesize': int_or_none(rendition.get('size')),
-                            'format_id': rendition.get('id'),
-                            'url': href,
-                        }
-                        video = try_get(rendition, lambda x: x['videos'][i], dict)
-                        if video:
-                            if not duration:
-                                duration = float_or_none(video.get('duration'))
-                            f.update({
-                                'height': int_or_none(video.get('height')),
-                                'tbr': int_or_none(video.get('bitrate'), 1000),
-                                'vcodec': video.get('codec'),
-                                'width': int_or_none(video.get('width')),
-                            })
-                            audio = try_get(video, lambda x: x['audios'][0], dict)
-                            if audio:
-                                f.update({
-                                    'acodec': audio.get('codec'),
-                                    'asr': int_or_none(audio.get('sampleRate')),
-                                })
-                        formats.append(f)
-                    elif rendition_type == 'index':
-                        mime_type = link.get('mimeType')
-                        if mime_type == 'application/smil+xml':
-                            formats.extend(self._extract_smil_formats(
-                                href, video_id, fatal=False))
-                        elif mime_type == 'application/x-mpegURL':
-                            formats.extend(self._extract_m3u8_formats(
-                                href, video_id, 'mp4', 'm3u8_native',
-                                m3u8_id='hls', fatal=False))
-                        elif mime_type == 'application/hds+xml':
-                            formats.extend(self._extract_f4m_formats(
-                                href, video_id, f4m_id='hds', fatal=False))
-                        elif mime_type == 'application/dash+xml':
-                            formats.extend(self._extract_mpd_formats(
-                                href, video_id, mpd_id='dash', fatal=False))
-                        elif mime_type == 'application/vnd.ms-sstr+xml':
-                            formats.extend(self._extract_ism_formats(
-                                href, video_id, ism_id='mss', fatal=False))
-
-        return {
-            'id': video_id,
-            'title': title,
-            'description': metadata.get('description'),
-            'timestamp': parse_iso8601(media.get('created')),
-            'thumbnails': thumbnails,
-            'subtitles': subtitles,
-            'duration': duration,
-            'tags': media.get('tags'),
-            'formats': formats,
-        }

yt_dlp/extractor/common.py

@@ -3107,7 +3107,6 @@ class InfoExtractor:
                         else:
                             # $Number*$ or $Time$ in media template with S list available
                             # Example $Number*$: http://www.svtplay.se/klipp/9023742/stopptid-om-bjorn-borg
-                            # Example $Time$: https://play.arkena.com/embed/avp/v2/player/media/b41dda37-d8e7-4d3f-b1b5-9a9db578bdfe/1/129411
                             representation_ms_info['fragments'] = []
                             segment_time = 0
                             segment_d = None

yt_dlp/extractor/dailymotion.py

@@ -171,17 +171,6 @@ class DailymotionIE(DailymotionBaseInfoExtractor):
             'view_count': int,
         },
         'skip': 'video gone',
-    }, {
-        # Vevo video
-        'url': 'http://www.dailymotion.com/video/x149uew_katy-perry-roar-official_musi',
-        'info_dict': {
-            'title': 'Roar (Official)',
-            'id': 'USUV71301934',
-            'ext': 'mp4',
-            'uploader': 'Katy Perry',
-            'upload_date': '20130905',
-        },
-        'skip': 'Invalid URL',
     }, {
         # age-restricted video
         'url': 'http://www.dailymotion.com/video/xyh2zz_leanna-decker-cyber-girl-of-the-year-desires-nude-playboy-plus_redband',

yt_dlp/extractor/disney.py

@@ -90,10 +90,6 @@ class DisneyIE(InfoExtractor):
                 webpage, 'embed data'), video_id)
             video_data = page_data['video']
 
-        for external in video_data.get('externals', []):
-            if external.get('source') == 'vevo':
-                return self.url_result('vevo:' + external['data_id'], 'Vevo')
-
         video_id = video_data['id']
         title = video_data['title']
 

yt_dlp/extractor/lcp.py

@@ -1,8 +1,8 @@
-from .arkena import ArkenaIE
 from .common import InfoExtractor
 
 
-class LcpPlayIE(ArkenaIE):  # XXX: Do not subclass from concrete IE
+class LcpPlayIE(InfoExtractor):
+    _WORKING = False
     _VALID_URL = r'https?://play\.lcp\.fr/embed/(?P<id>[^/]+)/(?P<account_id>[^/]+)/[^/]+/[^/]+'
     _TESTS = [{
         'url': 'http://play.lcp.fr/embed/327336/131064/darkmatter/0',
@@ -21,24 +21,9 @@ class LcpPlayIE(ArkenaIE):  # XXX: Do not subclass from concrete IE
 
 
 class LcpIE(InfoExtractor):
+    _WORKING = False
     _VALID_URL = r'https?://(?:www\.)?lcp\.fr/(?:[^/]+/)*(?P<id>[^/]+)'
-
     _TESTS = [{
-        # arkena embed
-        'url': 'http://www.lcp.fr/la-politique-en-video/schwartzenberg-prg-preconise-francois-hollande-de-participer-une-primaire',
-        'md5': 'b8bd9298542929c06c1c15788b1f277a',
-        'info_dict': {
-            'id': 'd56d03e9',
-            'ext': 'mp4',
-            'title': 'Schwartzenberg (PRG) préconise à François Hollande de participer à une primaire à gauche',
-            'description': 'md5:96ad55009548da9dea19f4120c6c16a8',
-            'timestamp': 1456488895,
-            'upload_date': '20160226',
-        },
-        'params': {
-            'skip_download': True,
-        },
-    }, {
         # dailymotion live stream
         'url': 'http://www.lcp.fr/le-direct',
         'info_dict': {

yt_dlp/extractor/myspace.py

@@ -111,12 +111,8 @@ class MySpaceIE(InfoExtractor):
                 search_data('stream-url'), search_data('hls-stream-url'),
                 search_data('http-stream-url'))
             if not formats:
-                vevo_id = search_data('vevo-id')
                 youtube_id = search_data('youtube-id')
-                if vevo_id:
+                if youtube_id:
-                    self.to_screen(f'Vevo video detected: {vevo_id}')
-                    return self.url_result(f'vevo:{vevo_id}', ie='Vevo')
-                elif youtube_id:
                     self.to_screen(f'Youtube video detected: {youtube_id}')
                     return self.url_result(youtube_id, ie='Youtube')
                 else:

yt_dlp/extractor/niconico.py

@@ -873,39 +873,67 @@ class NiconicoLiveIE(NiconicoBaseIE):
     IE_DESC = 'ニコニコ生放送'
     _VALID_URL = r'https?://(?:sp\.)?live2?\.nicovideo\.jp/(?:watch|gate)/(?P<id>lv\d+)'
     _TESTS = [{
-        'note': 'this test case includes invisible characters for title, pasting them as-is',
+        'url': 'https://live.nicovideo.jp/watch/lv329299587',
-        'url': 'https://live.nicovideo.jp/watch/lv339533123',
         'info_dict': {
-            'id': 'lv339533123',
+            'id': 'lv329299587',
-            'title': '激辛ペヤング食べます\u202a( ;ᯅ; )\u202c（歌枠オーディション参加中）',
+            'ext': 'mp4',
-            'view_count': 1526,
+            'title': str,
-            'comment_count': 1772,
+            'channel': 'ニコニコエンタメチャンネル',
-            'description': '初めましてもかって言います❕\nのんびり自由に適当に暮らしてます',
+            'channel_id': 'ch2640322',
-            'uploader': 'もか',
+            'channel_url': 'https://ch.nicovideo.jp/channel/ch2640322',
-            'channel': 'ゲストさんのコミュニティ',
+            'comment_count': int,
-            'channel_id': 'co5776900',
+            'description': 'md5:281edd7f00309e99ec46a87fb16d7033',
-            'channel_url': 'https://com.nicovideo.jp/community/co5776900',
+            'live_status': 'is_live',
-            'timestamp': 1670677328,
+            'thumbnail': r're:https?://.+',
-            'is_live': True,
+            'timestamp': 1608803400,
+            'upload_date': '20201224',
+            'uploader': '株式会社ドワンゴ',
+            'view_count': int,
         },
-        'skip': 'livestream',
+        'params': {'skip_download': True},
     }, {
-        'url': 'https://live2.nicovideo.jp/watch/lv339533123',
+        'url': 'https://live.nicovideo.jp/watch/lv331050399',
-        'only_matching': True,
+        'info_dict': {
-    }, {
+            'id': 'lv331050399',
-        'url': 'https://sp.live.nicovideo.jp/watch/lv339533123',
+            'ext': 'mp4',
-        'only_matching': True,
+            'title': str,
-    }, {
+            'age_limit': 18,
-        'url': 'https://sp.live2.nicovideo.jp/watch/lv339533123',
+            'channel': 'みんなのおもちゃ REBOOT',
-        'only_matching': True,
+            'channel_id': 'ch2642088',
+            'channel_url': 'https://ch.nicovideo.jp/channel/ch2642088',
+            'comment_count': int,
+            'description': 'md5:8d0bb5beaca73b911725478a1e7c7b91',
+            'live_status': 'is_live',
+            'thumbnail': r're:https?://.+',
+            'timestamp': 1617029400,
+            'upload_date': '20210329',
+            'uploader': '株式会社ドワンゴ',
+            'view_count': int,
+        },
+        'params': {'skip_download': True},
     }]
 
     def _real_extract(self, url):
         video_id = self._match_id(url)
-        webpage = self._download_webpage(url, video_id, expected_status=404)
+        webpage, urlh = self._download_webpage_handle(url, video_id, expected_status=404)
         if err_msg := traverse_obj(webpage, ({find_element(cls='message')}, {clean_html})):
             raise ExtractorError(err_msg, expected=True)
 
+        age_limit = 18 if 'age_auth' in urlh.url else None
+        if age_limit:
+            if not self.is_logged_in:
+                self.raise_login_required('Login is required to access age-restricted content')
+
+            my = self._download_webpage('https://www.nicovideo.jp/my', None, 'Checking age verification')
+            if traverse_obj(my, (
+                {find_element(id='js-initial-userpage-data', html=True)}, {extract_attributes},
+                'data-environment', {json.loads}, 'allowSensitiveContents', {bool},
+            )):
+                self._set_cookie('.nicovideo.jp', 'age_auth', '1')
+                webpage = self._download_webpage(url, video_id)
+            else:
+                raise ExtractorError('Sensitive content setting must be enabled', expected=True)
+
         embedded_data = traverse_obj(webpage, (
             {find_element(tag='script', id='embedded-data', html=True)},
             {extract_attributes}, 'data-props', {json.loads}))
@@ -1008,6 +1036,7 @@ class NiconicoLiveIE(NiconicoBaseIE):
         return {
             'id': video_id,
             'title': title,
+            'age_limit': age_limit,
             'downloader_options': {
                 'max_quality': traverse_obj(embedded_data, ('program', 'stream', 'maxQuality', {str})) or 'normal',
                 'ws': ws,

yt_dlp/extractor/odnoklassniki.py

@@ -352,14 +352,6 @@ class OdnoklassnikiIE(InfoExtractor):
             'subtitles': subtitles,
         }
 
-        # pladform
-        if provider == 'OPEN_GRAPH':
-            info.update({
-                '_type': 'url_transparent',
-                'url': movie['contentId'],
-            })
-            return info
-
         if provider == 'USER_YOUTUBE':
             info.update({
                 '_type': 'url_transparent',

yt_dlp/extractor/pladform.py

@@ -1,135 +0,0 @@
-from .common import InfoExtractor
-from ..utils import (
-    ExtractorError,
-    determine_ext,
-    int_or_none,
-    parse_qs,
-    qualities,
-    xpath_text,
-)
-
-
-class PladformIE(InfoExtractor):
-    _VALID_URL = r'''(?x)
-                    https?://
-                        (?:
-                            (?:
-                                out\.pladform\.ru/player|
-                                static\.pladform\.ru/player\.swf
-                            )
-                            \?.*\bvideoid=|
-                            video\.pladform\.ru/catalog/video/videoid/
-                        )
-                        (?P<id>\d+)
-                    '''
-    _EMBED_REGEX = [r'<iframe[^>]+src=(["\'])(?P<url>(?:https?:)?//out\.pladform\.ru/player\?.+?)\1']
-    _TESTS = [{
-        'url': 'http://out.pladform.ru/player?pl=18079&type=html5&videoid=100231282',
-        'info_dict': {
-            'id': '6216d548e755edae6e8280667d774791',
-            'ext': 'mp4',
-            'timestamp': 1406117012,
-            'title': 'Гарик Мартиросян и Гарик Харламов - Кастинг на концерт ко Дню милиции',
-            'age_limit': 0,
-            'upload_date': '20140723',
-            'thumbnail': str,
-            'view_count': int,
-            'description': str,
-            'uploader_id': '12082',
-            'uploader': 'Comedy Club',
-            'duration': 367,
-        },
-        'expected_warnings': ['HTTP Error 404: Not Found'],
-    }, {
-        'url': 'https://out.pladform.ru/player?pl=64471&videoid=3777899&vk_puid15=0&vk_puid34=0',
-        'md5': '53362fac3a27352da20fa2803cc5cd6f',
-        'info_dict': {
-            'id': '3777899',
-            'ext': 'mp4',
-            'title': 'СТУДИЯ СОЮЗ • Шоу Студия Союз, 24 выпуск (01.02.2018) Нурлан Сабуров и Слава Комиссаренко',
-            'description': 'md5:05140e8bf1b7e2d46e7ba140be57fd95',
-            'thumbnail': r're:^https?://.*\.jpg$',
-            'duration': 3190,
-        },
-    }, {
-        'url': 'http://static.pladform.ru/player.swf?pl=21469&videoid=100183293&vkcid=0',
-        'only_matching': True,
-    }, {
-        'url': 'http://video.pladform.ru/catalog/video/videoid/100183293/vkcid/0',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-
-        qs = parse_qs(url)
-        pl = qs.get('pl', ['1'])[0]
-
-        video = self._download_xml(
-            'http://out.pladform.ru/getVideo', video_id, query={
-                'pl': pl,
-                'videoid': video_id,
-            }, fatal=False)
-
-        def fail(text):
-            raise ExtractorError(
-                f'{self.IE_NAME} returned error: {text}',
-                expected=True)
-
-        if not video:
-            target_url = self._request_webpage(url, video_id, note='Resolving final URL').url
-            if target_url == url:
-                raise ExtractorError('Can\'t parse page')
-            return self.url_result(target_url)
-
-        if video.tag == 'error':
-            fail(video.text)
-
-        quality = qualities(('ld', 'sd', 'hd'))
-
-        formats = []
-        for src in video.findall('./src'):
-            if src is None:
-                continue
-            format_url = src.text
-            if not format_url:
-                continue
-            if src.get('type') == 'hls' or determine_ext(format_url) == 'm3u8':
-                formats.extend(self._extract_m3u8_formats(
-                    format_url, video_id, 'mp4', entry_protocol='m3u8_native',
-                    m3u8_id='hls', fatal=False))
-            else:
-                formats.append({
-                    'url': src.text,
-                    'format_id': src.get('quality'),
-                    'quality': quality(src.get('quality')),
-                })
-
-        if not formats:
-            error = xpath_text(video, './cap', 'error', default=None)
-            if error:
-                fail(error)
-
-        webpage = self._download_webpage(
-            f'http://video.pladform.ru/catalog/video/videoid/{video_id}',
-            video_id)
-
-        title = self._og_search_title(webpage, fatal=False) or xpath_text(
-            video, './/title', 'title', fatal=True)
-        description = self._search_regex(
-            r'</h3>\s*<p>([^<]+)</p>', webpage, 'description', fatal=False)
-        thumbnail = self._og_search_thumbnail(webpage) or xpath_text(
-            video, './/cover', 'cover')
-
-        duration = int_or_none(xpath_text(video, './/time', 'duration'))
-        age_limit = int_or_none(xpath_text(video, './/age18', 'age limit'))
-
-        return {
-            'id': video_id,
-            'title': title,
-            'description': description,
-            'thumbnail': thumbnail,
-            'duration': duration,
-            'age_limit': age_limit,
-            'formats': formats,
-        }

yt_dlp/extractor/vevo.py

@@ -1,352 +0,0 @@
-import json
-import re
-
-from .common import InfoExtractor
-from ..networking.exceptions import HTTPError
-from ..utils import (
-    ExtractorError,
-    int_or_none,
-    parse_iso8601,
-    parse_qs,
-)
-
-
-class VevoBaseIE(InfoExtractor):
-    def _extract_json(self, webpage, video_id):
-        return self._parse_json(
-            self._search_regex(
-                r'window\.__INITIAL_STORE__\s*=\s*({.+?});\s*</script>',
-                webpage, 'initial store'),
-            video_id)
-
-
-class VevoIE(VevoBaseIE):
-    """
-    Accepts urls from vevo.com or in the format 'vevo:{id}'
-    (currently used by MTVIE and MySpaceIE)
-    """
-    _VALID_URL = r'''(?x)
-        (?:https?://(?:www\.)?vevo\.com/watch/(?!playlist|genre)(?:[^/]+/(?:[^/]+/)?)?|
-           https?://cache\.vevo\.com/m/html/embed\.html\?video=|
-           https?://videoplayer\.vevo\.com/embed/embedded\?videoId=|
-           https?://embed\.vevo\.com/.*?[?&]isrc=|
-           https?://tv\.vevo\.com/watch/artist/(?:[^/]+)/|
-           vevo:)
-        (?P<id>[^&?#]+)'''
-    _EMBED_REGEX = [r'<iframe[^>]+?src=(["\'])(?P<url>(?:https?:)?//(?:cache\.)?vevo\.com/.+?)\1']
-
-    _TESTS = [{
-        'url': 'http://www.vevo.com/watch/hurts/somebody-to-die-for/GB1101300280',
-        'md5': '95ee28ee45e70130e3ab02b0f579ae23',
-        'info_dict': {
-            'id': 'GB1101300280',
-            'ext': 'mp4',
-            'title': 'Hurts - Somebody to Die For',
-            'timestamp': 1372057200,
-            'upload_date': '20130624',
-            'uploader': 'Hurts',
-            'track': 'Somebody to Die For',
-            'artist': 'Hurts',
-            'genre': 'Pop',
-        },
-        'expected_warnings': ['Unable to download SMIL file', 'Unable to download info'],
-    }, {
-        'note': 'v3 SMIL format',
-        'url': 'http://www.vevo.com/watch/cassadee-pope/i-wish-i-could-break-your-heart/USUV71302923',
-        'md5': 'f6ab09b034f8c22969020b042e5ac7fc',
-        'info_dict': {
-            'id': 'USUV71302923',
-            'ext': 'mp4',
-            'title': 'Cassadee Pope - I Wish I Could Break Your Heart',
-            'timestamp': 1392796919,
-            'upload_date': '20140219',
-            'uploader': 'Cassadee Pope',
-            'track': 'I Wish I Could Break Your Heart',
-            'artist': 'Cassadee Pope',
-            'genre': 'Country',
-        },
-        'expected_warnings': ['Unable to download SMIL file', 'Unable to download info'],
-    }, {
-        'note': 'Age-limited video',
-        'url': 'https://www.vevo.com/watch/justin-timberlake/tunnel-vision-explicit/USRV81300282',
-        'info_dict': {
-            'id': 'USRV81300282',
-            'ext': 'mp4',
-            'title': 'Justin Timberlake - Tunnel Vision (Explicit)',
-            'age_limit': 18,
-            'timestamp': 1372888800,
-            'upload_date': '20130703',
-            'uploader': 'Justin Timberlake',
-            'track': 'Tunnel Vision (Explicit)',
-            'artist': 'Justin Timberlake',
-            'genre': 'Pop',
-        },
-        'expected_warnings': ['Unable to download SMIL file', 'Unable to download info'],
-    }, {
-        'note': 'No video_info',
-        'url': 'http://www.vevo.com/watch/k-camp-1/Till-I-Die/USUV71503000',
-        'md5': '8b83cc492d72fc9cf74a02acee7dc1b0',
-        'info_dict': {
-            'id': 'USUV71503000',
-            'ext': 'mp4',
-            'title': 'K Camp ft. T.I. - Till I Die',
-            'age_limit': 18,
-            'timestamp': 1449468000,
-            'upload_date': '20151207',
-            'uploader': 'K Camp',
-            'track': 'Till I Die',
-            'artist': 'K Camp',
-            'genre': 'Hip-Hop',
-        },
-        'expected_warnings': ['Unable to download SMIL file', 'Unable to download info'],
-    }, {
-        'note': 'Featured test',
-        'url': 'https://www.vevo.com/watch/lemaitre/Wait/USUV71402190',
-        'md5': 'd28675e5e8805035d949dc5cf161071d',
-        'info_dict': {
-            'id': 'USUV71402190',
-            'ext': 'mp4',
-            'title': 'Lemaitre ft. LoLo - Wait',
-            'age_limit': 0,
-            'timestamp': 1413432000,
-            'upload_date': '20141016',
-            'uploader': 'Lemaitre',
-            'track': 'Wait',
-            'artist': 'Lemaitre',
-            'genre': 'Electronic',
-        },
-        'expected_warnings': ['Unable to download SMIL file', 'Unable to download info'],
-    }, {
-        'note': 'Only available via webpage',
-        'url': 'http://www.vevo.com/watch/GBUV71600656',
-        'md5': '67e79210613865b66a47c33baa5e37fe',
-        'info_dict': {
-            'id': 'GBUV71600656',
-            'ext': 'mp4',
-            'title': 'ABC - Viva Love',
-            'age_limit': 0,
-            'timestamp': 1461830400,
-            'upload_date': '20160428',
-            'uploader': 'ABC',
-            'track': 'Viva Love',
-            'artist': 'ABC',
-            'genre': 'Pop',
-        },
-        'expected_warnings': ['Failed to download video versions info'],
-    }, {
-        # no genres available
-        'url': 'http://www.vevo.com/watch/INS171400764',
-        'only_matching': True,
-    }, {
-        # Another case available only via the webpage; using streams/streamsV3 formats
-        # Geo-restricted to Netherlands/Germany
-        'url': 'http://www.vevo.com/watch/boostee/pop-corn-clip-officiel/FR1A91600909',
-        'only_matching': True,
-    }, {
-        'url': 'https://embed.vevo.com/?isrc=USH5V1923499&partnerId=4d61b777-8023-4191-9ede-497ed6c24647&partnerAdCode=',
-        'only_matching': True,
-    }, {
-        'url': 'https://tv.vevo.com/watch/artist/janet-jackson/US0450100550',
-        'only_matching': True,
-    }]
-    _VERSIONS = {
-        0: 'youtube',  # only in AuthenticateVideo videoVersions
-        1: 'level3',
-        2: 'akamai',
-        3: 'level3',
-        4: 'amazon',
-    }
-
-    def _initialize_api(self, video_id):
-        webpage = self._download_webpage(
-            'https://accounts.vevo.com/token', None,
-            note='Retrieving oauth token',
-            errnote='Unable to retrieve oauth token',
-            data=json.dumps({
-                'client_id': 'SPupX1tvqFEopQ1YS6SS',
-                'grant_type': 'urn:vevo:params:oauth:grant-type:anonymous',
-            }).encode(),
-            headers={
-                'Content-Type': 'application/json',
-            })
-
-        if re.search(r'(?i)THIS PAGE IS CURRENTLY UNAVAILABLE IN YOUR REGION', webpage):
-            self.raise_geo_restricted(
-                f'{self.IE_NAME} said: This page is currently unavailable in your region')
-
-        auth_info = self._parse_json(webpage, video_id)
-        self._api_url_template = self.http_scheme() + '//apiv2.vevo.com/%s?token=' + auth_info['legacy_token']
-
-    def _call_api(self, path, *args, **kwargs):
-        try:
-            data = self._download_json(self._api_url_template % path, *args, **kwargs)
-        except ExtractorError as e:
-            if isinstance(e.cause, HTTPError):
-                errors = self._parse_json(e.cause.response.read().decode(), None)['errors']
-                error_message = ', '.join([error['message'] for error in errors])
-                raise ExtractorError(f'{self.IE_NAME} said: {error_message}', expected=True)
-            raise
-        return data
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-
-        self._initialize_api(video_id)
-
-        video_info = self._call_api(
-            f'video/{video_id}', video_id, 'Downloading api video info',
-            'Failed to download video info')
-
-        video_versions = self._call_api(
-            f'video/{video_id}/streams', video_id,
-            'Downloading video versions info',
-            'Failed to download video versions info',
-            fatal=False)
-
-        # Some videos are only available via webpage (e.g.
-        # https://github.com/ytdl-org/youtube-dl/issues/9366)
-        if not video_versions:
-            webpage = self._download_webpage(url, video_id)
-            json_data = self._extract_json(webpage, video_id)
-            if 'streams' in json_data.get('default', {}):
-                video_versions = json_data['default']['streams'][video_id][0]
-            else:
-                video_versions = [
-                    value
-                    for key, value in json_data['apollo']['data'].items()
-                    if key.startswith(f'{video_id}.streams')]
-
-        uploader = None
-        artist = None
-        featured_artist = None
-        artists = video_info.get('artists')
-        for curr_artist in artists:
-            if curr_artist.get('role') == 'Featured':
-                featured_artist = curr_artist['name']
-            else:
-                artist = uploader = curr_artist['name']
-
-        formats = []
-        for video_version in video_versions:
-            version = self._VERSIONS.get(video_version.get('version'), 'generic')
-            version_url = video_version.get('url')
-            if not version_url:
-                continue
-
-            if '.ism' in version_url:
-                continue
-            elif '.mpd' in version_url:
-                formats.extend(self._extract_mpd_formats(
-                    version_url, video_id, mpd_id=f'dash-{version}',
-                    note=f'Downloading {version} MPD information',
-                    errnote=f'Failed to download {version} MPD information',
-                    fatal=False))
-            elif '.m3u8' in version_url:
-                formats.extend(self._extract_m3u8_formats(
-                    version_url, video_id, 'mp4', 'm3u8_native',
-                    m3u8_id=f'hls-{version}',
-                    note=f'Downloading {version} m3u8 information',
-                    errnote=f'Failed to download {version} m3u8 information',
-                    fatal=False))
-            else:
-                m = re.search(r'''(?xi)
-                    _(?P<quality>[a-z0-9]+)
-                    _(?P<width>[0-9]+)x(?P<height>[0-9]+)
-                    _(?P<vcodec>[a-z0-9]+)
-                    _(?P<vbr>[0-9]+)
-                    _(?P<acodec>[a-z0-9]+)
-                    _(?P<abr>[0-9]+)
-                    \.(?P<ext>[a-z0-9]+)''', version_url)
-                if not m:
-                    continue
-
-                formats.append({
-                    'url': version_url,
-                    'format_id': f'http-{version}-{video_version.get("quality") or m.group("quality")}',
-                    'vcodec': m.group('vcodec'),
-                    'acodec': m.group('acodec'),
-                    'vbr': int(m.group('vbr')),
-                    'abr': int(m.group('abr')),
-                    'ext': m.group('ext'),
-                    'width': int(m.group('width')),
-                    'height': int(m.group('height')),
-                })
-
-        track = video_info['title']
-        if featured_artist:
-            artist = f'{artist} ft. {featured_artist}'
-        title = f'{artist} - {track}' if artist else track
-
-        genres = video_info.get('genres')
-        genre = (
-            genres[0] if genres and isinstance(genres, list)
-            and isinstance(genres[0], str) else None)
-
-        is_explicit = video_info.get('isExplicit')
-        if is_explicit is True:
-            age_limit = 18
-        elif is_explicit is False:
-            age_limit = 0
-        else:
-            age_limit = None
-
-        return {
-            'id': video_id,
-            'title': title,
-            'formats': formats,
-            'thumbnail': video_info.get('imageUrl') or video_info.get('thumbnailUrl'),
-            'timestamp': parse_iso8601(video_info.get('releaseDate')),
-            'uploader': uploader,
-            'duration': int_or_none(video_info.get('duration')),
-            'view_count': int_or_none(video_info.get('views', {}).get('total')),
-            'age_limit': age_limit,
-            'track': track,
-            'artist': uploader,
-            'genre': genre,
-        }
-
-
-class VevoPlaylistIE(VevoBaseIE):
-    _VALID_URL = r'https?://(?:www\.)?vevo\.com/watch/(?P<kind>playlist|genre)/(?P<id>[^/?#&]+)'
-
-    _TESTS = [{
-        'url': 'http://www.vevo.com/watch/genre/rock',
-        'info_dict': {
-            'id': 'rock',
-            'title': 'Rock',
-        },
-        'playlist_count': 20,
-    }, {
-        'url': 'http://www.vevo.com/watch/genre/rock?index=0',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        mobj = self._match_valid_url(url)
-        playlist_id = mobj.group('id')
-        playlist_kind = mobj.group('kind')
-
-        webpage = self._download_webpage(url, playlist_id)
-
-        qs = parse_qs(url)
-        index = qs.get('index', [None])[0]
-
-        if index:
-            video_id = self._search_regex(
-                r'<meta[^>]+content=(["\'])vevo://video/(?P<id>.+?)\1[^>]*>',
-                webpage, 'video id', default=None, group='id')
-            if video_id:
-                return self.url_result(f'vevo:{video_id}', VevoIE.ie_key())
-
-        playlists = self._extract_json(webpage, playlist_id)['default'][f'{playlist_kind}s']
-
-        playlist = (next(iter(playlists.values()))
-                    if playlist_kind == 'playlist' else playlists[playlist_id])
-
-        entries = [
-            self.url_result(f'vevo:{src}', VevoIE.ie_key())
-            for src in playlist['isrcs']]
-
-        return self.playlist_result(
-            entries, playlist.get('playlistId') or playlist_id,
-            playlist.get('name'), playlist.get('description'))

yt_dlp/extractor/vk.py

@@ -5,7 +5,6 @@ import re
 from .common import InfoExtractor
 from .dailymotion import DailymotionIE
 from .odnoklassniki import OdnoklassnikiIE
-from .pladform import PladformIE
 from .sibnet import SibnetEmbedIE
 from .vimeo import VimeoIE
 from .youtube import YoutubeIE
@@ -334,11 +333,6 @@ class VKIE(VKBaseIE):
             'url': 'https://vk.com/video205387401_164765225',
             'only_matching': True,
         },
-        {
-            # pladform embed
-            'url': 'https://vk.com/video-76116461_171554880',
-            'only_matching': True,
-        },
         {
             'url': 'http://new.vk.com/video205387401_165548505',
             'only_matching': True,
@@ -456,10 +450,6 @@ class VKIE(VKBaseIE):
         if vimeo_url is not None:
             return self.url_result(vimeo_url, VimeoIE.ie_key())
 
-        pladform_url = PladformIE._extract_url(info_page)
-        if pladform_url:
-            return self.url_result(pladform_url, PladformIE.ie_key())
-
         m_rutube = re.search(
             r'\ssrc="((?:https?:)?//rutube\.ru\\?/(?:video|play)\\?/embed(?:.*?))\\?"', info_page)
         if m_rutube is not None: