impersonate=True in download_json, set age limit

yt_dlp/extractor/chaturbate.py

@@ -1,11 +1,11 @@
 import re
 
 from .common import InfoExtractor
-from ..networking import Request
 from ..utils import (
     ExtractorError,
     lowercase_escape,
     url_or_none,
+    urlencode_postdata,
 )
 
 
@@ -41,58 +41,48 @@ class ChaturbateIE(InfoExtractor):
         'only_matching': True,
     }]
 
-    _ROOM_OFFLINE = 'Room is currently offline'
-    _ROOM_PRIVATE = 'Room is currently in a private show'
-    _ROOM_AWAY = 'Performer is currently away'
-    _ROOM_PASSWORD = 'Room is password protected'
-    _ROOM_HIDDEN = 'Hidden session in progress'
-    _ROOM_BLOCKED = 'Room is not avaiable in this region'
+    _ERROR_MAP = {
+        'offline': 'Room is currently offline',
+        'private': 'Room is currently in a private show',
+        'away': 'Performer is currently away',
+        'password protected': 'Room is password protected',
+        'hidden': 'Hidden session in progress',
+    }
 
     def _extract_from_api(self, video_id, tld):
-        req = Request(
-            f'https://chaturbate.{tld}/get_edge_hls_url_ajax/',
-            data=f'room_slug={video_id}'.encode(),
+        response = self._download_json(
+            f'https://chaturbate.{tld}/get_edge_hls_url_ajax/', video_id,
+            data=urlencode_postdata({'room_slug': video_id}),
             headers={
+                **self.geo_verification_headers(),
                 'X-Requested-With': 'XMLHttpRequest',
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-        )
-        response = self._download_json(req, video_id, fatal=False)
+                'Accept': 'application/json',
+            }, fatal=False, impersonate=True) or {}
 
         status = response.get('room_status')
-        if status == 'offline':
-            raise ExtractorError(self._ROOM_OFFLINE, expected=True)
-        elif status == 'private':
-            raise ExtractorError(self._ROOM_PRIVATE, expected=True)
-        elif status == 'away':
-            raise ExtractorError(self._ROOM_AWAY, expected=True)
-        elif status == 'hidden':
-            raise ExtractorError(self._ROOM_HIDDEN, expected=True)
-        elif status == 'password protected':
-            raise ExtractorError(self._ROOM_PASSWORD, expected=True)
-        elif status != 'public':
+        if status != 'public':
+            if error := self._ERROR_MAP.get(status):
+                raise ExtractorError(error, expected=True)
+            self.report_warning('Falling back to webpage extraction')
             return None
 
         m3u8_url = response.get('url')
         if not m3u8_url:
-            raise ExtractorError(self._ROOM_BLOCKED, expected=True)
-
-        formats = self._extract_m3u8_formats(
-            m3u8_url, video_id, ext='mp4',
-            fatal=False, live=True)
+            self.raise_geo_restricted()
 
         return {
             'id': video_id,
             'title': video_id,
             'thumbnail': f'https://roomimg.stream.highwebmedia.com/ri/{video_id}.jpg',
             'is_live': True,
-            'formats': formats,
+            'age_limit': 18,
+            'formats': self._extract_m3u8_formats(m3u8_url, video_id, ext='mp4', live=True),
         }
 
     def _extract_from_webpage(self, video_id, tld):
         webpage = self._download_webpage(
             f'https://chaturbate.{tld}/{video_id}/', video_id,
-            headers=self.geo_verification_headers())
+            headers=self.geo_verification_headers(), impersonate=True)
 
         found_m3u8_urls = []
 
@@ -130,8 +120,8 @@ class ChaturbateIE(InfoExtractor):
                 webpage, 'error', group='error', default=None)
             if not error:
                 if any(p in webpage for p in (
-                        self._ROOM_OFFLINE, 'offline_tipping', 'tip_offline')):
-                    error = self._ROOM_OFFLINE
+                        self._ERROR_MAP['offline'], 'offline_tipping', 'tip_offline')):
+                    error = self._ERROR_MAP['offline']
             if error:
                 raise ExtractorError(error, expected=True)
             raise ExtractorError('Unable to find stream URL')
@@ -161,7 +151,4 @@ class ChaturbateIE(InfoExtractor):
 
     def _real_extract(self, url):
         video_id, tld = self._match_valid_url(url).group('id', 'tld')
-        extraction = self._extract_from_api(video_id, tld)
-        if extraction is None:
-            extraction = self._extract_from_webpage(video_id, tld)
-        return extraction
+        return self._extract_from_api(video_id, tld) or self._extract_from_webpage(video_id, tld)