yt-dlp 2026.1.19.233146.dev0__py3-none-any.whl → 2026.1.27.233257.dev0__py3-none-any.whl

yt_dlp/extractor/patreon.py

@@ -1,6 +1,5 @@
 import functools
 import itertools
-import urllib.parse
 
 from .common import InfoExtractor
 from .sproutvideo import VidsIoIE
@@ -11,15 +10,23 @@ from ..utils import (
     ExtractorError,
     clean_html,
     determine_ext,
+    extract_attributes,
+    float_or_none,
     int_or_none,
     mimetype2ext,
     parse_iso8601,
     smuggle_url,
     str_or_none,
+    update_url_query,
     url_or_none,
     urljoin,
 )
-from ..utils.traversal import require, traverse_obj, value
+from ..utils.traversal import (
+    find_elements,
+    require,
+    traverse_obj,
+    value,
+)
 
 
 class PatreonBaseIE(InfoExtractor):
@@ -121,6 +128,7 @@ class PatreonIE(PatreonBaseIE):
             'channel_is_verified': True,
             'chapters': 'count:4',
             'timestamp': 1423689666,
+            'media_type': 'video',
         },
         'params': {
             'noplaylist': True,
@@ -161,7 +169,7 @@ class PatreonIE(PatreonBaseIE):
             'uploader_url': 'https://www.patreon.com/loish',
             'description': 'md5:e2693e97ee299c8ece47ffdb67e7d9d2',
             'title': 'VIDEO // sketchbook flipthrough',
-            'uploader': 'Loish ',
+            'uploader': 'Loish',
             'tags': ['sketchbook', 'video'],
             'channel_id': '1641751',
             'channel_url': 'https://www.patreon.com/loish',
@@ -274,8 +282,73 @@ class PatreonIE(PatreonBaseIE):
             'channel_id': '9346307',
         },
         'params': {'getcomments': True},
+    }, {
+        # Inlined media in post; uses _extract_from_media_api
+        'url': 'https://www.patreon.com/posts/scottfalco-146966245',
+        'info_dict': {
+            'id': '146966245',
+            'ext': 'mp4',
+            'title': 'scottfalco 1080',
+            'description': 'md5:a3f29bbd0a46b4821ec3400957c98aa2',
+            'uploader': 'Insanimate',
+            'uploader_id': '2828146',
+            'uploader_url': 'https://www.patreon.com/Insanimate',
+            'channel_id': '6260877',
+            'channel_url': 'https://www.patreon.com/Insanimate',
+            'channel_follower_count': int,
+            'comment_count': int,
+            'like_count': int,
+            'duration': 7.833333,
+            'timestamp': 1767061800,
+            'upload_date': '20251230',
+        },
     }]
     _RETURN_TYPE = 'video'
+    _HTTP_HEADERS = {
+        # Must be all-lowercase 'referer' so we can smuggle it to Generic, SproutVideo, and Vimeo.
+        # patreon.com URLs redirect to www.patreon.com; this matters when requesting mux.com m3u8s
+        'referer': 'https://www.patreon.com/',
+    }
+
+    def _extract_from_media_api(self, media_id):
+        attributes = traverse_obj(
+            self._call_api(f'media/{media_id}', media_id, fatal=False),
+            ('data', 'attributes', {dict}))
+        if not attributes:
+            return None
+
+        info_dict = traverse_obj(attributes, {
+            'title': ('file_name', {lambda x: x.rpartition('.')[0]}),
+            'timestamp': ('created_at', {parse_iso8601}),
+            'duration': ('display', 'duration', {float_or_none}),
+        })
+        info_dict['id'] = media_id
+
+        playback_url = traverse_obj(
+            attributes, ('display', (None, 'viewer_playback_data'), 'url', {url_or_none}, any))
+        download_url = traverse_obj(attributes, ('download_url', {url_or_none}))
+
+        if playback_url and mimetype2ext(attributes.get('mimetype')) == 'm3u8':
+            info_dict['formats'], info_dict['subtitles'] = self._extract_m3u8_formats_and_subtitles(
+                playback_url, media_id, 'mp4', fatal=False, headers=self._HTTP_HEADERS)
+            for f in info_dict['formats']:
+                f['http_headers'] = self._HTTP_HEADERS
+            if transcript_url := traverse_obj(attributes, ('display', 'transcript_url', {url_or_none})):
+                info_dict['subtitles'].setdefault('en', []).append({
+                    'url': transcript_url,
+                    'ext': 'vtt',
+                })
+        elif playback_url or download_url:
+            info_dict['formats'] = [{
+                # If playback_url is available, download_url is a duplicate lower resolution format
+                'url': playback_url or download_url,
+                'vcodec': 'none' if attributes.get('media_type') != 'video' else None,
+            }]
+
+        if not info_dict.get('formats'):
+            return None
+
+        return info_dict
 
     def _real_extract(self, url):
         video_id = self._match_id(url)
@@ -299,6 +372,7 @@ class PatreonIE(PatreonBaseIE):
             'comment_count': ('comment_count', {int_or_none}),
         })
 
+        seen_media_ids = set()
         entries = []
         idx = 0
         for include in traverse_obj(post, ('included', lambda _, v: v['type'])):
@@ -320,6 +394,8 @@ class PatreonIE(PatreonBaseIE):
                         'url': download_url,
                         'alt_title': traverse_obj(media_attributes, ('file_name', {str})),
                     })
+                if media_id := traverse_obj(include, ('id', {str})):
+                    seen_media_ids.add(media_id)
 
             elif include_type == 'user':
                 info.update(traverse_obj(include, {
@@ -340,34 +416,29 @@ class PatreonIE(PatreonBaseIE):
                     'channel_follower_count': ('attributes', 'patron_count', {int_or_none}),
                 }))
 
-        # Must be all-lowercase 'referer' so we can smuggle it to Generic, SproutVideo, and Vimeo.
-        # patreon.com URLs redirect to www.patreon.com; this matters when requesting mux.com m3u8s
-        headers = {'referer': 'https://www.patreon.com/'}
-
-        # handle Vimeo embeds
-        if traverse_obj(attributes, ('embed', 'provider')) == 'Vimeo':
-            v_url = urllib.parse.unquote(self._html_search_regex(
-                r'(https(?:%3A%2F%2F|://)player\.vimeo\.com.+app_id(?:=|%3D)+\d+)',
-                traverse_obj(attributes, ('embed', 'html', {str})), 'vimeo url', fatal=False) or '')
-            if url_or_none(v_url) and self._request_webpage(
-                    v_url, video_id, 'Checking Vimeo embed URL', headers=headers,
-                    fatal=False, errnote=False, expected_status=429):  # 429 is TLS fingerprint rejection
-                entries.append(self.url_result(
-                    VimeoIE._smuggle_referrer(v_url, headers['referer']),
-                    VimeoIE, url_transparent=True))
-
-        embed_url = traverse_obj(attributes, ('embed', 'url', {url_or_none}))
-        if embed_url and (urlh := self._request_webpage(
-                embed_url, video_id, 'Checking embed URL', headers=headers,
-                fatal=False, errnote=False, expected_status=403)):
-            # Vimeo's Cloudflare anti-bot protection will return HTTP status 200 for 404, so we need
-            # to check for "Sorry, we couldn’t find that page" in the meta description tag
-            meta_description = clean_html(self._html_search_meta(
-                'description', self._webpage_read_content(urlh, embed_url, video_id, fatal=False), default=None))
-            # Password-protected vids.io embeds return 403 errors w/o --video-password or session cookie
-            if ((urlh.status != 403 and meta_description != 'Sorry, we couldn’t find that page')
-                    or VidsIoIE.suitable(embed_url)):
-                entries.append(self.url_result(smuggle_url(embed_url, headers)))
+        if embed_url := traverse_obj(attributes, ('embed', 'url', {url_or_none})):
+            # Convert useless vimeo.com URLs to useful player.vimeo.com embed URLs
+            vimeo_id, vimeo_hash = self._search_regex(
+                r'//vimeo\.com/(\d+)(?:/([\da-f]+))?', embed_url,
+                'vimeo id', group=(1, 2), default=(None, None))
+            if vimeo_id:
+                embed_url = update_url_query(
+                    f'https://player.vimeo.com/video/{vimeo_id}',
+                    {'h': vimeo_hash or []})
+            if VimeoIE.suitable(embed_url):
+                entry = self.url_result(
+                    VimeoIE._smuggle_referrer(embed_url, self._HTTP_HEADERS['referer']),
+                    VimeoIE, url_transparent=True)
+            else:
+                entry = self.url_result(smuggle_url(embed_url, self._HTTP_HEADERS))
+
+            if urlh := self._request_webpage(
+                embed_url, video_id, 'Checking embed URL', headers=self._HTTP_HEADERS,
+                fatal=False, errnote=False, expected_status=(403, 429),  # Ignore Vimeo 429's
+            ):
+                # Password-protected vids.io embeds return 403 errors w/o --video-password or session cookie
+                if VidsIoIE.suitable(embed_url) or urlh.status != 403:
+                    entries.append(entry)
 
         post_file = traverse_obj(attributes, ('post_file', {dict}))
         if post_file:
@@ -381,13 +452,27 @@ class PatreonIE(PatreonBaseIE):
                 })
             elif name == 'video' or determine_ext(post_file.get('url')) == 'm3u8':
                 formats, subtitles = self._extract_m3u8_formats_and_subtitles(
-                    post_file['url'], video_id, headers=headers)
+                    post_file['url'], video_id, headers=self._HTTP_HEADERS)
+                for f in formats:
+                    f['http_headers'] = self._HTTP_HEADERS
                 entries.append({
                     'id': video_id,
                     'formats': formats,
                     'subtitles': subtitles,
-                    'http_headers': headers,
                 })
+            if media_id := traverse_obj(post_file, ('media_id', {int}, {str_or_none})):
+                seen_media_ids.add(media_id)
+
+        for media_id in traverse_obj(attributes, (
+            'content', {find_elements(attr='data-media-id', value=r'\d+', regex=True, html=True)},
+            ..., {extract_attributes}, 'data-media-id',
+        )):
+            # Inlined media may be duplicates of what was extracted above
+            if media_id in seen_media_ids:
+                continue
+            if media := self._extract_from_media_api(media_id):
+                entries.append(media)
+                seen_media_ids.add(media_id)
 
         can_view_post = traverse_obj(attributes, 'current_user_can_view')
         comments = None

yt_dlp/extractor/pbs.py

@@ -453,6 +453,23 @@ class PBSIE(InfoExtractor):
             'url': 'https://player.pbs.org/portalplayer/3004638221/?uid=',
             'only_matching': True,
         },
+        {
+            # Next.js v13+, see https://github.com/yt-dlp/yt-dlp/issues/13299
+            'url': 'https://www.pbs.org/video/caregiving',
+            'info_dict': {
+                'id': '3101776876',
+                'ext': 'mp4',
+                'title': 'Caregiving - Caregiving',
+                'description': 'A documentary revealing America’s caregiving crisis through intimate stories and expert insight.',
+                'display_id': 'caregiving',
+                'duration': 6783,
+                'thumbnail': 'https://image.pbs.org/video-assets/BSrSkcc-asset-mezzanine-16x9-nlcxQts.jpg',
+                'chapters': [],
+            },
+            'params': {
+                'skip_download': True,
+            },
+        },
     ]
     _ERRORS = {
         101: 'We\'re sorry, but this video is not yet available.',
@@ -506,6 +523,7 @@ class PBSIE(InfoExtractor):
                 r"(?s)window\.PBS\.playerConfig\s*=\s*{.*?id\s*:\s*'([0-9]+)',",
                 r'<div[^>]+\bdata-cove-id=["\'](\d+)"',  # http://www.pbs.org/wgbh/roadshow/watch/episode/2105-indianapolis-hour-2/
                 r'<iframe[^>]+\bsrc=["\'](?:https?:)?//video\.pbs\.org/widget/partnerplayer/(\d+)',  # https://www.pbs.org/wgbh/masterpiece/episodes/victoria-s2-e1/
+                r'\\"videoTPMediaId\\":\\\"(\d+)\\"',  # Next.js v13, e.g. https://www.pbs.org/video/caregiving
                 r'\bhttps?://player\.pbs\.org/[\w-]+player/(\d+)',      # last pattern to avoid false positives
             ]
 

yt_dlp/extractor/rumble.py

@@ -405,7 +405,7 @@ class RumbleChannelIE(InfoExtractor):
             for video_url in traverse_obj(
                 get_elements_html_by_class('videostream__link', webpage), (..., {extract_attributes}, 'href'),
             ):
-                yield self.url_result(urljoin('https://rumble.com', video_url))
+                yield self.url_result(urljoin('https://rumble.com', video_url), RumbleIE)
 
     def _real_extract(self, url):
         url, playlist_id = self._match_valid_url(url).groups()

yt_dlp/extractor/tiktok.py

@@ -1,4 +1,6 @@
+import base64
 import functools
+import hashlib
 import itertools
 import json
 import random
@@ -15,6 +17,7 @@ from ..utils import (
     UnsupportedError,
     UserNotLive,
     determine_ext,
+    extract_attributes,
     filter_dict,
     format_field,
     int_or_none,
@@ -25,13 +28,13 @@ from ..utils import (
     qualities,
     srt_subtitles_timecode,
     str_or_none,
-    traverse_obj,
     truncate_string,
     try_call,
     try_get,
     url_or_none,
     urlencode_postdata,
 )
+from ..utils.traversal import find_element, require, traverse_obj
 
 
 class TikTokBaseIE(InfoExtractor):
@@ -217,38 +220,94 @@ class TikTokBaseIE(InfoExtractor):
             raise ExtractorError('Unable to extract aweme detail info', video_id=aweme_id)
         return self._parse_aweme_video_app(aweme_detail)
 
+    def _solve_challenge_and_set_cookie(self, webpage):
+        challenge_data = traverse_obj(webpage, (
+            {find_element(id='cs', html=True)}, {extract_attributes}, 'class',
+            filter, {lambda x: f'{x}==='}, {base64.b64decode}, {json.loads}))
+
+        if not challenge_data:
+            if 'Please wait...' in webpage:
+                raise ExtractorError('Unable to extract challenge data')
+            raise ExtractorError('Unexpected response from webpage request')
+
+        self.to_screen('Solving JS challenge using native Python implementation')
+
+        expected_digest = traverse_obj(challenge_data, (
+            'v', 'c', {str}, {base64.b64decode},
+            {require('challenge expected digest')}))
+
+        base_hash = traverse_obj(challenge_data, (
+            'v', 'a', {str}, {base64.b64decode},
+            {hashlib.sha256}, {require('challenge base hash')}))
+
+        for i in range(1_000_001):
+            number = str(i).encode()
+            test_hash = base_hash.copy()
+            test_hash.update(number)
+            if test_hash.digest() == expected_digest:
+                challenge_data['d'] = base64.b64encode(number).decode()
+                break
+        else:
+            raise ExtractorError('Unable to solve JS challenge')
+
+        cookie_value = base64.b64encode(
+            json.dumps(challenge_data, separators=(',', ':')).encode()).decode()
+
+        # At time of writing, the cookie name was _wafchallengeid
+        cookie_name = traverse_obj(webpage, (
+            {find_element(id='wci', html=True)}, {extract_attributes},
+            'class', {require('challenge cookie name')}))
+
+        # Actual JS sets Max-Age=1, but we need to adjust for --sleep-requests and Python slowness
+        expire_time = int(time.time()) + (self.get_param('sleep_interval_requests') or 0) + 2
+        self._set_cookie('.tiktok.com', cookie_name, cookie_value, expire_time=expire_time)
+
     def _extract_web_data_and_status(self, url, video_id, fatal=True):
         video_data, status = {}, -1
 
-        res = self._download_webpage_handle(url, video_id, fatal=fatal, impersonate=True)
-        if res is False:
-            return video_data, status
+        def get_webpage(note='Downloading webpage'):
+            res = self._download_webpage_handle(url, video_id, note, fatal=fatal, impersonate=True)
+            if res is False:
+                return False
 
-        webpage, urlh = res
-        if urllib.parse.urlparse(urlh.url).path == '/login':
-            message = 'TikTok is requiring login for access to this content'
-            if fatal:
-                self.raise_login_required(message)
-            self.report_warning(f'{message}. {self._login_hint()}')
+            webpage, urlh = res
+            if urllib.parse.urlparse(urlh.url).path == '/login':
+                message = 'TikTok is requiring login for access to this content'
+                if fatal:
+                    self.raise_login_required(message)
+                self.report_warning(f'{message}. {self._login_hint()}', video_id=video_id)
+                return False
+
+            return webpage
+
+        webpage = get_webpage()
+        if webpage is False:
             return video_data, status
 
-        if universal_data := self._get_universal_data(webpage, video_id):
-            self.write_debug('Found universal data for rehydration')
-            status = traverse_obj(universal_data, ('webapp.video-detail', 'statusCode', {int})) or 0
-            video_data = traverse_obj(universal_data, ('webapp.video-detail', 'itemInfo', 'itemStruct', {dict}))
+        universal_data = self._get_universal_data(webpage, video_id)
+        if not universal_data:
+            try:
+                self._solve_challenge_and_set_cookie(webpage)
+            except ExtractorError as e:
+                if fatal:
+                    raise
+                self.report_warning(e.orig_msg, video_id=video_id)
+                return video_data, status
 
-        elif sigi_data := self._get_sigi_state(webpage, video_id):
-            self.write_debug('Found sigi state data')
-            status = traverse_obj(sigi_data, ('VideoPage', 'statusCode', {int})) or 0
-            video_data = traverse_obj(sigi_data, ('ItemModule', video_id, {dict}))
+            webpage = get_webpage(note='Downloading webpage with challenge cookie')
+            if webpage is False:
+                return video_data, status
+            universal_data = self._get_universal_data(webpage, video_id)
 
-        elif next_data := self._search_nextjs_data(webpage, video_id, default={}):
-            self.write_debug('Found next.js data')
-            status = traverse_obj(next_data, ('props', 'pageProps', 'statusCode', {int})) or 0
-            video_data = traverse_obj(next_data, ('props', 'pageProps', 'itemInfo', 'itemStruct', {dict}))
+        if not universal_data:
+            message = 'Unable to extract universal data for rehydration'
+            if fatal:
+                raise ExtractorError(message)
+            self.report_warning(message, video_id=video_id)
+            return video_data, status
 
-        elif fatal:
-            raise ExtractorError('Unable to extract webpage video data')
+        status = traverse_obj(universal_data, ('webapp.video-detail', 'statusCode', {int})) or 0
+        video_data = traverse_obj(universal_data, ('webapp.video-detail', 'itemInfo', 'itemStruct', {dict}))
 
         if not traverse_obj(video_data, ('video', {dict})) and traverse_obj(video_data, ('isContentClassified', {bool})):
             message = 'This post may not be comfortable for some audiences. Log in for access'

yt_dlp/extractor/volejtv.py

@@ -1,40 +1,167 @@
+import functools
+
 from .common import InfoExtractor
+from ..utils import (
+    InAdvancePagedList,
+    int_or_none,
+    join_nonempty,
+    orderedSet,
+    str_or_none,
+    strftime_or_none,
+    unified_timestamp,
+    url_or_none,
+)
+from ..utils.traversal import (
+    require,
+    traverse_obj,
+)
+
+
+class VolejTVBaseIE(InfoExtractor):
+    TBR_HEIGHT_MAPPING = {
+        '6000': 1080,
+        '2400': 720,
+        '1500': 480,
+        '800': 360,
+    }
+
+    def _call_api(self, endpoint, display_id, query=None):
+        return self._download_json(
+            f'https://api-volejtv-prod.apps.okd4.devopsie.cloud/api/{endpoint}',
+            display_id, query=query)
 
 
-class VolejTVIE(InfoExtractor):
-    _VALID_URL = r'https?://volej\.tv/video/(?P<id>\d+)'
+class VolejTVIE(VolejTVBaseIE):
+    IE_NAME = 'volejtv:match'
+    _VALID_URL = r'https?://volej\.tv/match/(?P<id>\d+)'
     _TESTS = [{
-        'url': 'https://volej.tv/video/725742/',
+        'url': 'https://volej.tv/match/270579',
         'info_dict': {
-            'id': '725742',
+            'id': '270579',
             'ext': 'mp4',
-            'description': 'Zápas VK Královo Pole vs VK Prostějov 10.12.2022 v 19:00 na Volej.TV',
-            'thumbnail': 'https://volej.tv/images/og/16/17186/og.png',
-            'title': 'VK Královo Pole vs VK Prostějov',
+            'title': 'SWE-CZE (2024-06-16)',
+            'categories': ['ženy'],
+            'series': 'ZLATÁ EVROPSKÁ VOLEJBALOVÁ LIGA',
+            'season': '2023-2024',
+            'timestamp': 1718553600,
+            'upload_date': '20240616',
         },
     }, {
-        'url': 'https://volej.tv/video/725605/',
+        'url': 'https://volej.tv/match/487520',
         'info_dict': {
-            'id': '725605',
+            'id': '487520',
             'ext': 'mp4',
-            'thumbnail': 'https://volej.tv/images/og/15/17185/og.png',
-            'title': 'VK Lvi Praha vs VK Euro Sitex Příbram',
-            'description': 'Zápas VK Lvi Praha vs VK Euro Sitex Příbram 11.12.2022 v 19:00 na Volej.TV',
+            'thumbnail': r're:https://.+\.(png|jpeg)',
+            'title': 'FRA-CZE (2024-09-06)',
+            'categories': ['mládež'],
+            'series': 'Mistrovství Evropy do 20 let',
+            'season': '2024-2025',
+            'timestamp': 1725627600,
+            'upload_date': '20240906',
+
         },
     }]
 
     def _real_extract(self, url):
         video_id = self._match_id(url)
-        webpage = self._download_webpage(url, video_id)
-        json_data = self._search_json(
-            r'<\s*!\[CDATA[^=]+=', webpage, 'CDATA', video_id)
-        formats, subtitle = self._extract_m3u8_formats_and_subtitles(
-            json_data['urls']['hls'], video_id)
-        return {
+        json_data = self._call_api(f'match/{video_id}', video_id)
+
+        formats = []
+        for video in traverse_obj(json_data, ('videos', 0, 'qualities', lambda _, v: url_or_none(v['cloud_front_path']))):
+            formats.append(traverse_obj(video, {
+                'url': 'cloud_front_path',
+                'tbr': ('quality', {int_or_none}),
+                'format_id': ('id', {str_or_none}),
+                'height': ('quality', {self.TBR_HEIGHT_MAPPING.get}),
+            }))
+
+        data = {
             'id': video_id,
-            'title': self._html_search_meta(['og:title', 'twitter:title'], webpage),
-            'thumbnail': self._html_search_meta(['og:image', 'twitter:image'], webpage),
-            'description': self._html_search_meta(['description', 'og:description', 'twitter:description'], webpage),
+            **traverse_obj(json_data, {
+                'series': ('competition_name', {str}),
+                'season': ('season', {str}),
+                'timestamp': ('match_time', {unified_timestamp}),
+                'categories': ('category', ('title'), {str}, filter, all, filter),
+                'thumbnail': ('poster', {url_or_none}),
+            }),
             'formats': formats,
-            'subtitles': subtitle,
         }
+
+        teams = orderedSet(traverse_obj(json_data, ('teams', ..., 'shortcut', {str})))
+        if len(teams) > 2 and 'FIN' in teams:
+            teams.remove('FIN')
+
+        data['title'] = join_nonempty(
+            join_nonempty(*teams, delim='-'),
+            strftime_or_none(data.get('timestamp'), '(%Y-%m-%d)'),
+            delim=' ')
+
+        return data
+
+
+class VolejTVPlaylistBaseIE(VolejTVBaseIE):
+    """Subclasses must set _API_FILTER, _PAGE_SIZE"""
+
+    def _get_page(self, playlist_id, page):
+        return self._call_api(
+            f'match/{self._API_FILTER}/{playlist_id}', playlist_id,
+            query={'page': page + 1, 'take': self._PAGE_SIZE, 'order': 'DESC'})
+
+    def _entries(self, playlist_id, first_page_data, page):
+        entries = first_page_data if page == 0 else self._get_page(playlist_id, page)
+        for match_id in traverse_obj(entries, ('data', ..., 'id')):
+            yield self.url_result(f'https://volej.tv/match/{match_id}', VolejTVIE)
+
+
+class VolejTVClubPlaylistIE(VolejTVPlaylistBaseIE):
+    IE_NAME = 'volejtv:club'
+    _VALID_URL = r'https?://volej\.tv/klub/(?P<id>\d+)'
+    _TESTS = [{
+        'url': 'https://volej.tv/klub/1173',
+        'info_dict': {
+            'id': '1173',
+            'title': 'VK Jihostroj České Budějovice',
+        },
+        'playlist_mincount': 30,
+    }]
+    _API_FILTER = 'by-team-id-paginated'
+    _PAGE_SIZE = 6
+
+    def _real_extract(self, url):
+        playlist_id = self._match_id(url)
+        title = self._call_api(f'team/show/{playlist_id}', playlist_id)['title']
+        first_page_data = self._get_page(playlist_id, 0)
+        total_pages = traverse_obj(first_page_data, ('meta', 'pageCount', {int}, {require('page count')}))
+        return self.playlist_result(InAdvancePagedList(
+            functools.partial(self._entries, playlist_id, first_page_data),
+            total_pages, self._PAGE_SIZE), playlist_id, title)
+
+
+class VolejTVCategoryPlaylistIE(VolejTVPlaylistBaseIE):
+    IE_NAME = 'volejtv:category'
+    _VALID_URL = r'https?://volej\.tv/kategorie/(?P<id>[^/$?]+)'
+    _TESTS = [{
+        'url': 'https://volej.tv/kategorie/chance-cesky-pohar',
+        'info_dict': {
+            'id': 'chance-cesky-pohar',
+            'title': 'Chance Český pohár',
+        },
+        'playlist_mincount': 30,
+    }]
+    _API_FILTER = 'by-category-id-paginated'
+    _PAGE_SIZE = 10
+
+    def _get_category(self, playlist_id):
+        categories = self._call_api('category', playlist_id)
+        for category in traverse_obj(categories, (lambda _, v: v['slug'] and v['id'] and v['title'])):
+            if category['slug'] == playlist_id:
+                return category['id'], category['title']
+
+    def _real_extract(self, url):
+        playlist_id = self._match_id(url)
+        category_id, title = self._get_category(playlist_id)
+        first_page_data = self._get_page(category_id, 0)
+        total_pages = traverse_obj(first_page_data, ('meta', 'pageCount', {int}, {require('page count')}))
+        return self.playlist_result(InAdvancePagedList(
+            functools.partial(self._entries, category_id, first_page_data),
+            total_pages, self._PAGE_SIZE), playlist_id, title)

yt_dlp/extractor/wat.py

@@ -76,7 +76,7 @@ class WatIE(InfoExtractor):
             if error_code == 'GEOBLOCKED':
                 self.raise_geo_restricted(error_desc, video_info.get('geoList'))
             elif error_code == 'DELIVERY_ERROR':
-                if traverse_obj(video_data, ('delivery', 'code')) == 500:
+                if traverse_obj(video_data, ('delivery', 'code')) in (403, 500):
                     self.report_drm(video_id)
                 error_desc = join_nonempty(
                     error_desc, traverse_obj(video_data, ('delivery', 'error', {str})), delim=': ')

yt_dlp/version.py

@@ -1,8 +1,8 @@
 # Autogenerated by devscripts/update-version.py
 
-__version__ = '2026.01.19.233146'
+__version__ = '2026.01.27.233257'
 
-RELEASE_GIT_HEAD = 'c8680b65f79cfeb23b342b70ffe1e233902f7933'
+RELEASE_GIT_HEAD = '1c739bf53e673e06d2a43feddb5a31ee8496fa6e'
 
 VARIANT = 'pip'
 
@@ -12,4 +12,4 @@ CHANNEL = 'nightly'
 
 ORIGIN = 'yt-dlp/yt-dlp-nightly-builds'
 
-_pkg_version = '2026.01.19.233146dev'
+_pkg_version = '2026.01.27.233257dev'

{yt_dlp-2026.1.19.233146.dev0.dist-info → yt_dlp-2026.1.27.233257.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yt-dlp
-Version: 2026.1.19.233146.dev0
+Version: 2026.1.27.233257.dev0
 Summary: A feature-rich command-line audio/video downloader
 Project-URL: Documentation, https://github.com/yt-dlp/yt-dlp#readme
 Project-URL: Repository, https://github.com/yt-dlp/yt-dlp