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

@@ -1,174 +0,0 @@
-import re
-
-from .common import InfoExtractor
-from ..utils import (
-    dict_get,
-    ExtractorError,
-    int_or_none,
-    join_nonempty,
-    parse_iso8601,
-    traverse_obj,
-    try_get,
-    unescapeHTML,
-    urljoin,
-)
-
-
-class PikselIE(InfoExtractor):
-    _VALID_URL = r'''(?x)https?://
-        (?:
-            (?:
-                player\.
-                    (?:
-                        olympusattelecom|
-                        vibebyvista
-                    )|
-                (?:api|player)\.multicastmedia|
-                (?:api-ovp|player)\.piksel
-            )\.com|
-            (?:
-                mz-edge\.stream\.co|
-                movie-s\.nhk\.or
-            )\.jp|
-            vidego\.baltimorecity\.gov
-        )/v/(?:refid/(?P<refid>[^/]+)/prefid/)?(?P<id>[\w-]+)'''
-    _EMBED_REGEX = [r'<iframe[^>]+src=["\'](?P<url>(?:https?:)?//player\.piksel\.com/v/[a-z0-9]+)']
-    _TESTS = [
-        {
-            'url': 'http://player.piksel.com/v/ums2867l',
-            'md5': '34e34c8d89dc2559976a6079db531e85',
-            'info_dict': {
-                'id': 'ums2867l',
-                'ext': 'mp4',
-                'title': 'GX-005 with Caption',
-                'timestamp': 1481335659,
-                'upload_date': '20161210'
-            }
-        },
-        {
-            # Original source: http://www.uscourts.gov/cameras-courts/state-washington-vs-donald-j-trump-et-al
-            'url': 'https://player.piksel.com/v/v80kqp41',
-            'md5': '753ddcd8cc8e4fa2dda4b7be0e77744d',
-            'info_dict': {
-                'id': 'v80kqp41',
-                'ext': 'mp4',
-                'title': 'WAW- State of Washington vs. Donald J. Trump, et al',
-                'description': 'State of Washington vs. Donald J. Trump, et al, Case Number 17-CV-00141-JLR, TRO Hearing, Civil Rights Case, 02/3/2017, 1:00 PM (PST), Seattle Federal Courthouse, Seattle, WA, Judge James L. Robart presiding.',
-                'timestamp': 1486171129,
-                'upload_date': '20170204'
-            }
-        },
-        {
-            # https://www3.nhk.or.jp/nhkworld/en/ondemand/video/2019240/
-            'url': 'http://player.piksel.com/v/refid/nhkworld/prefid/nw_vod_v_en_2019_240_20190823233000_02_1566873477',
-            'only_matching': True,
-        }
-    ]
-
-    def _call_api(self, app_token, resource, display_id, query, host='https://player.piksel.com', fatal=True):
-        url = urljoin(host, f'/ws/ws_{resource}/api/{app_token}/mode/json/apiv/5')
-        response = traverse_obj(
-            self._download_json(url, display_id, query=query, fatal=fatal), ('response', {dict})) or {}
-        failure = traverse_obj(response, ('failure', 'reason')) if response else 'Empty response from API'
-        if failure:
-            if fatal:
-                raise ExtractorError(failure, expected=True)
-            self.report_warning(failure)
-        return response
-
-    def _real_extract(self, url):
-        ref_id, display_id = self._match_valid_url(url).groups()
-        webpage = self._download_webpage(url, display_id)
-        app_token = self._search_regex([
-            r'clientAPI\s*:\s*"([^"]+)"',
-            r'data-de-api-key\s*=\s*"([^"]+)"'
-        ], webpage, 'app token')
-        query = {'refid': ref_id, 'prefid': display_id} if ref_id else {'v': display_id}
-        program = self._call_api(
-            app_token, 'program', display_id, query, url)['WsProgramResponse']['program']
-        video_id = program['uuid']
-        video_data = program['asset']
-        title = video_data['title']
-        asset_type = dict_get(video_data, ['assetType', 'asset_type'])
-
-        formats = []
-
-        def process_asset_file(asset_file):
-            if not asset_file:
-                return
-            # TODO: extract rtmp formats
-            http_url = asset_file.get('http_url')
-            if not http_url:
-                return
-            tbr = None
-            vbr = int_or_none(asset_file.get('videoBitrate'), 1024)
-            abr = int_or_none(asset_file.get('audioBitrate'), 1024)
-            if asset_type == 'video':
-                tbr = vbr + abr
-            elif asset_type == 'audio':
-                tbr = abr
-
-            formats.append({
-                'format_id': join_nonempty('http', tbr),
-                'url': unescapeHTML(http_url),
-                'vbr': vbr,
-                'abr': abr,
-                'width': int_or_none(asset_file.get('videoWidth')),
-                'height': int_or_none(asset_file.get('videoHeight')),
-                'filesize': int_or_none(asset_file.get('filesize')),
-                'tbr': tbr,
-            })
-
-        def process_asset_files(asset_files):
-            for asset_file in (asset_files or []):
-                process_asset_file(asset_file)
-
-        process_asset_files(video_data.get('assetFiles'))
-        process_asset_file(video_data.get('referenceFile'))
-        if not formats:
-            asset_id = video_data.get('assetid') or program.get('assetid')
-            if asset_id:
-                process_asset_files(try_get(self._call_api(
-                    app_token, 'asset_file', display_id, {
-                        'assetid': asset_id,
-                    }, url, False), lambda x: x['WsAssetFileResponse']['AssetFiles']))
-
-        m3u8_url = dict_get(video_data, [
-            'm3u8iPadURL',
-            'ipadM3u8Url',
-            'm3u8AndroidURL',
-            'm3u8iPhoneURL',
-            'iphoneM3u8Url'])
-        if m3u8_url:
-            formats.extend(self._extract_m3u8_formats(
-                m3u8_url, video_id, 'mp4', 'm3u8_native',
-                m3u8_id='hls', fatal=False))
-
-        smil_url = dict_get(video_data, ['httpSmil', 'hdSmil', 'rtmpSmil'])
-        if smil_url:
-            transform_source = None
-            if ref_id == 'nhkworld':
-                # TODO: figure out if this is something to be fixed in urljoin,
-                # _parse_smil_formats or keep it here
-                transform_source = lambda x: x.replace('src="/', 'src="').replace('/media"', '/media/"')
-            formats.extend(self._extract_smil_formats(
-                re.sub(r'/od/[^/]+/', '/od/http/', smil_url), video_id,
-                transform_source=transform_source, fatal=False))
-
-        subtitles = {}
-        for caption in video_data.get('captions', []):
-            caption_url = caption.get('url')
-            if caption_url:
-                subtitles.setdefault(caption.get('locale', 'en'), []).append({
-                    'url': caption_url})
-
-        return {
-            'id': video_id,
-            'title': title,
-            'description': video_data.get('description'),
-            'thumbnail': video_data.get('thumbnailUrl'),
-            'timestamp': parse_iso8601(video_data.get('dateadd')),
-            'formats': formats,
-            'subtitles': subtitles,
-            '_format_sort_fields': ('tbr', ),  # Incomplete resolution information
-        }

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

@@ -1,93 +0,0 @@
-import re
-
-from .common import InfoExtractor
-from ..utils import (
-    int_or_none,
-    remove_end,
-    remove_start,
-    str_to_int,
-    unified_strdate,
-)
-
-
-class PinkbikeIE(InfoExtractor):
-    _VALID_URL = r'https?://(?:(?:www\.)?pinkbike\.com/video/|es\.pinkbike\.org/i/kvid/kvid-y5\.swf\?id=)(?P<id>[0-9]+)'
-    _TESTS = [{
-        'url': 'http://www.pinkbike.com/video/402811/',
-        'md5': '4814b8ca7651034cd87e3361d5c2155a',
-        'info_dict': {
-            'id': '402811',
-            'ext': 'mp4',
-            'title': 'Brandon Semenuk - RAW 100',
-            'description': 'Official release: www.redbull.ca/rupertwalker',
-            'thumbnail': r're:^https?://.*\.jpg$',
-            'duration': 100,
-            'upload_date': '20150406',
-            'uploader': 'revelco',
-            'location': 'Victoria, British Columbia, Canada',
-            'view_count': int,
-            'comment_count': int,
-        }
-    }, {
-        'url': 'http://es.pinkbike.org/i/kvid/kvid-y5.swf?id=406629',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-
-        webpage = self._download_webpage(
-            'http://www.pinkbike.com/video/%s' % video_id, video_id)
-
-        formats = []
-        for _, format_id, src in re.findall(
-                r'data-quality=((?:\\)?["\'])(.+?)\1[^>]+src=\1(.+?)\1', webpage):
-            height = int_or_none(self._search_regex(
-                r'^(\d+)[pP]$', format_id, 'height', default=None))
-            formats.append({
-                'url': src,
-                'format_id': format_id,
-                'height': height,
-            })
-
-        title = remove_end(self._og_search_title(webpage), ' Video - Pinkbike')
-        description = self._html_search_regex(
-            r'(?s)id="media-description"[^>]*>(.+?)<',
-            webpage, 'description', default=None) or remove_start(
-            self._og_search_description(webpage), title + '. ')
-        thumbnail = self._og_search_thumbnail(webpage)
-        duration = int_or_none(self._html_search_meta(
-            'video:duration', webpage, 'duration'))
-
-        uploader = self._search_regex(
-            r'<a[^>]+\brel=["\']author[^>]+>([^<]+)', webpage,
-            'uploader', fatal=False)
-        upload_date = unified_strdate(self._search_regex(
-            r'class="fullTime"[^>]+title="([^"]+)"',
-            webpage, 'upload date', fatal=False))
-
-        location = self._html_search_regex(
-            r'(?s)<dt>Location</dt>\s*<dd>(.+?)<',
-            webpage, 'location', fatal=False)
-
-        def extract_count(webpage, label):
-            return str_to_int(self._search_regex(
-                r'<span[^>]+class="stat-num"[^>]*>([\d,.]+)</span>\s*<span[^>]+class="stat-label"[^>]*>%s' % label,
-                webpage, label, fatal=False))
-
-        view_count = extract_count(webpage, 'Views')
-        comment_count = extract_count(webpage, 'Comments')
-
-        return {
-            'id': video_id,
-            'title': title,
-            'description': description,
-            'thumbnail': thumbnail,
-            'duration': duration,
-            'upload_date': upload_date,
-            'uploader': uploader,
-            'location': location,
-            'view_count': view_count,
-            'comment_count': comment_count,
-            'formats': formats
-        }

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

@@ -1,248 +0,0 @@
-import json
-
-from .common import InfoExtractor
-from ..utils import (
-    determine_ext,
-    float_or_none,
-    int_or_none,
-    str_or_none,
-    strip_or_none,
-    traverse_obj,
-    unified_timestamp,
-    url_or_none,
-)
-
-
-class PinterestBaseIE(InfoExtractor):
-    _VALID_URL_BASE = r'''(?x)
-        https?://(?:[^/]+\.)?pinterest\.(?:
-            com|fr|de|ch|jp|cl|ca|it|co\.uk|nz|ru|com\.au|at|pt|co\.kr|es|com\.mx|
-            dk|ph|th|com\.uy|co|nl|info|kr|ie|vn|com\.vn|ec|mx|in|pe|co\.at|hu|
-            co\.in|co\.nz|id|com\.ec|com\.py|tw|be|uk|com\.bo|com\.pe)'''
-
-    def _call_api(self, resource, video_id, options):
-        return self._download_json(
-            'https://www.pinterest.com/resource/%sResource/get/' % resource,
-            video_id, 'Download %s JSON metadata' % resource, query={
-                'data': json.dumps({'options': options})
-            })['resource_response']
-
-    def _extract_video(self, data, extract_formats=True):
-        video_id = data['id']
-        thumbnails = []
-        images = data.get('images')
-        if isinstance(images, dict):
-            for thumbnail_id, thumbnail in images.items():
-                if not isinstance(thumbnail, dict):
-                    continue
-                thumbnail_url = url_or_none(thumbnail.get('url'))
-                if not thumbnail_url:
-                    continue
-                thumbnails.append({
-                    'url': thumbnail_url,
-                    'width': int_or_none(thumbnail.get('width')),
-                    'height': int_or_none(thumbnail.get('height')),
-                })
-
-        info = {
-            'title': strip_or_none(traverse_obj(data, 'title', 'grid_title', default='')),
-            'description': traverse_obj(data, 'seo_description', 'description'),
-            'timestamp': unified_timestamp(data.get('created_at')),
-            'thumbnails': thumbnails,
-            'uploader': traverse_obj(data, ('closeup_attribution', 'full_name')),
-            'uploader_id': str_or_none(traverse_obj(data, ('closeup_attribution', 'id'))),
-            'repost_count': int_or_none(data.get('repin_count')),
-            'comment_count': int_or_none(data.get('comment_count')),
-            'categories': traverse_obj(data, ('pin_join', 'visual_annotation'), expected_type=list),
-            'tags': traverse_obj(data, 'hashtags', expected_type=list),
-        }
-
-        urls = []
-        formats = []
-        duration = None
-        domain = data.get('domain', '')
-        if domain.lower() != 'uploaded by user' and traverse_obj(data, ('embed', 'src')):
-            if not info['title']:
-                info['title'] = None
-            return {
-                '_type': 'url_transparent',
-                'url': data['embed']['src'],
-                **info,
-            }
-
-        elif extract_formats:
-            video_list = traverse_obj(
-                data, ('videos', 'video_list'),
-                ('story_pin_data', 'pages', ..., 'blocks', ..., 'video', 'video_list'),
-                expected_type=dict, get_all=False, default={})
-            for format_id, format_dict in video_list.items():
-                if not isinstance(format_dict, dict):
-                    continue
-                format_url = url_or_none(format_dict.get('url'))
-                if not format_url or format_url in urls:
-                    continue
-                urls.append(format_url)
-                duration = float_or_none(format_dict.get('duration'), scale=1000)
-                ext = determine_ext(format_url)
-                if 'hls' in format_id.lower() or ext == 'm3u8':
-                    formats.extend(self._extract_m3u8_formats(
-                        format_url, video_id, 'mp4', entry_protocol='m3u8_native',
-                        m3u8_id=format_id, fatal=False))
-                else:
-                    formats.append({
-                        'url': format_url,
-                        'format_id': format_id,
-                        'width': int_or_none(format_dict.get('width')),
-                        'height': int_or_none(format_dict.get('height')),
-                        'duration': duration,
-                    })
-
-        return {
-            'id': video_id,
-            'formats': formats,
-            'duration': duration,
-            'webpage_url': f'https://www.pinterest.com/pin/{video_id}/',
-            'extractor_key': PinterestIE.ie_key(),
-            'extractor': PinterestIE.IE_NAME,
-            **info,
-        }
-
-
-class PinterestIE(PinterestBaseIE):
-    _VALID_URL = r'%s/pin/(?P<id>\d+)' % PinterestBaseIE._VALID_URL_BASE
-    _TESTS = [{
-        # formats found in data['videos']
-        'url': 'https://www.pinterest.com/pin/664281013778109217/',
-        'md5': '6550c2af85d6d9f3fe3b88954d1577fc',
-        'info_dict': {
-            'id': '664281013778109217',
-            'ext': 'mp4',
-            'title': 'Origami',
-            'description': 'md5:e29801cab7d741ea8c741bc50c8d00ab',
-            'duration': 57.7,
-            'timestamp': 1593073622,
-            'upload_date': '20200625',
-            'repost_count': int,
-            'comment_count': int,
-            'categories': list,
-            'tags': list,
-            'thumbnail': r're:^https?://.*\.(?:jpg|png)$',
-        },
-    }, {
-        # formats found in data['story_pin_data']
-        'url': 'https://www.pinterest.com/pin/1084663891475263837/',
-        'md5': '069ac19919ab9e1e13fa60de46290b03',
-        'info_dict': {
-            'id': '1084663891475263837',
-            'ext': 'mp4',
-            'title': 'Gadget, Cool products, Amazon product, technology, Kitchen gadgets',
-            'description': 'md5:d0a4b6ae996ff0c6eed83bc869598d13',
-            'uploader': 'CoolCrazyGadgets',
-            'uploader_id': '1084664028912989237',
-            'upload_date': '20211003',
-            'timestamp': 1633246654.0,
-            'duration': 14.9,
-            'comment_count': int,
-            'repost_count': int,
-            'categories': 'count:9',
-            'tags': list,
-            'thumbnail': r're:^https?://.*\.(?:jpg|png)$',
-        },
-    }, {
-        # vimeo.com embed
-        'url': 'https://www.pinterest.ca/pin/441282463481903715/',
-        'info_dict': {
-            'id': '111691128',
-            'ext': 'mp4',
-            'title': 'Tonite Let\'s All Make Love In London (1967)',
-            'description': 'md5:8190f37b3926807809ec57ec21aa77b2',
-            'uploader': 'Vimeo',
-            'uploader_id': '473792960706651251',
-            'upload_date': '20180120',
-            'timestamp': 1516409040,
-            'duration': 3404,
-            'comment_count': int,
-            'repost_count': int,
-            'categories': 'count:9',
-            'tags': [],
-            'thumbnail': r're:^https?://.*\.(?:jpg|png)$',
-            'uploader_url': 'https://vimeo.com/willardandrade',
-        },
-        'params': {
-            'skip_download': 'm3u8',
-        },
-    }, {
-        'url': 'https://co.pinterest.com/pin/824721750502199491/',
-        'only_matching': True,
-    }]
-
-    def _real_extract(self, url):
-        video_id = self._match_id(url)
-        data = self._call_api(
-            'Pin', video_id, {
-                'field_set_key': 'unauth_react_main_pin',
-                'id': video_id,
-            })['data']
-        return self._extract_video(data)
-
-
-class PinterestCollectionIE(PinterestBaseIE):
-    _VALID_URL = r'%s/(?P<username>[^/]+)/(?P<id>[^/?#&]+)' % PinterestBaseIE._VALID_URL_BASE
-    _TESTS = [{
-        'url': 'https://www.pinterest.ca/mashal0407/cool-diys/',
-        'info_dict': {
-            'id': '585890301462791043',
-            'title': 'cool diys',
-        },
-        'playlist_count': 8,
-    }, {
-        'url': 'https://www.pinterest.ca/fudohub/videos/',
-        'info_dict': {
-            'id': '682858430939307450',
-            'title': 'VIDEOS',
-        },
-        'playlist_mincount': 365,
-        'skip': 'Test with extract_formats=False',
-    }]
-
-    @classmethod
-    def suitable(cls, url):
-        return False if PinterestIE.suitable(url) else super(
-            PinterestCollectionIE, cls).suitable(url)
-
-    def _real_extract(self, url):
-        username, slug = self._match_valid_url(url).groups()
-        board = self._call_api(
-            'Board', slug, {
-                'slug': slug,
-                'username': username
-            })['data']
-        board_id = board['id']
-        options = {
-            'board_id': board_id,
-            'page_size': 250,
-        }
-        bookmark = None
-        entries = []
-        while True:
-            if bookmark:
-                options['bookmarks'] = [bookmark]
-            board_feed = self._call_api('BoardFeed', board_id, options)
-            for item in (board_feed.get('data') or []):
-                if not isinstance(item, dict) or item.get('type') != 'pin':
-                    continue
-                video_id = item.get('id')
-                if video_id:
-                    # Some pins may not be available anonymously via pin URL
-                    # video = self._extract_video(item, extract_formats=False)
-                    # video.update({
-                    #     '_type': 'url_transparent',
-                    #     'url': 'https://www.pinterest.com/pin/%s/' % video_id,
-                    # })
-                    # entries.append(video)
-                    entries.append(self._extract_video(item))
-            bookmark = board_feed.get('bookmark')
-            if not bookmark:
-                break
-        return self.playlist_result(
-            entries, playlist_id=board_id, playlist_title=board.get('name'))

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

@@ -1,118 +0,0 @@
-from .common import InfoExtractor
-from ..utils import (
-    ExtractorError,
-    traverse_obj,
-    unified_timestamp,
-)
-
-
-class PixivSketchBaseIE(InfoExtractor):
-    def _call_api(self, video_id, path, referer, note='Downloading JSON metadata'):
-        response = self._download_json(f'https://sketch.pixiv.net/api/{path}', video_id, note=note, headers={
-            'Referer': referer,
-            'X-Requested-With': referer,
-        })
-        errors = traverse_obj(response, ('errors', ..., 'message'))
-        if errors:
-            raise ExtractorError(' '.join(f'{e}.' for e in errors))
-        return response.get('data') or {}
-
-
-class PixivSketchIE(PixivSketchBaseIE):
-    IE_NAME = 'pixiv:sketch'
-    _VALID_URL = r'https?://sketch\.pixiv\.net/@(?P<uploader_id>[a-zA-Z0-9_-]+)/lives/(?P<id>\d+)/?'
-    _TESTS = [{
-        'url': 'https://sketch.pixiv.net/@nuhutya/lives/3654620468641830507',
-        'info_dict': {
-            'id': '7370666691623196569',
-            'title': 'まにあえクリスマス！',
-            'uploader': 'ぬふちゃ',
-            'uploader_id': 'nuhutya',
-            'channel_id': '9844815',
-            'age_limit': 0,
-            'timestamp': 1640351536,
-        },
-        'skip': True,
-    }, {
-        # these two (age_limit > 0) requires you to login on website, but it's actually not required for download
-        'url': 'https://sketch.pixiv.net/@namahyou/lives/4393103321546851377',
-        'info_dict': {
-            'id': '4907995960957946943',
-            'title': 'クリスマスなんて知らん🖕',
-            'uploader': 'すゃもり',
-            'uploader_id': 'suya2mori2',
-            'channel_id': '31169300',
-            'age_limit': 15,
-            'timestamp': 1640347640,
-        },
-        'skip': True,
-    }, {
-        'url': 'https://sketch.pixiv.net/@8aki/lives/3553803162487249670',
-        'info_dict': {
-            'id': '1593420639479156945',
-            'title': 'おまけ本作業(リョナ有)',
-            'uploader': 'おぶい / Obui',
-            'uploader_id': 'oving',
-            'channel_id': '17606',
-            'age_limit': 18,
-            'timestamp': 1640330263,
-        },
-        'skip': True,
-    }]
-
-    def _real_extract(self, url):
-        video_id, uploader_id = self._match_valid_url(url).group('id', 'uploader_id')
-        data = self._call_api(video_id, f'lives/{video_id}.json', url)
-
-        if not traverse_obj(data, 'is_broadcasting'):
-            raise ExtractorError(f'This live is offline. Use https://sketch.pixiv.net/@{uploader_id} for ongoing live.', expected=True)
-
-        m3u8_url = traverse_obj(data, ('owner', 'hls_movie', 'url'))
-        formats = self._extract_m3u8_formats(
-            m3u8_url, video_id, ext='mp4',
-            entry_protocol='m3u8_native', m3u8_id='hls')
-
-        return {
-            'id': video_id,
-            'title': data.get('name'),
-            'formats': formats,
-            'uploader': traverse_obj(data, ('user', 'name'), ('owner', 'user', 'name')),
-            'uploader_id': traverse_obj(data, ('user', 'unique_name'), ('owner', 'user', 'unique_name')),
-            'channel_id': str(traverse_obj(data, ('user', 'pixiv_user_id'), ('owner', 'user', 'pixiv_user_id'))),
-            'age_limit': 18 if data.get('is_r18') else 15 if data.get('is_r15') else 0,
-            'timestamp': unified_timestamp(data.get('created_at')),
-            'is_live': True
-        }
-
-
-class PixivSketchUserIE(PixivSketchBaseIE):
-    IE_NAME = 'pixiv:sketch:user'
-    _VALID_URL = r'https?://sketch\.pixiv\.net/@(?P<id>[a-zA-Z0-9_-]+)/?'
-    _TESTS = [{
-        'url': 'https://sketch.pixiv.net/@nuhutya',
-        'only_matching': True,
-    }, {
-        'url': 'https://sketch.pixiv.net/@namahyou',
-        'only_matching': True,
-    }, {
-        'url': 'https://sketch.pixiv.net/@8aki',
-        'only_matching': True,
-    }]
-
-    @classmethod
-    def suitable(cls, url):
-        return super(PixivSketchUserIE, cls).suitable(url) and not PixivSketchIE.suitable(url)
-
-    def _real_extract(self, url):
-        user_id = self._match_id(url)
-        data = self._call_api(user_id, f'lives/users/@{user_id}.json', url)
-
-        if not traverse_obj(data, 'is_broadcasting'):
-            try:
-                self._call_api(user_id, 'users/current.json', url, 'Investigating reason for request failure')
-            except ExtractorError as ex:
-                if ex.cause and ex.cause.code == 401:
-                    self.raise_login_required(f'Please log in, or use direct link like https://sketch.pixiv.net/@{user_id}/1234567890', method='cookies')
-            raise ExtractorError('This user is offline', expected=True)
-
-        return self.url_result(f'https://sketch.pixiv.net/@{user_id}/lives/{data["id"]}')