@tushar-br/desktop 1.0.282 → 1.0.283

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

@@ -0,0 +1,507 @@
+"""This module is designed to interact with the innertube API.
+
+This module is NOT intended to be used directly by end users, as each of the
+interfaces returns raw results. These should instead be parsed to extract
+the useful information for the end user.
+"""
+# Native python imports
+import json
+import os
+import pathlib
+import time
+from urllib import parse
+
+# Local imports
+from pytube import request
+
+# YouTube on TV client secrets
+_client_id = '861556708454-d6dlm3lh05idd8npek18k6be8ba3oc68.apps.googleusercontent.com'
+_client_secret = 'SboVhoG9s0rNafixCSGGKXAT'
+
+# Extracted API keys -- unclear what these are linked to.
+_api_keys = [
+    'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
+    'AIzaSyCtkvNIR1HCEwzsqK6JuE6KqpyjusIRI30',
+    'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
+    'AIzaSyC8UYZpvA2eknNex0Pjid0_eTLJoDu6los',
+    'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
+    'AIzaSyDHQ9ipnphqTzDqZsbtd8_Ru4_kiKVQe2k'
+]
+
+_default_clients = {
+    'WEB': {
+        'context': {
+            'client': {
+                'clientName': 'WEB',
+                'clientVersion': '2.20200720.00.02'
+            }
+        },
+        'header': {
+            'User-Agent': 'Mozilla/5.0'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'ANDROID': {
+        'context': {
+            'client': {
+                'clientName': 'ANDROID',
+                'clientVersion': '17.31.35',
+                'androidSdkVersion': 30
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.android.youtube/',
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'IOS': {
+        'context': {
+            'client': {
+                'clientName': 'IOS',
+                'clientVersion': '17.33.2',
+                'deviceModel': 'iPhone14,3'
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.ios.youtube/'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+
+    'WEB_EMBED': {
+        'context': {
+            'client': {
+                'clientName': 'WEB_EMBEDDED_PLAYER',
+                'clientVersion': '2.20210721.00.00',
+                'clientScreen': 'EMBED'
+            }
+        },
+        'header': {
+            'User-Agent': 'Mozilla/5.0'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'ANDROID_EMBED': {
+        'context': {
+            'client': {
+                'clientName': 'ANDROID_EMBEDDED_PLAYER',
+                'clientVersion': '17.31.35',
+                'clientScreen': 'EMBED',
+                'androidSdkVersion': 30,
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.android.youtube/'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'IOS_EMBED': {
+        'context': {
+            'client': {
+                'clientName': 'IOS_MESSAGES_EXTENSION',
+                'clientVersion': '17.33.2',
+                'deviceModel': 'iPhone14,3'
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.ios.youtube/'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+
+    'WEB_MUSIC': {
+        'context': {
+            'client': {
+                'clientName': 'WEB_REMIX',
+                'clientVersion': '1.20220727.01.00',
+            }
+        },
+        'header': {
+            'User-Agent': 'Mozilla/5.0'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'ANDROID_MUSIC': {
+        'context': {
+            'client': {
+                'clientName': 'ANDROID_MUSIC',
+                'clientVersion': '5.16.51',
+                'androidSdkVersion': 30
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.android.apps.youtube.music/'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'IOS_MUSIC': {
+        'context': {
+            'client': {
+                'clientName': 'IOS_MUSIC',
+                'clientVersion': '5.21',
+                'deviceModel': 'iPhone14,3'
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.ios.youtubemusic/'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+
+    'WEB_CREATOR': {
+        'context': {
+            'client': {
+                'clientName': 'WEB_CREATOR',
+                'clientVersion': '1.20220726.00.00',
+            }
+        },
+        'header': {
+            'User-Agent': 'Mozilla/5.0'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'ANDROID_CREATOR': {
+        'context': {
+            'client': {
+                'clientName': 'ANDROID_CREATOR',
+                'clientVersion': '22.30.100',
+                'androidSdkVersion': 30,
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.android.apps.youtube.creator/',
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+    'IOS_CREATOR': {
+        'context': {
+            'client': {
+                'clientName': 'IOS_CREATOR',
+                'clientVersion': '22.33.101',
+                'deviceModel': 'iPhone14,3',
+            }
+        },
+        'header': {
+            'User-Agent': 'com.google.ios.ytcreator/'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+
+    'MWEB': {
+        'context': {
+            'client': {
+                'clientName': 'MWEB',
+                'clientVersion': '2.20220801.00.00',
+            }
+        },
+        'header': {
+            'User-Agent': 'Mozilla/5.0'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+
+    'TV_EMBED': {
+        'context': {
+            'client': {
+                'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
+                'clientVersion': '2.0',
+            }
+        },
+        'header': {
+            'User-Agent': 'Mozilla/5.0'
+        },
+        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+    },
+}
+_token_timeout = 1800
+_cache_dir = pathlib.Path(__file__).parent.resolve() / '__cache__'
+_token_file = os.path.join(_cache_dir, 'tokens.json')
+
+
+class InnerTube:
+    """Object for interacting with the innertube API."""
+    def __init__(self, client='ANDROID_MUSIC', use_oauth=False, allow_cache=True):
+        """Initialize an InnerTube object.
+
+        :param str client:
+            Client to use for the object.
+            Default to web because it returns the most playback types.
+        :param bool use_oauth:
+            Whether or not to authenticate to YouTube.
+        :param bool allow_cache:
+            Allows caching of oauth tokens on the machine.
+        """
+        self.context = _default_clients[client]['context']
+        self.header = _default_clients[client]['header']
+        self.api_key = _default_clients[client]['api_key']
+        self.access_token = None
+        self.refresh_token = None
+        self.use_oauth = use_oauth
+        self.allow_cache = allow_cache
+
+        # Stored as epoch time
+        self.expires = None
+
+        # Try to load from file if specified
+        if self.use_oauth and self.allow_cache:
+            # Try to load from file if possible
+            if os.path.exists(_token_file):
+                with open(_token_file) as f:
+                    data = json.load(f)
+                    self.access_token = data['access_token']
+                    self.refresh_token = data['refresh_token']
+                    self.expires = data['expires']
+                    self.refresh_bearer_token()
+
+    def cache_tokens(self):
+        """Cache tokens to file if allowed."""
+        if not self.allow_cache:
+            return
+
+        data = {
+            'access_token': self.access_token,
+            'refresh_token': self.refresh_token,
+            'expires': self.expires
+        }
+        if not os.path.exists(_cache_dir):
+            os.mkdir(_cache_dir)
+        with open(_token_file, 'w') as f:
+            json.dump(data, f)
+
+    def refresh_bearer_token(self, force=False):
+        """Refreshes the OAuth token if necessary.
+
+        :param bool force:
+            Force-refresh the bearer token.
+        """
+        if not self.use_oauth:
+            return
+        # Skip refresh if it's not necessary and not forced
+        if self.expires > time.time() and not force:
+            return
+
+        # Subtracting 30 seconds is arbitrary to avoid potential time discrepencies
+        start_time = int(time.time() - 30)
+        data = {
+            'client_id': _client_id,
+            'client_secret': _client_secret,
+            'grant_type': 'refresh_token',
+            'refresh_token': self.refresh_token
+        }
+        response = request._execute_request(
+            'https://oauth2.googleapis.com/token',
+            'POST',
+            headers={
+                'Content-Type': 'application/json'
+            },
+            data=data
+        )
+        response_data = json.loads(response.read())
+
+        self.access_token = response_data['access_token']
+        self.expires = start_time + response_data['expires_in']
+        self.cache_tokens()
+
+    def fetch_bearer_token(self):
+        """Fetch an OAuth token."""
+        # Subtracting 30 seconds is arbitrary to avoid potential time discrepencies
+        start_time = int(time.time() - 30)
+        data = {
+            'client_id': _client_id,
+            'scope': 'https://www.googleapis.com/auth/youtube'
+        }
+        response = request._execute_request(
+            'https://oauth2.googleapis.com/device/code',
+            'POST',
+            headers={
+                'Content-Type': 'application/json'
+            },
+            data=data
+        )
+        response_data = json.loads(response.read())
+        verification_url = response_data['verification_url']
+        user_code = response_data['user_code']
+        print(f'Please open {verification_url} and input code {user_code}')
+        input('Press enter when you have completed this step.')
+
+        data = {
+            'client_id': _client_id,
+            'client_secret': _client_secret,
+            'device_code': response_data['device_code'],
+            'grant_type': 'urn:ietf:params:oauth:grant-type:device_code'
+        }
+        response = request._execute_request(
+            'https://oauth2.googleapis.com/token',
+            'POST',
+            headers={
+                'Content-Type': 'application/json'
+            },
+            data=data
+        )
+        response_data = json.loads(response.read())
+
+        self.access_token = response_data['access_token']
+        self.refresh_token = response_data['refresh_token']
+        self.expires = start_time + response_data['expires_in']
+        self.cache_tokens()
+
+    @property
+    def base_url(self):
+        """Return the base url endpoint for the innertube API."""
+        return 'https://www.youtube.com/youtubei/v1'
+
+    @property
+    def base_data(self):
+        """Return the base json data to transmit to the innertube API."""
+        return {
+            'context': self.context
+        }
+
+    @property
+    def base_params(self):
+        """Return the base query parameters to transmit to the innertube API."""
+        return {
+            'key': self.api_key,
+            'contentCheckOk': True,
+            'racyCheckOk': True
+        }
+
+    def _call_api(self, endpoint, query, data):
+        """Make a request to a given endpoint with the provided query parameters and data."""
+        # Remove the API key if oauth is being used.
+        if self.use_oauth:
+            del query['key']
+
+        endpoint_url = f'{endpoint}?{parse.urlencode(query)}'
+        headers = {
+            'Content-Type': 'application/json',
+        }
+        # Add the bearer token if applicable
+        if self.use_oauth:
+            if self.access_token:
+                self.refresh_bearer_token()
+                headers['Authorization'] = f'Bearer {self.access_token}'
+            else:
+                self.fetch_bearer_token()
+                headers['Authorization'] = f'Bearer {self.access_token}'
+
+        headers.update(self.header)
+
+        response = request._execute_request(
+            endpoint_url,
+            'POST',
+            headers=headers,
+            data=data
+        )
+        return json.loads(response.read())
+
+    def browse(self):
+        """Make a request to the browse endpoint.
+
+        TODO: Figure out how we can use this
+        """
+        # endpoint = f'{self.base_url}/browse'  # noqa:E800
+        ...
+        # return self._call_api(endpoint, query, self.base_data)  # noqa:E800
+
+    def config(self):
+        """Make a request to the config endpoint.
+
+        TODO: Figure out how we can use this
+        """
+        # endpoint = f'{self.base_url}/config'  # noqa:E800
+        ...
+        # return self._call_api(endpoint, query, self.base_data)  # noqa:E800
+
+    def guide(self):
+        """Make a request to the guide endpoint.
+
+        TODO: Figure out how we can use this
+        """
+        # endpoint = f'{self.base_url}/guide'  # noqa:E800
+        ...
+        # return self._call_api(endpoint, query, self.base_data)  # noqa:E800
+
+    def next(self):
+        """Make a request to the next endpoint.
+
+        TODO: Figure out how we can use this
+        """
+        # endpoint = f'{self.base_url}/next'  # noqa:E800
+        ...
+        # return self._call_api(endpoint, query, self.base_data)  # noqa:E800
+
+    def player(self, video_id):
+        """Make a request to the player endpoint.
+
+        :param str video_id:
+            The video id to get player info for.
+        :rtype: dict
+        :returns:
+            Raw player info results.
+        """
+        endpoint = f'{self.base_url}/player'
+        query = {
+            'videoId': video_id,
+        }
+        query.update(self.base_params)
+        return self._call_api(endpoint, query, self.base_data)
+
+    def search(self, search_query, continuation=None):
+        """Make a request to the search endpoint.
+
+        :param str search_query:
+            The query to search.
+        :rtype: dict
+        :returns:
+            Raw search query results.
+        """
+        endpoint = f'{self.base_url}/search'
+        query = {
+            'query': search_query
+        }
+        query.update(self.base_params)
+        data = {}
+        if continuation:
+            data['continuation'] = continuation
+        data.update(self.base_data)
+        return self._call_api(endpoint, query, data)
+
+    def verify_age(self, video_id):
+        """Make a request to the age_verify endpoint.
+
+        Notable examples of the types of video this verification step is for:
+        * https://www.youtube.com/watch?v=QLdAhwSBZ3w
+        * https://www.youtube.com/watch?v=hc0ZDaAZQT0
+
+        :param str video_id:
+            The video id to get player info for.
+        :rtype: dict
+        :returns:
+            Returns information that includes a URL for bypassing certain restrictions.
+        """
+        endpoint = f'{self.base_url}/verify_age'
+        data = {
+            'nextEndpoint': {
+                'urlEndpoint': {
+                    'url': f'/watch?v={video_id}'
+                }
+            },
+            'setControvercy': True
+        }
+        data.update(self.base_data)
+        result = self._call_api(endpoint, self.base_params, data)
+        return result
+
+    def get_transcript(self, video_id):
+        """Make a request to the get_transcript endpoint.
+
+        This is likely related to captioning for videos, but is currently untested.
+        """
+        endpoint = f'{self.base_url}/get_transcript'
+        query = {
+            'videoId': video_id,
+        }
+        query.update(self.base_params)
+        result = self._call_api(endpoint, query, self.base_data)
+        return result

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

@@ -0,0 +1,153 @@
+"""This module contains a lookup table of YouTube's itag values."""
+from typing import Dict
+
+PROGRESSIVE_VIDEO = {
+    5: ("240p", "64kbps"),
+    6: ("270p", "64kbps"),
+    13: ("144p", None),
+    17: ("144p", "24kbps"),
+    18: ("360p", "96kbps"),
+    22: ("720p", "192kbps"),
+    34: ("360p", "128kbps"),
+    35: ("480p", "128kbps"),
+    36: ("240p", None),
+    37: ("1080p", "192kbps"),
+    38: ("3072p", "192kbps"),
+    43: ("360p", "128kbps"),
+    44: ("480p", "128kbps"),
+    45: ("720p", "192kbps"),
+    46: ("1080p", "192kbps"),
+    59: ("480p", "128kbps"),
+    78: ("480p", "128kbps"),
+    82: ("360p", "128kbps"),
+    83: ("480p", "128kbps"),
+    84: ("720p", "192kbps"),
+    85: ("1080p", "192kbps"),
+    91: ("144p", "48kbps"),
+    92: ("240p", "48kbps"),
+    93: ("360p", "128kbps"),
+    94: ("480p", "128kbps"),
+    95: ("720p", "256kbps"),
+    96: ("1080p", "256kbps"),
+    100: ("360p", "128kbps"),
+    101: ("480p", "192kbps"),
+    102: ("720p", "192kbps"),
+    132: ("240p", "48kbps"),
+    151: ("720p", "24kbps"),
+    300: ("720p", "128kbps"),
+    301: ("1080p", "128kbps"),
+}
+
+DASH_VIDEO = {
+    # DASH Video
+    133: ("240p", None),  # MP4
+    134: ("360p", None),  # MP4
+    135: ("480p", None),  # MP4
+    136: ("720p", None),  # MP4
+    137: ("1080p", None),  # MP4
+    138: ("2160p", None),  # MP4
+    160: ("144p", None),  # MP4
+    167: ("360p", None),  # WEBM
+    168: ("480p", None),  # WEBM
+    169: ("720p", None),  # WEBM
+    170: ("1080p", None),  # WEBM
+    212: ("480p", None),  # MP4
+    218: ("480p", None),  # WEBM
+    219: ("480p", None),  # WEBM
+    242: ("240p", None),  # WEBM
+    243: ("360p", None),  # WEBM
+    244: ("480p", None),  # WEBM
+    245: ("480p", None),  # WEBM
+    246: ("480p", None),  # WEBM
+    247: ("720p", None),  # WEBM
+    248: ("1080p", None),  # WEBM
+    264: ("1440p", None),  # MP4
+    266: ("2160p", None),  # MP4
+    271: ("1440p", None),  # WEBM
+    272: ("4320p", None),  # WEBM
+    278: ("144p", None),  # WEBM
+    298: ("720p", None),  # MP4
+    299: ("1080p", None),  # MP4
+    302: ("720p", None),  # WEBM
+    303: ("1080p", None),  # WEBM
+    308: ("1440p", None),  # WEBM
+    313: ("2160p", None),  # WEBM
+    315: ("2160p", None),  # WEBM
+    330: ("144p", None),  # WEBM
+    331: ("240p", None),  # WEBM
+    332: ("360p", None),  # WEBM
+    333: ("480p", None),  # WEBM
+    334: ("720p", None),  # WEBM
+    335: ("1080p", None),  # WEBM
+    336: ("1440p", None),  # WEBM
+    337: ("2160p", None),  # WEBM
+    394: ("144p", None),  # MP4
+    395: ("240p", None),  # MP4
+    396: ("360p", None),  # MP4
+    397: ("480p", None),  # MP4
+    398: ("720p", None),  # MP4
+    399: ("1080p", None),  # MP4
+    400: ("1440p", None),  # MP4
+    401: ("2160p", None),  # MP4
+    402: ("4320p", None),  # MP4
+    571: ("4320p", None),  # MP4
+    694: ("144p", None),  # MP4
+    695: ("240p", None),  # MP4
+    696: ("360p", None),  # MP4
+    697: ("480p", None),  # MP4
+    698: ("720p", None),  # MP4
+    699: ("1080p", None),  # MP4
+    700: ("1440p", None),  # MP4
+    701: ("2160p", None),  # MP4
+    702: ("4320p", None),  # MP4
+}
+
+DASH_AUDIO = {
+    # DASH Audio
+    139: (None, "48kbps"),  # MP4
+    140: (None, "128kbps"),  # MP4
+    141: (None, "256kbps"),  # MP4
+    171: (None, "128kbps"),  # WEBM
+    172: (None, "256kbps"),  # WEBM
+    249: (None, "50kbps"),  # WEBM
+    250: (None, "70kbps"),  # WEBM
+    251: (None, "160kbps"),  # WEBM
+    256: (None, "192kbps"),  # MP4
+    258: (None, "384kbps"),  # MP4
+    325: (None, None),  # MP4
+    328: (None, None),  # MP4
+}
+
+ITAGS = {
+    **PROGRESSIVE_VIDEO,
+    **DASH_VIDEO,
+    **DASH_AUDIO,
+}
+
+HDR = [330, 331, 332, 333, 334, 335, 336, 337]
+_3D = [82, 83, 84, 85, 100, 101, 102]
+LIVE = [91, 92, 93, 94, 95, 96, 132, 151]
+
+
+def get_format_profile(itag: int) -> Dict:
+    """Get additional format information for a given itag.
+
+    :param str itag:
+        YouTube format identifier code.
+    """
+    itag = int(itag)
+    if itag in ITAGS:
+        res, bitrate = ITAGS[itag]
+    else:
+        res, bitrate = None, None
+    return {
+        "resolution": res,
+        "abr": bitrate,
+        "is_live": itag in LIVE,
+        "is_3d": itag in _3D,
+        "is_hdr": itag in HDR,
+        "is_dash": (
+            itag in DASH_AUDIO
+            or itag in DASH_VIDEO
+        ),
+    }

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

@@ -0,0 +1,48 @@
+"""This module contains the YouTubeMetadata class."""
+import json
+from typing import Dict, List, Optional
+
+
+class YouTubeMetadata:
+    def __init__(self, metadata: List):
+        self._raw_metadata: List = metadata
+        self._metadata = [{}]
+
+        for el in metadata:
+            # We only add metadata to the dict if it has a simpleText title.
+            if 'title' in el and 'simpleText' in el['title']:
+                metadata_title = el['title']['simpleText']
+            else:
+                continue
+
+            contents = el['contents'][0]
+            if 'simpleText' in contents:
+                self._metadata[-1][metadata_title] = contents['simpleText']
+            elif 'runs' in contents:
+                self._metadata[-1][metadata_title] = contents['runs'][0]['text']
+
+            # Upon reaching a dividing line, create a new grouping
+            if el.get('hasDividerLine', False):
+                self._metadata.append({})
+
+        # If we happen to create an empty dict at the end, drop it
+        if self._metadata[-1] == {}:
+            self._metadata = self._metadata[:-1]
+
+    def __getitem__(self, key):
+        return self._metadata[key]
+
+    def __iter__(self):
+        for el in self._metadata:
+            yield el
+
+    def __str__(self):
+        return json.dumps(self._metadata)
+
+    @property
+    def raw_metadata(self) -> Optional[Dict]:
+        return self._raw_metadata
+
+    @property
+    def metadata(self):
+        return self._metadata