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

@@ -1,507 +0,0 @@
-"""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

@@ -1,153 +0,0 @@
-"""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

@@ -1,48 +0,0 @@
-"""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