Fix for StreamURLFetcher - Needs to be improved

Author: mytja

youtubesearchpython/core/streamurlfetcher.py

@@ -1,3 +1,4 @@
+import json
 import urllib.request
 
 from youtubesearchpython.core.requests import RequestCore
@@ -31,21 +32,11 @@ def __init__(self):
     Saving videoFormats inside a dictionary with key "player_response" for apply_descrambler & apply_signature methods.
     '''
     def _getDecipheredURLs(self, videoFormats: dict) -> None:
-        if not videoFormats['streamingData']:
-            try:
-                self.use_oauth = False
-                self.allow_oauth_cache = False
-                self.video_id = videoFormats["id"]
-                self.bypass_age_gate()
-                r = self._vid_info["streamingData"]
-                ''' Derived from extract.video_info_url_age_restricted '''
-                ''' Google returns content as a query string instead of a JSON. '''
-            except:
-                raise Exception('ERROR: Could not make request.')
-        else:
-            r = videoFormats["streamingData"]
-        self._player_response = {'player_response': r}
         self.video_id = videoFormats["id"]
+        self._player_response = videoFormats
+        url = f"https://www.youtube.com/watch?v={self.video_id}"
+        self.youtube = pytube.YouTube(url)
+
         self._decipher()
 
     '''
@@ -56,49 +47,36 @@ def _getDecipheredURLs(self, videoFormats: dict) -> None:
     Removed v parameter from the query. (No idea about why PyTube bothered with that)
     '''
     def _getJS(self) -> None:
-        response = urllib.request.urlopen('https://youtube.com/watch')
-        watch_html = response.read().decode()
-        try:
-            self._js_url = extract.js_url(watch_html)
-            if pytube.__js_url__ != self._js_url:
-                response = httpx.get(self._js_url, timeout = None)
-                self._js = response.text
-                pytube.__js__ = self._js
-                pytube.__js_url__ = self._js_url
-            else:
-                self._js = pytube.__js__
-        except:
-            raise Exception('ERROR: Could not make request.')
-
-    async def _asyncGetJS(self):
-        # Due to some errors with JS fetching with httpx, we are now using sync urllib
-        self._getJS()
+        self._js = self.youtube.js
 
     async def getJavaScript(self):
-        await self._asyncGetJS()
+        # we don't wanna break compatibility, so we just pass
+        pass
 
     '''
     Not fetching for new player JavaScript if pytube.__js__ is not None or exception is not caused.
     '''
     def _decipher(self, retry: bool = False):
         if not pytube.__js__ or retry:
+            self.youtube._js = None
+            self.youtube._js_url = None
+            pytube.__js__ = None
+            pytube.__js_url__ = None
             self._getJS()
         try:
             '''
             These two are the main methods being used from PyTube.
             Used to decipher the stream URLs using player JavaScript & the player_response passed from the getStream method of this derieved class.
             These methods operate on the value of "player_response" key in dictionary of self._player_response & save _deciphered information in the "url_encoded_fmt_stream_map" key.
             '''
+            #self._player_response = self.youtube.vid_info
+            with open("test2.json", "w+", encoding="utf-8") as f:
+                f.write(json.dumps(self.youtube.vid_info))
 
-            stream = apply_descrambler(self._player_response["player_response"])
-
-            try:
-                apply_signature(
-                    stream, self._player_response, pytube.__js__
-                )
-            except:
-                # TODO: Applying signature is randomly failing - not to me, but on GitHub Actions server. I disabled throwing errors, since we don't want a whole mailbox of failed tests...
-                pass
+            stream = apply_descrambler(self._player_response["streamingData"])
+            apply_signature(
+                stream, self._player_response, pytube.__js__
+            )
             self._streams = stream
         except Exception as e:
             if retry:

youtubesearchpython/core/video.py

@@ -1,3 +1,4 @@
+import copy
 import json
 from typing import Union, List
 from urllib.parse import urlencode
@@ -20,7 +21,16 @@ def __init__(self, videoLink: str, componentMode: str, resultMode: int, timeout:
             'racyCheckOk': True,
             "videoId": getVideoId(self.videoLink)
         })
-        self.data = requestPayload
+        self.data = {
+            'context': {
+                'client': {
+                    'clientName': 'ANDROID',
+                    'clientVersion': '16.20',
+                    'clientScreen': 'EMBED'
+                }
+            },
+            'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+        }
 
     def post_request_processing(self):
         self.__parseSource()
@@ -46,6 +56,8 @@ def sync_create(self):
     def __parseSource(self) -> None:
         try:
             self.responseSource = json.loads(self.response)
+            with open("test.json", "w+", encoding="utf-8") as f:
+                f.write(self.response)
         except Exception as e:
             raise Exception('ERROR: Could not parse YouTube response.')
 
@@ -83,10 +95,5 @@ def __getVideoComponent(self, mode: str) -> None:
             component['isLiveNow'] = component['isLiveContent'] and component['duration']['secondsText'] == "0"
             component['link'] = 'https://www.youtube.com/watch?v=' + component['id']
             component['channel']['link'] = 'https://www.youtube.com/channel/' + component['channel']['id']
-            videoComponent.update(component)
-        if mode in ['getFormats', None]:
-            component = {
-                'streamingData': getValue(self.responseSource, ['streamingData']),
-            }
-            videoComponent.update(component)
-        self.__videoComponent = videoComponent
+            self.responseSource.update(component)
+        self.__videoComponent = self.responseSource

youtubesearchpython/streamurlfetcher.py

@@ -27,7 +27,7 @@ class StreamURLFetcher(StreamURLFetcherCore):
     '''
     def __init__(self):
         super().__init__()
-        self._getJS()
+        #self._getJS()
 
     def get(self, videoFormats: dict, itag: int) -> Union[str, None]:
         '''Gets direct stream URL for a YouTube video fetched using `Video.get` or `Video.getFormats`.