'''
Function:
    Implementation of YouTubeMusicClient utils, refer to https://pytubefix.readthedocs.io/en/latest/index.html
Author:
    Zhenchao Jin
WeChat Official Account (微信公众号):
    Charles的皮卡丘
'''
import os
import re
import sys
import ast
import math
import enum
import json
import time
import shutil
import struct
import base64
import socket
import pathlib
import subprocess
import http.client
from enum import Enum
from pathlib import Path
from urllib import parse
from functools import lru_cache
from collections.abc import Sequence
from datetime import datetime, timezone
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
from urllib.parse import parse_qs, urlencode, urlparse
from ..js.youtube import JSInterpreter, extractplayerjsglobalvar
from typing import Callable, List, Optional, Union, Callable, BinaryIO, Dict, Any, Tuple


'''API_KEYS'''
API_KEYS = [
    'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'AIzaSyCtkvNIR1HCEwzsqK6JuE6KqpyjusIRI30', 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w', 'AIzaSyC8UYZpvA2eknNex0Pjid0_eTLJoDu6los',
    'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw', 'AIzaSyDHQ9ipnphqTzDqZsbtd8_Ru4_kiKVQe2k'
]
'''CLIENT DATA'''
CLIENT_ID = '861556708454-d6dlm3lh05idd8npek18k6be8ba3oc68.apps.googleusercontent.com'
CLIENT_SECRET = 'SboVhoG9s0rNafixCSGGKXAT'
DEFAULT_CLIENTS = {
    'WEB': {
        'innertube_context': {'context': {'client': {'clientName': 'WEB', 'osName': 'Windows', 'osVersion': '10.0', 'clientVersion': '2.20251021.01.00', 'platform': 'DESKTOP'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '1', 'X-Youtube-Client-Version': '2.20251021.01.00'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': True
    },
    'WEB_EMBED': {
        'innertube_context': {'context': {'client': {'clientName': 'WEB_EMBEDDED_PLAYER', 'osName': 'Windows', 'osVersion': '10.0', 'clientVersion': '2.20240530.02.00', 'clientScreen': 'EMBED'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '56'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': True
    },
    'WEB_MUSIC': {
        'innertube_context': {'context': {'client': {'clientName': 'WEB_REMIX', 'clientVersion': '1.20251013.03.00'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '67'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': True
    },
    'WEB_CREATOR': {
        'innertube_context': {'context': {'client': {'clientName': 'WEB_CREATOR', 'clientVersion': '1.20220726.00.00'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '62'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': False
    },
    'WEB_SAFARI': {
        'innertube_context': {'context': {'client': {'clientName': 'WEB', 'clientVersion': '2.20240726.00.00'}}},
        'header': {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15,gzip(gfe)', 'X-Youtube-Client-Name': '1'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': True
    },
    'MWEB': {
        'innertube_context': {'context': {'client': {'clientName': 'MWEB', 'clientVersion': '2.20251014.06.00'}}},
        'header': {'User-Agent': 'Mozilla/5.0 (iPad; CPU OS 16_7_10 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1,gzip(gfe)', 'X-Youtube-Client-Name': '2'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': True
    },
    'WEB_KIDS': {
        'innertube_context': {'context': {'client': {'clientName': 'WEB_KIDS', 'osName': 'Windows', 'osVersion': '10.0', 'clientVersion': '2.20241125.00.00', 'platform': 'DESKTOP'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '76', 'X-Youtube-Client-Version': '2.20241125.00.00'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': False
    },
    'ANDROID': {
        'innertube_context': {'context': {'client': {'clientName': 'ANDROID', 'clientVersion': '19.44.38', 'platform': 'MOBILE', 'osName': 'Android', 'osVersion': '14', 'androidSdkVersion': '34'}}},
        'header': {'User-Agent': 'com.google.android.youtube/', 'X-Youtube-Client-Name': '3'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': True
    },
    'ANDROID_VR': {
        'innertube_context': {'context': {'client': {'clientName': 'ANDROID_VR', 'clientVersion': '1.60.19', 'deviceMake': 'Oculus', 'deviceModel': 'Quest 3', 'osName': 'Android', 'osVersion': '12L', 'androidSdkVersion': '32'}}},
        'header': {'User-Agent': 'com.google.android.apps.youtube.vr.oculus/1.60.19 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip', 'X-Youtube-Client-Name': '28'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'ANDROID_MUSIC': {
        'innertube_context': {'context': {'client': {'clientName': 'ANDROID_MUSIC', 'clientVersion': '7.27.52', 'androidSdkVersion': '30', 'osName': 'Android', 'osVersion': '11'}}},
        'header': {'User-Agent': 'com.google.android.apps.youtube.music/7.27.52 (Linux; U; Android 11) gzip', 'X-Youtube-Client-Name': '21'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'ANDROID_CREATOR': {
        'innertube_context': {'context': {'client': {'clientName': 'ANDROID_CREATOR', 'clientVersion': '24.45.100', 'androidSdkVersion': '30', 'osName': 'Android', 'osVersion': '11'}}},
        'header': {'User-Agent': 'com.google.android.apps.youtube.creator/24.45.100 (Linux; U; Android 11) gzip', 'X-Youtube-Client-Name': '14'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'ANDROID_TESTSUITE': {
        'innertube_context': {'context': {'client': {'clientName': 'ANDROID_TESTSUITE', 'clientVersion': '1.9', 'platform': 'MOBILE', 'osName': 'Android', 'osVersion': '14', 'androidSdkVersion': '34'}}},
        'header': {'User-Agent': 'com.google.android.youtube/', 'X-Youtube-Client-Name': '30', 'X-Youtube-Client-Version': '1.9'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'ANDROID_PRODUCER': {
        'innertube_context': {'context': {'client': {'clientName': 'ANDROID_PRODUCER', 'clientVersion': '0.111.1', 'androidSdkVersion': '30', 'osName': 'Android', 'osVersion': '11'}}},
        'header': {'User-Agent': 'com.google.android.apps.youtube.producer/0.111.1 (Linux; U; Android 11) gzip', 'X-Youtube-Client-Name': '91'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'ANDROID_KIDS': {
        'innertube_context': {'context': {'client': {'clientName': 'ANDROID_KIDS', 'clientVersion': '7.36.1', 'androidSdkVersion': '30', 'osName': 'Android', 'osVersion': '11'}}},
        'header': {'User-Agent': 'com.google.android.apps.youtube.music/7.27.52 (Linux; U; Android 11) gzip'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'IOS': {
        'innertube_context': {'context': {'client': {'clientName': 'IOS', 'clientVersion': '19.45.4', 'deviceMake': 'Apple', 'platform': 'MOBILE', 'osName': 'iPhone', 'osVersion': '18.1.0.22B83', 'deviceModel': 'iPhone16,2'}}},
        'header': {'User-Agent': 'com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X;)', 'X-Youtube-Client-Name': '5'},
        'api_key': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc', 'require_js_player': False, 'require_po_token': False
    },
    'IOS_MUSIC': {
        'innertube_context': {'context': {'client': {'clientName': 'IOS_MUSIC', 'clientVersion': '7.27.0', 'deviceMake': 'Apple', 'platform': 'MOBILE', 'osName': 'iPhone', 'osVersion': '18.1.0.22B83', 'deviceModel': 'iPhone16,2'}}},
        'header': {'User-Agent': 'com.google.ios.youtubemusic/7.27.0 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X;)', 'X-Youtube-Client-Name': '26'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'IOS_CREATOR': {
        'innertube_context': {'context': {'client': {'clientName': 'IOS_CREATOR', 'clientVersion': '24.45.100', 'deviceMake': 'Apple', 'deviceModel': 'iPhone16,2', 'osName': 'iPhone', 'osVersion': '18.1.0.22B83'}}},
        'header': {'User-Agent': 'com.google.ios.ytcreator/24.45.100 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X;)', 'X-Youtube-Client-Name': '15'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    },
    'IOS_KIDS': {
        'innertube_context': {'context': {'client': {'clientName': 'IOS_KIDS', 'clientVersion': '7.36.1', 'deviceMake': 'Apple', 'platform': 'MOBILE', 'osName': 'iPhone', 'osVersion': '18.1.0.22B83', 'deviceModel': 'iPhone16,2'}}},
        'header': {'User-Agent': 'com.google.ios.youtube/19.45.4 (iPhone16,2; U; CPU iOS 18_1_0 like Mac OS X;)'},
        'api_key': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc', 'require_js_player': False, 'require_po_token': False
    },
    'TV': {
        'innertube_context': {'context': {'client': {'clientName': 'TVHTML5', 'clientVersion': '7.20240813.07.00', 'platform': 'TV'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '7'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': False
    },
    'TV_EMBED': {
        'innertube_context': {'context': {'client': {'clientName': 'TVHTML5_SIMPLY_EMBEDDED_PLAYER', 'clientVersion': '2.0', 'clientScreen': 'EMBED', 'platform': 'TV'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '85'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': True, 'require_po_token': False
    },
    'MEDIA_CONNECT': {
        'innertube_context': {'context': {'client': {'clientName': 'MEDIA_CONNECT_FRONTEND', 'clientVersion': '0.1'}}},
        'header': {'User-Agent': 'Mozilla/5.0', 'X-Youtube-Client-Name': '95'},
        'api_key': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8', 'require_js_player': False, 'require_po_token': False
    }
}


'''assertuint32'''
def assertuint32(value):
    if not (0 <= value <= 0xFFFFFFFF): raise ValueError("Value is not a valid uint32")


'''assertint32'''
def assertint32(value):
    if not (-0x80000000 <= value <= 0x7FFFFFFF): raise ValueError("Value is not a valid int32")


'''varint32write'''
def varint32write(value, buf: list):
    while value > 0x7F:
        buf.append((value & 0x7F) | 0x80)
        value >>= 7
    buf.append(value)


'''varint64write'''
def varint64write(lo, hi, buf: list):
    for _ in range(9):
        if hi == 0 and lo < 0x80:
            buf.append(lo)
            return
        buf.append((lo & 0x7F) | 0x80)
        lo = ((hi << 25) | (lo >> 7)) & 0xFFFFFFFF
        hi = hi >> 7
    buf.append(lo)


'''readvarint32'''
def readvarint32(buf: bytes, pos: int):
    result = shift = 0
    while True:
        if pos >= len(buf): raise EOFError("Unexpected end of buffer while reading varint32")
        b = buf[pos]
        pos += 1
        result |= (b & 0x7F) << shift
        if not (b & 0x80): break
        shift += 7
        if shift > 35: raise ValueError("Varint32 too long")
    return result, pos


'''readvarint64'''
def readvarint64(buf, pos):
    low_bits, high_bits = 0, 0
    for shift in range(0, 28, 7):
        b = buf[pos]
        pos += 1
        low_bits |= (b & 0x7F) << shift
        if (b & 0x80) == 0: return low_bits, high_bits, pos
    middle_byte = buf[pos]
    pos += 1
    low_bits |= (middle_byte & 0x0F) << 28
    high_bits = (middle_byte & 0x70) >> 4
    if (middle_byte & 0x80) == 0: return low_bits, high_bits, pos
    for shift in range(3, 32, 7):
        b = buf[pos]
        pos += 1
        high_bits |= (b & 0x7F) << shift
        if (b & 0x80) == 0: return low_bits, high_bits, pos
    raise ValueError("invalid varint")


'''decodeint64'''
def decodeint64(lo: int, hi: int):
    value = (hi << 32) | lo
    if hi & 0x80000000: value -= 1 << 64
    return value


'''decodeuint64'''
def decodeuint64(lo: int, hi: int):
    return (hi << 32) | lo


'''longtonumber'''
def longtonumber(int64_value):
    value = int(str(int64_value))
    if value > (2 ** 53 - 1): raise OverflowError("Value is larger than 9007199254740991")
    if value < -(2 ** 53 - 1): raise OverflowError("Value is smaller than -9007199254740991")
    return value


'''targetdirectory'''
def targetdirectory(output_path: Optional[str] = None):
    if output_path:
        if not os.path.isabs(output_path): output_path = os.path.join(os.getcwd(), output_path)
    else:
        output_path = os.getcwd()
    os.makedirs(output_path, exist_ok=True)
    return output_path


'''regexsearch'''
def regexsearch(pattern: str, string: str, group: int):
    regex = re.compile(pattern)
    results = regex.search(string)
    return results.group(group)


'''filesystemverify'''
def filesystemverify(file_type):
    # systems
    bsd_unix = ['BSD', 'UFS']
    mac_os = ['macOS', 'APFS', 'HFS+']
    network_filesystems = ['CIFS', 'SMB']
    windows = ['Windows', 'NTFS', 'FAT32', 'exFAT', 'ReFS']
    linux = ['Linux', 'ext2', 'ext3', 'ext4', 'Btrfs', 'XFS', 'ZFS']
    # return translations
    if file_type in windows: return str.maketrans({'\\': '', '/': '', '?': '', ':': '', '*': '', '"': '', '<': '', '>': '', '|': ''})
    elif file_type in linux: return str.maketrans({'/': ''})
    elif file_type in mac_os: return str.maketrans({'/': ''})
    elif file_type in bsd_unix: return str.maketrans({'/': ''})
    elif file_type in network_filesystems: return str.maketrans({'\\': '', '/': '', '?': '', ':': '', '*': '', '"': '', '<': '', '>': '', '|': ''})


'''mimetypecodec'''
def mimetypecodec(mime_type_codec: str):
    pattern = r"(\w+\/\w+)\;\scodecs=\"([a-zA-Z-0-9.,\s]*)\""
    regex = re.compile(pattern)
    results = regex.search(mime_type_codec)
    mime_type, codecs = results.groups()
    return mime_type, [c.strip() for c in codecs.split(",")]


'''getformatprofile'''
def getformatprofile(itag: str):
    # constants
    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 = {
        133: ("240p", None), 134: ("360p", None), 135: ("480p", None), 136: ("720p", None), 137: ("1080p", None), 138: ("2160p", None), 160: ("144p", None),
        167: ("360p", None), 168: ("480p", None), 169: ("720p", None), 170: ("1080p", None), 212: ("480p", None), 218: ("480p", None), 219: ("480p", None),
        242: ("240p", None), 243: ("360p", None), 244: ("480p", None), 245: ("480p", None), 246: ("480p", None), 247: ("720p", None), 248: ("1080p", None), 
        264: ("1440p", None), 266: ("2160p", None), 271: ("1440p", None), 272: ("4320p", None), 278: ("144p", None), 298: ("720p", None), 299: ("1080p", None),  
        302: ("720p", None), 303: ("1080p", None), 308: ("1440p", None), 313: ("2160p", None), 315: ("2160p", None), 330: ("144p", None), 331: ("240p", None),
        332: ("360p", None), 333: ("480p", None), 334: ("720p", None), 335: ("1080p", None), 336: ("1440p", None), 337: ("2160p", None), 394: ("144p", None), 
        395: ("240p", None), 396: ("360p", None), 397: ("480p", None), 398: ("720p", None), 399: ("1080p", None), 400: ("1440p", None), 401: ("2160p", None), 
        402: ("4320p", None), 571: ("4320p", None), 694: ("144p", None), 695: ("240p", None), 696: ("360p", None), 697: ("480p", None), 698: ("720p", None), 
        699: ("1080p", None), 700: ("1440p", None), 701: ("2160p", None), 702: ("4320p", None),
    }
    DASH_AUDIO = {
        139: (None, "48kbps"), 140: (None, "128kbps"), 141: (None, "256kbps"), 171: (None, "128kbps"), 172: (None, "256kbps"), 249: (None, "50kbps"), 
        250: (None, "70kbps"), 251: (None, "160kbps"), 256: (None, "192kbps"), 258: (None, "384kbps"), 325: (None, None), 328: (None, None), 
    }
    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]
    # parse
    itag = int(itag)
    res, bitrate = ITAGS[itag] if itag in ITAGS else (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)}


'''defaultoauthverifier'''
def defaultoauthverifier(verification_url: str, user_code: str):
    print(f'Please open {verification_url} and input code {user_code}')
    input('Press enter when you have completed this step.')


'''defaultpotokenverifier'''
def defaultpotokenverifier():
    print('You can use the tool: https://github.com/YunzheZJU/youtube-po-token-generator, to get the token')
    visitor_data = str(input("Enter with your visitorData: "))
    po_token = str(input("Enter with your po_token: "))
    return visitor_data, po_token


'''isagerestricted'''
def isagerestricted(watch_html: str):
    try:
        regexsearch(r"og:restrictions:age", watch_html, group=0)
    except:
        return False
    return True


'''getytplayerjs'''
def getytplayerjs(html: str):
    js_url_patterns = [r"(/s/player/[\w\d]+/[\w\d_/.]+/base\.js)"]
    for pattern in js_url_patterns:
        regex = re.compile(pattern)
        function_match = regex.search(html)
        if function_match:
            yt_player_js = function_match.group(1)
            return yt_player_js


'''findobjectfromstartpoint'''
def findobjectfromstartpoint(html, start_point):
    html, last_char, curr_char = html[start_point:], '{', None
    stack, i, context_closers = [html[0]], 1, {'{': '}', '[': ']', '"': '"', '\'': '\'', '/': '/'}
    while i < len(html):
        if not stack: break
        if curr_char not in [' ', '\n']: last_char = curr_char
        curr_char = html[i]
        curr_context = stack[-1]
        if curr_char == context_closers[curr_context]:
            stack.pop()
            i += 1
            continue
        if curr_context in ['"', '\'', '/']:
            if curr_char == '\\':
                i += 2
                continue
        else:
            if curr_char in context_closers.keys():
                if not (curr_char == '/' and last_char not in ['(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';']): 
                    stack.append(curr_char)
        i += 1
    full_obj = html[:i]
    return full_obj


'''parseforobjectfromstartpoint'''
def parseforobjectfromstartpoint(html, start_point):
    full_obj = findobjectfromstartpoint(html, start_point)
    try:
        return json.loads(full_obj)
    except:
        try:
            return ast.literal_eval(full_obj)
        except:
            raise


'''parseforobject'''
def parseforobject(html, preceding_regex):
    regex = re.compile(preceding_regex)
    result = regex.search(html)
    start_index = result.end()
    return parseforobjectfromstartpoint(html, start_index)


'''getytplayerconfig'''
def getytplayerconfig(html: str):
    config_patterns = [r"ytplayer\.config\s*=\s*", r"ytInitialPlayerResponse\s*=\s*"]
    for pattern in config_patterns:
        try:
            return parseforobject(html, pattern)
        except:
            continue
    setconfig_patterns = [r"yt\.setConfig\(.*['\"]PLAYER_CONFIG['\"]:\s*"]
    for pattern in setconfig_patterns:
        try:
            return parseforobject(html, pattern)
        except:
            continue


'''extractjsurl'''
def extractjsurl(html: str):
    try:
        base_js = getytplayerconfig(html)['assets']['js']
    except:
        base_js = getytplayerjs(html)
    return f"https://youtube.com{base_js}"


'''extractsignaturetimestamp'''
def extractsignaturetimestamp(js: str):
    return regexsearch(r"signatureTimestamp:(\d*)", js, group=1)


'''extractvisitordata'''
def extractvisitordata(resp_context: str):
    return regexsearch(r"visitor_data[',\"\s]+value['\"]:\s?['\"]([a-zA-Z0-9_%-]+)['\"]", resp_context, group=1)


'''extractinitialdata'''
def extractinitialdata(watch_html: str):
    patterns = [r"window\[['\"]ytInitialData['\"]]\s*=\s*", r"ytInitialData\s*=\s*"]
    for pattern in patterns:
        try:
            return parseforobject(watch_html, pattern)
        except:
            pass


'''extractmetadata'''
def extractmetadata(initial_data):
    try:
        metadata_rows = initial_data["contents"]["twoColumnWatchNextResults"]["results"]["results"]["contents"][1]["videoSecondaryInfoRenderer"]["metadataRowContainer"]["metadataRowContainerRenderer"]["rows"]
    except:
        YouTubeMetadata([])
    metadata_rows = filter(lambda x: "metadataRowRenderer" in x.keys(), metadata_rows)
    metadata_rows = [x["metadataRowRenderer"] for x in metadata_rows]
    return YouTubeMetadata(metadata_rows)


'''applydescrambler'''
def applydescrambler(stream_data: dict):
    if 'url' in stream_data: return None
    formats = []
    if 'formats' in stream_data.keys(): formats.extend(stream_data['formats'])
    if 'adaptiveFormats' in stream_data.keys(): formats.extend(stream_data['adaptiveFormats'])
    for data in formats:
        if 'url' not in data and 'signatureCipher' in data:
            cipher_url = parse_qs(data['signatureCipher'])
            data['url'] = cipher_url['url'][0]
            data['s'] = cipher_url['s'][0]
            data['is_sabr'] = False
        elif 'url' not in data and 'signatureCipher' not in data:
            data['url'] = stream_data['serverAbrStreamingUrl']
            data['is_sabr'] = True
        data['is_otf'] = data.get('type') == 'FORMAT_STREAM_TYPE_OTF'
    return formats


'''applypotoken'''
def applypotoken(stream_manifest, vid_info: dict, po_token: str):
    for i, stream in enumerate(stream_manifest):
        url: str = stream["url"]
        parsed_url = urlparse(url)
        query_params = parse_qs(urlparse(url).query)
        query_params = {k: v[0] for k, v in query_params.items()}
        query_params['pot'] = po_token
        url = f'{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path}?{urlencode(query_params)}'
        stream_manifest[i]["url"] = url


'''generatepotoken'''
def generatepotoken(video_id: str):
    import nodejs_wheel.executable
    suffix = ".exe" if os.name == "nt" else ""
    bin_dir = nodejs_wheel.executable.ROOT_DIR if os.name == "nt" else os.path.join(nodejs_wheel.executable.ROOT_DIR, "bin")
    try:
        result = subprocess.check_output([os.path.join(bin_dir, 'node' + suffix), str(Path(__file__).resolve().parent.parent / "js" / "youtube" / "botguard.js"), video_id], stderr=subprocess.PIPE).decode()
        return result.replace("\n", "")
    except Exception as err:
        raise RuntimeError(err)


'''extractsignaturetimestamp'''
def extractsignaturetimestamp(js: str):
    return regexsearch(r"signatureTimestamp:(\d*)", js, group=1)


'''applysignature'''
def applysignature(stream_manifest: Dict, vid_info: Dict, js: str, url_js: str):
    cipher = Cipher(js=js, js_url=url_js)
    discovered_n = dict()
    for i, stream in enumerate(stream_manifest):
        try:
            url: str = stream["url"]
        except KeyError:
            live_stream = (vid_info.get("playabilityStatus", {}, ).get("liveStreamability"))
            if live_stream: raise
        parsed_url = urlparse(url)
        query_params = parse_qs(urlparse(url).query)
        query_params = {k: v[0] for k, v in query_params.items()}
        if "signature" in url or ("s" not in stream and ("&sig=" in url or "&lsig=" in url)):
            pass
        else:
            signature = cipher.getsig(ciphered_signature=stream["s"])
            query_params['sig'] = signature
        if 'n' in query_params.keys():
            initial_n = query_params['n']
            if initial_n not in discovered_n: discovered_n[initial_n] = cipher.getnsig(initial_n)
            else: pass
            new_n = discovered_n[initial_n]
            query_params['n'] = new_n
        url = f'{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path}?{urlencode(query_params)}'
        stream_manifest[i]["url"] = url
    cipher.runner_sig.close()
    cipher.runner_nsig.close()


'''ProtoInt64'''
class ProtoInt64:
    '''enc'''
    @staticmethod
    def enc(value: int):
        if value < 0: value += 1 << 64
        lo = value & 0xFFFFFFFF
        hi = (value >> 32) & 0xFFFFFFFF
        return {'lo': lo, 'hi': hi}
    '''uenc'''
    @staticmethod
    def uenc(value: int):
        lo = value & 0xFFFFFFFF
        hi = (value >> 32) & 0xFFFFFFFF
        return {'lo': lo, 'hi': hi}


'''RequestWrapper'''
class RequestWrapper:
    default_range_size = 9437184
    '''_executerequest'''
    @staticmethod
    def _executerequest(url: str, method=None, headers=None, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
        base_headers = {"User-Agent": "Mozilla/5.0", "accept-language": "en-US,en"}
        if headers: base_headers.update(headers)
        if data and not isinstance(data, bytes): data = bytes(json.dumps(data), encoding="utf-8")
        if url.lower().startswith("http"): request = Request(url, headers=base_headers, method=method, data=data)
        else: raise ValueError("Invalid URL")
        return urlopen(request, timeout=timeout)
    '''get'''
    @staticmethod
    def get(url, extra_headers=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
        if extra_headers is None: extra_headers = {}
        resp = RequestWrapper._executerequest(url, headers=extra_headers, timeout=timeout)
        return resp.read().decode("utf-8")
    '''post'''
    @staticmethod
    def post(url, extra_headers=None, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
        if extra_headers is None: extra_headers = {}
        if data is None: data = {}
        extra_headers.update({"Content-Type": "application/json"})
        resp = RequestWrapper._executerequest(url, headers=extra_headers, data=data, timeout=timeout)
        return resp.read().decode("utf-8")
    '''seqstream'''
    @staticmethod
    def seqstream(url, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, max_retries=0):
        split_url = parse.urlsplit(url)
        base_url = f'{split_url.scheme}://{split_url.netloc}/{split_url.path}?'
        querys = dict(parse.parse_qsl(split_url.query))
        querys['sq'] = 0
        url = base_url + parse.urlencode(querys)
        segment_data = b''
        for chunk in RequestWrapper.stream(url, timeout=timeout, max_retries=max_retries):
            yield chunk
            segment_data += chunk
        stream_info = segment_data.split(b'\r\n')
        segment_count_pattern = re.compile(b'Segment-Count: (\\d+)')
        for line in stream_info:
            match = segment_count_pattern.search(line)
            if match: segment_count = int(match.group(1).decode('utf-8'))
        seq_num = 1
        while seq_num <= segment_count:
            querys['sq'] = seq_num
            url = base_url + parse.urlencode(querys)
            yield from RequestWrapper.stream(url, timeout=timeout, max_retries=max_retries)
            seq_num += 1
        return
    '''stream'''
    @staticmethod
    def stream(url, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, max_retries=0):
        downloaded = 0
        file_size: int = RequestWrapper.default_range_size
        while downloaded < file_size:
            stop_pos, tries = min(downloaded + RequestWrapper.default_range_size, file_size) - 1, 0
            while True:
                if tries >= 1 + max_retries: raise HTTPError()
                try:
                    resp = RequestWrapper._executerequest(f"{url}&range={downloaded}-{stop_pos}", method="GET", timeout=timeout)
                except URLError as e:
                    if not isinstance(e.reason, (socket.timeout, OSError)): raise
                except http.client.IncompleteRead: pass
                else: break
                tries += 1
            if file_size == RequestWrapper.default_range_size:
                try:
                    content_range = RequestWrapper._executerequest(f"{url}&range=0-99999999999", method="GET", timeout=timeout).info()["Content-Length"]
                    file_size = int(content_range)
                except (KeyError, IndexError, ValueError) as e:
                    pass
            while True:
                try: chunk = resp.read()
                except StopIteration: return
                except http.client.IncompleteRead as e: chunk = e.partial
                if not chunk: break
                if chunk: downloaded += len(chunk)
                yield chunk
        return
    '''filesize'''
    @staticmethod
    @lru_cache()
    def filesize(url): return int(RequestWrapper.head(url)["content-length"])
    '''seqfilesize'''
    @staticmethod
    @lru_cache()
    def seqfilesize(url):
        total_filesize = 0
        split_url = parse.urlsplit(url)
        base_url = f'{split_url.scheme}://{split_url.netloc}/{split_url.path}?'
        querys = dict(parse.parse_qsl(split_url.query))
        querys['sq'] = 0
        url = base_url + parse.urlencode(querys)
        resp = RequestWrapper._executerequest(url, method="GET")
        resp_value = resp.read()
        total_filesize += len(resp_value)
        segment_count = 0
        stream_info = resp_value.split(b'\r\n')
        segment_regex = b'Segment-Count: (\\d+)'
        for line in stream_info:
            try: segment_count = int(regexsearch(segment_regex, line, 1))
            except: pass
        if segment_count == 0: raise
        seq_num = 1
        while seq_num <= segment_count:
            querys['sq'] = seq_num
            url = base_url + parse.urlencode(querys)
            total_filesize += int(RequestWrapper.head(url)['content-length'])
            seq_num += 1
        return total_filesize
    '''head'''
    @staticmethod
    def head(url: str):
        resp_headers: dict = RequestWrapper._executerequest(url, method="HEAD").info()
        return {k.lower(): v for k, v in resp_headers.items()}


'''NodeRunner'''
class NodeRunner:
    def __init__(self, code: str):
        self.code = code
        self.function_name = None
        self.proc = subprocess.Popen([self._nodepath(), str(Path(__file__).resolve().parent.parent / "js" / "youtube" / "runner.js")], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
    '''_nodepath'''
    @staticmethod
    def _nodepath():
        import nodejs_wheel.executable
        suffix = ".exe" if os.name == "nt" else ""
        bin_dir = nodejs_wheel.executable.ROOT_DIR if os.name == "nt" else os.path.join(nodejs_wheel.executable.ROOT_DIR, "bin")
        return os.path.join(bin_dir, 'node' + suffix)
    '''_exposed'''
    @staticmethod
    def _exposed(code: str, fun_name: str):
        exposed = f"_exposed['{fun_name}']={fun_name};" + "})(_yt_player);"
        return code.replace("})(_yt_player);", exposed)
    '''_send'''
    def _send(self, data):
        self.proc.stdin.write(json.dumps(data) + "\n")
        self.proc.stdin.flush()
        return json.loads(self.proc.stdout.readline())
    '''loadfunction'''
    def loadfunction(self, function_name: str):
        self.function_name = function_name
        return self._send({"type": "load", "code": self._exposed(self.code, function_name)})
    '''call'''
    def call(self, args: list):
        return self._send({"type": "call", "fun": self.function_name, "args": args or []})
    '''close'''
    def close(self):
        self.proc.stdin.close()
        self.proc.terminate()
        self.proc.wait()


'''PART'''
class PART(Enum):
    ONESIE_HEADER = 10
    ONESIE_DATA = 11
    MEDIA_HEADER = 20
    MEDIA = 21
    MEDIA_END = 22
    LIVE_METADATA = 31
    HOSTNAME_CHANGE_HINT = 32
    LIVE_METADATA_PROMISE = 33
    LIVE_METADATA_PROMISE_CANCELLATION = 34
    NEXT_REQUEST_POLICY = 35
    USTREAMER_VIDEO_AND_FORMAT_DATA = 36
    FORMAT_SELECTION_CONFIG = 37
    USTREAMER_SELECTED_MEDIA_STREAM = 38
    FORMAT_INITIALIZATION_METADATA = 42
    SABR_REDIRECT = 43
    SABR_ERROR = 44
    SABR_SEEK = 45
    RELOAD_PLAYER_RESPONSE = 46
    PLAYBACK_START_POLICY = 47
    ALLOWED_CACHED_FORMATS = 48
    START_BW_SAMPLING_HINT = 49
    PAUSE_BW_SAMPLING_HINT = 50
    SELECTABLE_FORMATS = 51
    REQUEST_IDENTIFIER = 52
    REQUEST_CANCELLATION_POLICY = 53
    ONESIE_PREFETCH_REJECTION = 54
    TIMELINE_CONTEXT = 55
    REQUEST_PIPELINING = 56
    SABR_CONTEXT_UPDATE = 57
    STREAM_PROTECTION_STATUS = 58
    SABR_CONTEXT_SENDING_POLICY = 59
    LAWNMOWER_POLICY = 60
    SABR_ACK = 61
    END_OF_TRACK = 62
    CACHE_LOAD_POLICY = 63
    LAWNMOWER_MESSAGING_POLICY = 64
    PREWARM_CONNECTION = 65
    PLAYBACK_DEBUG_INFO = 66
    SNACKBAR_MESSAGE = 67


'''PoTokenStatus'''
class PoTokenStatus(Enum):
    UNKNOWN = -1
    OK = enum.auto()
    MISSING = enum.auto()
    INVALID = enum.auto()
    PENDING = enum.auto()
    NOT_REQUIRED = enum.auto()
    PENDING_MISSING = enum.auto()


'''Monostate'''
class Monostate:
    def __init__(self, on_progress: Optional[Callable[[Any, bytes, int], None]], on_complete: Optional[Callable[[Any, Optional[str]], None]], 
                 title: Optional[str] = None, duration: Optional[int] = None, youtube = None):
        self.on_progress = on_progress
        self.on_complete = on_complete
        self.title = title
        self.duration = duration
        self.youtube = youtube


'''ChunkedDataBuffer'''
class ChunkedDataBuffer:
    def __init__(self, chunks=None):
        self.chunks = []
        self.current_chunk_index = 0
        self.current_chunk_offset = 0
        self.current_data_view = None
        self.total_length = 0
        chunks = chunks or []
        for chunk in chunks: self.append(chunk)
    '''getlength'''
    def getlength(self):
        return self.total_length
    '''append'''
    def append(self, chunk):
        if self.canmergewithlastchunk(chunk):
            last_chunk = self.chunks[-1]
            merged = bytearray(last_chunk)
            merged.extend(chunk)
            self.chunks[-1] = bytes(merged)
            self.resetfocus()
        else:
            self.chunks.append(chunk)
        self.total_length += len(chunk)
    '''split'''
    def split(self, position):
        extracted_buffer, remaining_buffer, remaining_pos = ChunkedDataBuffer(), ChunkedDataBuffer(), position
        for chunk in self.chunks:
            chunk_len = len(chunk)
            if remaining_pos >= chunk_len:
                extracted_buffer.append(chunk)
                remaining_pos -= chunk_len
            elif remaining_pos > 0:
                extracted_buffer.append(chunk[:remaining_pos])
                remaining_buffer.append(chunk[remaining_pos:])
                remaining_pos = 0
            else:
                remaining_buffer.append(chunk)
        return {"extracted_buffer": extracted_buffer, "remaining_buffer": remaining_buffer}
    '''isfocused'''
    def isfocused(self, position):
        chunk = self.chunks[self.current_chunk_index]
        return self.current_chunk_offset <= position < self.current_chunk_offset + len(chunk)
    '''focus'''
    def focus(self, position):
        if not self.isfocused(position):
            if position < self.current_chunk_offset: self.resetfocus()
            while (self.current_chunk_offset + len(self.chunks[self.current_chunk_index]) <= position and self.current_chunk_index < len(self.chunks) - 1):
                self.current_chunk_offset += len(self.chunks[self.current_chunk_index])
                self.current_chunk_index += 1
            self.current_data_view = None
    '''canreadbytes'''
    def canreadbytes(self, position, length):
        return position + length <= self.total_length
    '''getuint8'''
    def getuint8(self, position):
        self.focus(position)
        chunk = self.chunks[self.current_chunk_index]
        return chunk[position - self.current_chunk_offset]
    '''canmergewithlastchunk'''
    def canmergewithlastchunk(self, chunk):
        if not self.chunks: return False
        last_chunk = self.chunks[-1]
        return (last_chunk is not None and isinstance(last_chunk, (bytes, bytearray)) and isinstance(chunk, (bytes, bytearray)))
    '''resetfocus'''
    def resetfocus(self):
        self.current_data_view = None
        self.current_chunk_index = 0
        self.current_chunk_offset = 0


'''UMP'''
class UMP:
    def __init__(self, chunked_data_buffer: ChunkedDataBuffer):
        self.chunked_data_buffer = chunked_data_buffer
    '''parse'''
    def parse(self, handle_part):
        while True:
            offset = 0
            part_type, new_offset = self.readvarint(offset)
            offset = new_offset
            part_size, final_offset = self.readvarint(offset)
            offset = final_offset
            if part_type < 0 or part_size < 0: break
            if not self.chunked_data_buffer.canreadbytes(offset, part_size):
                if not self.chunked_data_buffer.canreadbytes(offset, 1): break
                return {"type": part_type, "size": part_size, "data": self.chunked_data_buffer}
            split_result = self.chunked_data_buffer.split(offset)['remaining_buffer'].split(part_size)
            offset = 0
            handle_part({"type": part_type, "size": part_size, "data": split_result['extracted_buffer']})
            self.chunked_data_buffer = split_result['remaining_buffer']
    '''readvarint'''
    def readvarint(self, offset):
        if self.chunked_data_buffer.canreadbytes(offset, 1):
            first_byte = self.chunked_data_buffer.getuint8(offset)
            if first_byte < 128: byte_length = 1
            elif first_byte < 192: byte_length = 2
            elif first_byte < 224: byte_length = 3
            elif first_byte < 240: byte_length = 4
            else: byte_length = 5
        else:
            byte_length = 0
        if byte_length < 1 or not self.chunked_data_buffer.canreadbytes(offset, byte_length): return -1, offset
        if byte_length == 1:
            value = self.chunked_data_buffer.getuint8(offset)
            offset += 1
        elif byte_length == 2:
            byte1 = self.chunked_data_buffer.getuint8(offset)
            byte2 = self.chunked_data_buffer.getuint8(offset + 1)
            value = (byte1 & 0x3F) + 64 * byte2
            offset += 2
        elif byte_length == 3:
            byte1 = self.chunked_data_buffer.getuint8(offset)
            byte2 = self.chunked_data_buffer.getuint8(offset + 1)
            byte3 = self.chunked_data_buffer.getuint8(offset + 2)
            value = (byte1 & 0x1F) + 32 * (byte2 + 256 * byte3)
            offset += 3
        elif byte_length == 4:
            byte1 = self.chunked_data_buffer.getuint8(offset)
            byte2 = self.chunked_data_buffer.getuint8(offset + 1)
            byte3 = self.chunked_data_buffer.getuint8(offset + 2)
            byte4 = self.chunked_data_buffer.getuint8(offset + 3)
            value = (byte1 & 0x0F) + 16 * (byte2 + 256 * (byte3 + 256 * byte4))
            offset += 4
        else:
            temp_offset = offset + 1
            self.chunked_data_buffer.focus(temp_offset)
            if self.canreadfromcurrentchunk(temp_offset, 4):
                view = self.getcurrentdataview()
                offset_in_chunk = temp_offset - self.chunked_data_buffer.current_chunk_offset
                value = int.from_bytes(view[offset_in_chunk:offset_in_chunk + 4], byteorder='little')
            else:
                byte3 = (self.chunked_data_buffer.getuint8(temp_offset + 2) + 256 * self.chunked_data_buffer.getuint8(temp_offset + 3))
                value = (self.chunked_data_buffer.getuint8(temp_offset) + 256 * (self.chunked_data_buffer.getuint8(temp_offset + 1) + 256 * byte3))
            offset += 5
        return value, offset
    '''canreadfromcurrentchunk'''
    def canreadfromcurrentchunk(self, offset, length):
        index = self.chunked_data_buffer.current_chunk_index
        current_chunk = self.chunked_data_buffer.chunks[index]
        return (offset - self.chunked_data_buffer.current_chunk_offset + length <= len(current_chunk))
    '''getcurrentdataview'''
    def getcurrentdataview(self):
        if self.chunked_data_buffer.current_data_view is None:
            chunk = self.chunked_data_buffer.chunks[self.chunked_data_buffer.current_chunk_index]
            self.chunked_data_buffer.current_data_view = memoryview(chunk)
        return self.chunked_data_buffer.current_data_view


'''Stream'''
class Stream:
    def __init__(self, stream: Dict, monostate: Monostate, po_token: str, video_playback_ustreamer_config: str):
        self._monostate = monostate
        self.url = stream["url"]
        self.itag = int(stream["itag"])
        self.xtags = stream["xtags"] if "xtags" in stream else None
        self.mime_type, self.codecs = mimetypecodec(stream["mimeType"])
        self.type, self.subtype = self.mime_type.split("/")
        self.video_codec, self.audio_codec = self.parsecodecs()
        self.is_otf: bool = stream["is_otf"]
        self.bitrate: Optional[int] = stream["bitrate"]
        self._filesize: Optional[int] = int(stream.get('contentLength', 0))
        self._filesize_kb: Optional[float] = float(math.ceil(float(stream.get('contentLength', 0)) / 1024 * 1000) / 1000)
        self._filesize_mb: Optional[float] = float(math.ceil(float(stream.get('contentLength', 0)) / 1024 / 1024 * 1000) / 1000)
        self._filesize_gb: Optional[float] = float(math.ceil(float(stream.get('contentLength', 0)) / 1024 / 1024 / 1024 * 1000) / 1000)
        itag_profile = getformatprofile(self.itag)
        self.is_dash = itag_profile["is_dash"]
        self.abr = itag_profile["abr"]
        if 'fps' in stream: self.fps = stream['fps']
        self.resolution = itag_profile["resolution"]
        self._width = stream["width"] if 'width' in stream else None
        self._height = stream["height"] if 'height' in stream else None
        self.is_3d = itag_profile["is_3d"]
        self.is_hdr = itag_profile["is_hdr"]
        self.is_live = itag_profile["is_live"]
        self.is_drc = stream.get('isDrc', False)
        self._is_sabr = stream.get('is_sabr', False)
        self.durationMs = stream['approxDurationMs']
        self.last_Modified = stream['lastModified']
        self.po_token = po_token
        self.video_playback_ustreamer_config = video_playback_ustreamer_config
        self.includes_multiple_audio_tracks: bool = 'audioTrack' in stream
        if self.includes_multiple_audio_tracks:
            self.is_default_audio_track = "original" in stream['audioTrack']['displayName']
            self.audio_track_name_regionalized = str(stream['audioTrack']['displayName']).replace(" original", "")
            self.audio_track_name = self.audio_track_name_regionalized.split(" ")[0]
            self.audio_track_language_id_regionalized= str(stream['audioTrack']['id']).split(".")[0]
            self.audio_track_language_id= self.audio_track_language_id_regionalized.split("-")[0] 
        else:
            self.is_default_audio_track = self.includesaudiotrack and not self.includesvideotrack
            self.audio_track_name_regionalized = None
            self.audio_track_name = None
            self.audio_track_language_id_regionalized = None
            self.audio_track_language_id= None
    '''isadaptive'''
    @property
    def isadaptive(self): return bool(len(self.codecs) % 2)
    '''isprogressive'''
    @property
    def isprogressive(self): return not self.isadaptive
    '''issabr'''
    @property
    def issabr(self): return self._is_sabr
    @issabr.setter
    def issabr(self, value): self._is_sabr = value
    '''includesaudiotrack'''
    @property
    def includesaudiotrack(self): return self.isprogressive or self.type == "audio"
    '''includesvideotrack'''
    @property
    def includesvideotrack(self): return self.isprogressive or self.type == "video"
    '''parsecodecs'''
    def parsecodecs(self):
        video, audio = None, None
        if not self.isadaptive: video, audio = self.codecs
        elif self.includesvideotrack: video = self.codecs[0]
        elif self.includesaudiotrack: audio = self.codecs[0]
        return video, audio
    '''width'''
    @property
    def width(self): return self._width
    '''height'''
    @property
    def height(self): return self._height
    '''filesize'''
    @property
    def filesize(self):
        if self._filesize == 0:
            try:
                self._filesize = RequestWrapper.filesize(self.url)
            except HTTPError as e:
                if e.code != 404: raise
                self._filesize = RequestWrapper.seqfilesize(self.url)
        return self._filesize
    '''filesizekb'''
    @property
    def filesizekb(self):
        if self._filesize_kb == 0:
            try:
                self._filesize_kb = float(math.ceil(RequestWrapper.filesize(self.url) / 1024 * 1000) / 1000)
            except HTTPError as e:
                if e.code != 404: raise
                self._filesize_kb = float(math.ceil(RequestWrapper.seqfilesize(self.url) / 1024 * 1000) / 1000)
        return self._filesize_kb
    '''filesizemb'''
    @property
    def filesizemb(self):
        if self._filesize_mb == 0:
            try:
                self._filesize_mb = float(math.ceil(RequestWrapper.filesize(self.url) / 1024 / 1024 * 1000) / 1000)
            except HTTPError as e:
                if e.code != 404: raise
                self._filesize_mb = float(math.ceil(RequestWrapper.seqfilesize(self.url) / 1024 / 1024 * 1000) / 1000)
        return self._filesize_mb
    '''filesizegb'''
    @property
    def filesizegb(self):
        if self._filesize_gb == 0:
            try:
                self._filesize_gb = float(math.ceil(RequestWrapper.filesize(self.url) / 1024 / 1024 / 1024 * 1000) / 1000)
            except HTTPError as e:
                if e.code != 404: raise
                self._filesize_gb = float(math.ceil(RequestWrapper.seqfilesize(self.url) / 1024 / 1024 / 1024 * 1000) / 1000)
        return self._filesize_gb
    '''title'''
    @property
    def title(self):
        return self._monostate.title or "Unknown YouTube Video Title"
    '''filesizeapprox'''
    @property
    def filesizeapprox(self):
        if self._monostate.duration and self.bitrate:
            bits_in_byte = 8
            return int((self._monostate.duration * self.bitrate) / bits_in_byte)
        return self.filesize
    '''expiration'''
    @property
    def expiration(self):
        expire = parse_qs(self.url.split("?")[1])["expire"][0]
        return datetime.fromtimestamp(int(expire), timezone.utc)
    '''defaultfilename'''
    @property
    def defaultfilename(self):
        if 'audio' in self.mime_type and 'video' not in self.mime_type:
            self.subtype = "m4a"
        return f"{self.title}.{self.subtype}"
    '''download'''
    def download(self, output_path: Optional[str] = None, filename: Optional[str] = None, filename_prefix: Optional[str] = None, skip_existing: bool = True, timeout: Optional[int] = None, max_retries: int = 0, interrupt_checker: Optional[Callable[[], bool]] = None):
        kernel = sys.platform
        if kernel == "linux": file_system = "ext4"
        elif kernel == "darwin": file_system = "APFS"
        else: file_system = "NTFS"  
        translation_table = filesystemverify(file_system)
        if filename is None: filename = self.defaultfilename.translate(translation_table)
        if filename: filename = filename.translate(translation_table)
        file_path = self.getfilepath(filename=filename, output_path=output_path, filename_prefix=filename_prefix, file_system=file_system)
        if skip_existing and self.existsatpath(file_path):
            self.oncomplete(file_path)
            return file_path
        bytes_remaining = self.filesize
        def _writechunk(chunk_, bytes_remaining_): self.onprogress(chunk_, fh, bytes_remaining_)
        with open(file_path, "wb") as fh:
            try:
                if not self.issabr:
                    for chunk in RequestWrapper.stream(self.url, timeout=timeout, max_retries=max_retries):
                        if interrupt_checker is not None and interrupt_checker() == True: return
                        bytes_remaining -= len(chunk)
                        _writechunk(chunk, bytes_remaining)
                else:
                    ServerAbrStream(stream=self, write_chunk=_writechunk, monostate=self._monostate).start()
            except HTTPError as e:
                if e.code != 404: raise
            except StopIteration:
                if not self.issabr:
                    for chunk in RequestWrapper.seqstream(self.url, timeout=timeout, max_retries=max_retries):
                        if interrupt_checker is not None and interrupt_checker() == True: return
                        bytes_remaining -= len(chunk)
                        _writechunk(chunk, bytes_remaining)
                else:
                    ServerAbrStream(stream=self, write_chunk=_writechunk, monostate=self._monostate).start()
            self.oncomplete(file_path)
            return file_path
    '''getfilepath'''
    def getfilepath(self, filename: Optional[str] = None, output_path: Optional[str] = None, filename_prefix: Optional[str] = None, file_system: str = 'NTFS'):
        if not filename:
            translation_table = filesystemverify(file_system)
            filename = self.defaultfilename.translate(translation_table)
        if filename:
            translation_table = filesystemverify(file_system)
            if not ('audio' in self.mime_type and 'video' not in self.mime_type): filename = filename.translate(translation_table)
            else: filename = filename.translate(translation_table)
        if filename_prefix: filename = f"{filename_prefix}{filename}"
        return str(Path(targetdirectory(output_path)) / filename)
    '''existsatpath'''
    def existsatpath(self, file_path: str):
        return (os.path.isfile(file_path) and os.path.getsize(file_path) == self.filesize)
    '''streamtobuffer'''
    def streamtobuffer(self, buffer: BinaryIO):
        bytes_remaining = self.filesize
        for chunk in RequestWrapper.stream(self.url):
            bytes_remaining -= len(chunk)
            self.onprogress(chunk, buffer, bytes_remaining)
        self.oncomplete(None)
    '''onprogress'''
    def onprogress(self, chunk: bytes, file_handler: BinaryIO, bytes_remaining: int):
        file_handler.write(chunk)
        if self._monostate.on_progress: self._monostate.on_progress(self, chunk, bytes_remaining)
    '''oncomplete'''
    def oncomplete(self, file_path: Optional[str]):
        on_complete = self._monostate.on_complete
        if on_complete: on_complete(self, file_path)
    '''onprogressforchunks'''
    def onprogressforchunks(self, chunk: bytes, bytes_remaining: int):
        if self._monostate.on_progress: self._monostate.on_progress(self, chunk, bytes_remaining)
    '''iterchunks'''
    def iterchunks(self, chunk_size: Optional[int] = None):
        bytes_remaining = self.filesize
        if chunk_size: RequestWrapper.default_range_size = chunk_size
        try:
            stream = RequestWrapper.stream(self.url)
        except HTTPError as e:
            if e.code != 404: raise
            stream = RequestWrapper.seqstream(self.url)
        for chunk in stream:
            bytes_remaining -= len(chunk)
            self.onprogressforchunks(chunk, bytes_remaining)
            yield chunk
        self.oncomplete(None)


'''BinaryWriter'''
class BinaryWriter:
    def __init__(self, encode_utf8: Callable[[str], bytes] = lambda s: s.encode('utf-8')):
        self.encode_utf8 = encode_utf8
        self.stack = []
        self.chunks = []
        self.buf = bytearray()
    '''finish'''
    def finish(self):
        if self.buf:
            self.chunks.append(bytes(self.buf))
            self.buf.clear()
        return b''.join(self.chunks)
    '''fork'''
    def fork(self):
        self.stack.append((self.chunks, self.buf))
        self.chunks = []
        self.buf = bytearray()
        return self
    '''join'''
    def join(self):
        chunk = self.finish()
        if not self.stack: raise RuntimeError("Invalid state, fork stack empty")
        self.chunks, self.buf = self.stack.pop()
        self.uint32(len(chunk))
        return self.raw(chunk)
    '''tag'''
    def tag(self, field_no: int, wire_type: int):
        return self.uint32((field_no << 3) | wire_type)
    '''raw'''
    def raw(self, chunk: bytes):
        if self.buf:
            self.chunks.append(bytes(self.buf))
            self.buf.clear()
        self.chunks.append(chunk)
        return self
    '''uint32'''
    def uint32(self, value: int):
        assertuint32(value)
        varint32write(value, self.buf)
        return self
    '''int32'''
    def int32(self, value: int):
        assertint32(value)
        varint32write(value & 0xFFFFFFFF, self.buf)
        return self
    '''bool'''
    def bool(self, value: bool):
        self.buf.append(1 if value else 0)
        return self
    '''bytes'''
    def bytes(self, value: bytes):
        self.uint32(len(value))
        return self.raw(value)
    '''string'''
    def string(self, value: str):
        encoded = self.encode_utf8(value)
        self.uint32(len(encoded))
        return self.raw(encoded)
    '''float'''
    def float(self, value: float):
        self.raw(struct.pack('<f', value))
        return self
    '''double'''
    def double(self, value: float):
        self.raw(struct.pack('<d', value))
        return self
    '''fixed32'''
    def fixed32(self, value: int):
        assertuint32(value)
        self.raw(struct.pack('<I', value))
        return self
    '''sfixed32'''
    def sfixed32(self, value: int):
        assertint32(value)
        self.raw(struct.pack('<i', value))
        return self
    '''sint32'''
    def sint32(self, value: int):
        assertint32(value)
        encoded = (value << 1) ^ (value >> 31)
        varint32write(encoded, self.buf)
        return self
    '''sfixed64'''
    def sfixed64(self, value: int):
        tc = ProtoInt64.enc(value)
        self.raw(struct.pack('<ii', tc['lo'], tc['hi']))
        return self
    '''fixed64'''
    def fixed64(self, value: int):
        tc = ProtoInt64.uenc(value)
        self.raw(struct.pack('<II', tc['lo'], tc['hi']))
        return self
    '''int64'''
    def int64(self, value: int):
        tc = ProtoInt64.enc(value)
        varint64write(tc['lo'], tc['hi'], self.buf)
        return self
    '''sint64'''
    def sint64(self, value: int):
        tc = ProtoInt64.enc(value)
        sign = tc['hi'] >> 31
        lo = (tc['lo'] << 1) ^ sign
        hi = ((tc['hi'] << 1) | (tc['lo'] >> 31)) ^ sign
        varint64write(lo, hi, self.buf)
        return self
    '''uint64'''
    def uint64(self, value: int):
        tc = ProtoInt64.uenc(value)
        varint64write(tc['lo'], tc['hi'], self.buf)
        return self


'''BinaryReader'''
class BinaryReader:
    def __init__(self, buf, decode_utf8: Callable[[bytes], str] = lambda b: b.decode('utf-8')):
        if isinstance(buf, list): buf = bytes(buf)
        elif isinstance(buf, bytearray): buf = bytes(buf)
        elif not isinstance(buf, bytes): raise TypeError(f"Unsupported buffer type: {type(buf)}")
        self.decode_utf8 = decode_utf8
        self.buf = buf
        self.len = len(buf)
        self.pos = 0
    '''tag'''
    def tag(self):
        tag, self.pos = readvarint32(self.buf, self.pos)
        field_no = tag >> 3
        wire_type = tag & 0x7
        if field_no <= 0 or wire_type < 0 or wire_type > 5: raise ValueError(f"Illegal tag: field no {field_no} wire type {wire_type}")
        return field_no, wire_type
    '''skip'''
    def skip(self, wire_type: int, field_no=None):
        start = self.pos
        if wire_type == 0:
            while self.buf[self.pos] & 0x80: self.pos += 1
            self.pos += 1
        elif wire_type == 1:
            self.pos += 8
        elif wire_type == 2:
            length, self.pos = readvarint32(self.buf, self.pos)
            self.pos += length
        elif wire_type == 3:
            while True:
                fn, wt = self.tag()
                if wt == 4:
                    if field_no is not None and fn != field_no: raise ValueError("Invalid end group tag")
                    break
                self.skip(wt, fn)
        elif wire_type == 5:
            self.pos += 4
        else:
            raise ValueError(f"Can't skip unknown wire type {wire_type}")
        self.assertbounds()
        return self.buf[start:self.pos]
    '''assertbounds'''
    def assertbounds(self):
        if self.pos > self.len: raise EOFError("Premature EOF")
    '''uint32'''
    def uint32(self):
        value, self.pos = readvarint32(self.buf, self.pos)
        return value
    '''int32'''
    def int32(self):
        return self.uint32() | 0
    '''sint32'''
    def sint32(self):
        value = self.uint32()
        return (value >> 1) ^ -(value & 1)
    '''varint64'''
    def varint64(self):
        lo, hi, self.pos = readvarint64(self.buf, self.pos)
        return lo, hi
    '''int64'''
    def int64(self):
        return decodeint64(*self.varint64())
    '''uint64'''
    def uint64(self):
        return decodeuint64(*self.varint64())
    '''sint64'''
    def sint64(self):
        lo, hi = self.varint64()
        sign = -(lo & 1)
        lo = ((lo >> 1) | ((hi & 1) << 31)) ^ sign
        hi = (hi >> 1) ^ sign
        return decodeint64(lo, hi)
    '''bool'''
    def bool(self):
        lo, hi = self.varint64()
        return lo != 0 or hi != 0
    '''fixed32'''
    def fixed32(self):
        value = struct.unpack_from('<I', self.buf, self.pos)[0]
        self.pos += 4
        return value
    '''sfixed32'''
    def sfixed32(self):
        value = struct.unpack_from('<i', self.buf, self.pos)[0]
        self.pos += 4
        return value
    '''fixed64'''
    def fixed64(self):
        lo = self.sfixed32()
        hi = self.sfixed32()
        return decodeuint64(lo, hi)
    '''sfixed64'''
    def sfixed64(self):
        lo = self.sfixed32()
        hi = self.sfixed32()
        return decodeint64(lo, hi)
    '''float'''
    def float(self):
        value = struct.unpack_from('<f', self.buf, self.pos)[0]
        self.pos += 4
        return value
    '''double'''
    def double(self):
        value = struct.unpack_from('<d', self.buf, self.pos)[0]
        self.pos += 8
        return value
    '''bytes'''
    def bytes(self):
        length = self.uint32()
        start = self.pos
        self.pos += length
        self.assertbounds()
        return self.buf[start:self.pos]
    '''string'''
    def string(self):
        return self.decode_utf8(self.bytes())


'''ClientAbrState'''
class ClientAbrState:
    '''createbaseclientabrstate'''
    @staticmethod
    def createbaseclientabrstate():
        return {
            "timeSinceLastManualFormatSelectionMs": 0, "lastManualDirection": 0, "lastManualSelectedResolution": 0, "detailedNetworkType": 0, "clientViewportWidth": 0,
            "clientViewportHeight": 0, "clientBitrateCapBytesPerSec": 0, "stickyResolution": 0, "clientViewportIsFlexible": False, "bandwidthEstimate": 0, "minAudioQuality": 0,
            "maxAudioQuality": 0, "videoQualitySetting": 0, "audioRoute": 0, "playerTimeMs": 0, "timeSinceLastSeek": 0, "dataSaverMode": False, "networkMeteredState": 0,
            "visibility": 0, "playbackRate": 0, "elapsedWallTimeMs": 0, "mediaCapabilities": bytearray(), "timeSinceLastActionMs": 0, "enabledTrackTypesBitfield": 0,
            "maxPacingRate": 0, "playerState": 0, "drcEnabled": False, "Jda": 0, "qw": 0, "Ky": 0, "sabrReportRequestCancellationInfo": 0, "l": False, "G7": 0, "preferVp9": False,
            "qj": 0, "Hx": 0, "isPrefetch": False, "sabrSupportQualityConstraints": 0, "sabrLicenseConstraint": bytearray(), "allowProximaLiveLatency": 0, "sabrForceProxima": 0,
            "Tqb": 0, "sabrForceMaxNetworkInterruptionDurationMs": 0, "audioTrackId": ""
        }
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("timeSinceLastManualFormatSelectionMs", 0):
            writer.uint32(104).int64(message["timeSinceLastManualFormatSelectionMs"])
        if message.get("lastManualDirection", 0):
            writer.uint32(112).sint32(message["lastManualDirection"])
        if message.get("lastManualSelectedResolution", 0):
            writer.uint32(128).int32(message["lastManualSelectedResolution"])
        if message.get("detailedNetworkType", 0):
            writer.uint32(136).int32(message["detailedNetworkType"])
        if message.get("clientViewportWidth", 0):
            writer.uint32(144).int32(message["clientViewportWidth"])
        if message.get("clientViewportHeight", 0):
            writer.uint32(152).int32(message["clientViewportHeight"])
        if message.get("clientBitrateCapBytesPerSec", 0):
            writer.uint32(160).int64(message["clientBitrateCapBytesPerSec"])
        if message.get("stickyResolution", 0):
            writer.uint32(168).int32(message["stickyResolution"])
        if message.get("clientViewportIsFlexible", False):
            writer.uint32(176).bool(message["clientViewportIsFlexible"])
        if message.get("bandwidthEstimate", 0):
            writer.uint32(184).int64(message["bandwidthEstimate"])
        if message.get("minAudioQuality", 0):
            writer.uint32(192).int32(message["minAudioQuality"])
        if message.get("maxAudioQuality", 0):
            writer.uint32(200).int32(message["maxAudioQuality"])
        if message.get("videoQualitySetting", 0):
            writer.uint32(208).int32(message["videoQualitySetting"])
        if message.get("audioRoute", 0):
            writer.uint32(216).int32(message["audioRoute"])
        if message.get("playerTimeMs", 0):
            writer.uint32(224).int64(message["playerTimeMs"])
        if message.get("timeSinceLastSeek", 0):
            writer.uint32(232).int64(message["timeSinceLastSeek"])
        if message.get("dataSaverMode", False):
            writer.uint32(240).bool(message["dataSaverMode"])
        if message.get("networkMeteredState", 0):
            writer.uint32(256).int32(message["networkMeteredState"])
        if message.get("visibility", 0):
            writer.uint32(272).int32(message["visibility"])
        if message.get("playbackRate", 0):
            writer.uint32(285).float(message["playbackRate"])
        if message.get("elapsedWallTimeMs", 0):
            writer.uint32(288).int64(message["elapsedWallTimeMs"])
        if message.get("mediaCapabilities", b''):
            writer.uint32(306).bytes(message["mediaCapabilities"])
        if message.get("timeSinceLastActionMs", 0):
            writer.uint32(312).int64(message["timeSinceLastActionMs"])
        if message.get("enabledTrackTypesBitfield", 0):
            writer.uint32(320).int32(message["enabledTrackTypesBitfield"])
        if message.get("maxPacingRate", 0):
            writer.uint32(344).int32(message["maxPacingRate"])
        if message.get("playerState", 0):
            writer.uint32(352).int64(message["playerState"])
        if message.get("drcEnabled", False):
            writer.uint32(368).bool(message["drcEnabled"])
        if message.get("Jda", 0):
            writer.uint32(384).int32(message["Jda"])
        if message.get("qw", 0):
            writer.uint32(400).int32(message["qw"])
        if message.get("Ky", 0):
            writer.uint32(408).int32(message["Ky"])
        if message.get("sabrReportRequestCancellationInfo", 0):
            writer.uint32(432).int32(message["sabrReportRequestCancellationInfo"])
        if message.get("l", False):
            writer.uint32(448).bool(message["l"])
        if message.get("G7", 0):
            writer.uint32(456).int64(message["G7"])
        if message.get("preferVp9", False):
            writer.uint32(464).bool(message["preferVp9"])
        if message.get("qj", 0):
            writer.uint32(472).int32(message["qj"])
        if message.get("Hx", 0):
            writer.uint32(480).int32(message["Hx"])
        if message.get("isPrefetch", False):
            writer.uint32(488).bool(message["isPrefetch"])
        if message.get("sabrSupportQualityConstraints", 0):
            writer.uint32(496).int32(message["sabrSupportQualityConstraints"])
        if message.get("sabrLicenseConstraint", b''):
            writer.uint32(506).bytes(message["sabrLicenseConstraint"])
        if message.get("allowProximaLiveLatency", 0):
            writer.uint32(512).int32(message["allowProximaLiveLatency"])
        if message.get("sabrForceProxima", 0):
            writer.uint32(528).int32(message["sabrForceProxima"])
        if message.get("Tqb", 0):
            writer.uint32(536).int32(message["Tqb"])
        if message.get("sabrForceMaxNetworkInterruptionDurationMs", 0):
            writer.uint32(544).int64(message["sabrForceMaxNetworkInterruptionDurationMs"])
        if message.get("audioTrackId", ""):
            writer.uint32(554).string(message["audioTrackId"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = ClientAbrState.createbaseclientabrstate()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 13 and tag == 104:
                message['timeSinceLastManualFormatSelectionMs'] = longtonumber(reader.int64())
                continue
            elif field_number == 14 and tag == 112:
                message['lastManualDirection'] = reader.sint32()
                continue
            elif field_number == 16 and tag == 128:
                message['lastManualSelectedResolution'] = reader.int32()
                continue
            elif field_number == 17 and tag == 136:
                message['detailedNetworkType'] = reader.int32()
                continue
            elif field_number == 18 and tag == 144:
                message['clientViewportWidth'] = reader.int32()
                continue
            elif field_number == 19 and tag == 152:
                message['clientViewportHeight'] = reader.int32()
                continue
            elif field_number == 20 and tag == 160:
                message['clientBitrateCapBytesPerSec'] = longtonumber(reader.int64())
                continue
            elif field_number == 21 and tag == 168:
                message['stickyResolution'] = reader.int32()
                continue
            elif field_number == 22 and tag == 176:
                message['clientViewportIsFlexible'] = reader.bool()
                continue
            elif field_number == 23 and tag == 184:
                message['bandwidthEstimate'] = longtonumber(reader.int64())
                continue
            elif field_number == 24 and tag == 192:
                message['minAudioQuality'] = reader.int32()
                continue
            elif field_number == 25 and tag == 200:
                message['maxAudioQuality'] = reader.int32()
                continue
            elif field_number == 26 and tag == 208:
                message['videoQualitySetting'] = reader.int32()
                continue
            elif field_number == 27 and tag == 216:
                message['audioRoute'] = reader.int32()
                continue
            elif field_number == 28 and tag == 224:
                message['playerTimeMs'] = longtonumber(reader.int64())
                continue
            elif field_number == 29 and tag == 232:
                message['timeSinceLastSeek'] = longtonumber(reader.int64())
                continue
            elif field_number == 30 and tag == 240:
                message['dataSaverMode'] = reader.bool()
                continue
            elif field_number == 32 and tag == 256:
                message['networkMeteredState'] = reader.int32()
                continue
            elif field_number == 34 and tag == 272:
                message['visibility'] = reader.int32()
                continue
            elif field_number == 35 and tag == 285:
                message['playbackRate'] = reader.float()
                continue
            elif field_number == 36 and tag == 288:
                message['elapsedWallTimeMs'] = longtonumber(reader.int64())
                continue
            elif field_number == 38 and tag == 306:
                message['mediaCapabilities'] = reader.bytes()
                continue
            elif field_number == 39 and tag == 312:
                message['timeSinceLastActionMs'] = longtonumber(reader.int64())
                continue
            elif field_number == 40 and tag == 320:
                message['enabledTrackTypesBitfield'] = reader.int32()
                continue
            elif field_number == 43 and tag == 344:
                message['maxPacingRate'] = reader.int32()
                continue
            elif field_number == 44 and tag == 352:
                message['playerState'] = longtonumber(reader.int64())
                continue
            elif field_number == 46 and tag == 368:
                message['drcEnabled'] = reader.bool()
                continue
            elif field_number == 48 and tag == 384:
                message['Jda'] = reader.int32()
                continue
            elif field_number == 50 and tag == 400:
                message['qw'] = reader.int32()
                continue
            elif field_number == 51 and tag == 408:
                message['Ky'] = reader.int32()
                continue
            elif field_number == 54 and tag == 432:
                message['sabrReportRequestCancellationInfo'] = reader.int32()
                continue
            elif field_number == 56 and tag == 448:
                message['l'] = reader.bool()
                continue
            elif field_number == 57 and tag == 456:
                message['G7'] = longtonumber(reader.int64())
                continue
            elif field_number == 58 and tag == 464:
                message['preferVp9'] = reader.bool()
                continue
            elif field_number == 59 and tag == 472:
                message['qj'] = reader.int32()
                continue
            elif field_number == 60 and tag == 480:
                message['Hx'] = reader.int32()
                continue
            elif field_number == 61 and tag == 488:
                message['isPrefetch'] = reader.bool()
                continue
            elif field_number == 62 and tag == 496:
                message['sabrSupportQualityConstraints'] = reader.int32()
                continue
            elif field_number == 63 and tag == 506:
                message['sabrLicenseConstraint'] = reader.bytes()
                continue
            elif field_number == 64 and tag == 512:
                message['allowProximaLiveLatency'] = reader.int32()
                continue
            elif field_number == 66 and tag == 528:
                message['sabrForceProxima'] = reader.int32()
                continue
            elif field_number == 67 and tag == 536:
                message['Tqb'] = reader.int32()
                continue
            elif field_number == 68 and tag == 544:
                message['sabrForceMaxNetworkInterruptionDurationMs'] = longtonumber(reader.int64())
                continue
            elif field_number == 69 and tag == 554:
                message['audioTrackId'] = reader.string()
                continue
            else:
                if (tag & 7) == 4 or tag == 0: break
                reader.skip(tag & 7)
        return message


'''FormatId'''
class FormatId:
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("itag", 0) != 0: writer.uint32(8).int32(message["itag"])
        if message.get("lastModified", 0) != 0: writer.uint32(16).uint64(message["lastModified"])
        if message.get("xtags", None) is not None: writer.uint32(26).string(message["xtags"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = {"itag": 0, "lastModified": 0, "xtags": None}
        while reader.pos < end:
            tag = reader.uint32()
            field_no = tag >> 3
            if field_no == 1 and tag == 8: message["itag"] = reader.int32(); continue
            elif field_no == 2 and tag == 16: message["lastModified"] = reader.uint64(); continue
            elif field_no == 3 and tag == 26: message["xtags"] = reader.string(); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message


'''InitRange'''
class InitRange:
    def __init__(self, start=0, end=0):
        self.start = start
        self.end = end
    '''encode'''
    @staticmethod
    def encode(message, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.start != 0:
            writer.uint32(8)
            writer.int32(message.start)
        if message.end != 0:
            writer.uint32(16)
            writer.int32(message.end)
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = InitRange()
        while reader.pos < end:
            tag = reader.uint32()
            field_no = tag >> 3
            if field_no == 1 and tag == 8: message.start = reader.int32(); continue
            elif field_no == 2 and tag == 16: message.end = reader.int32(); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message


'''IndexRange'''
class IndexRange:
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("start", 0) != 0: writer.uint32(8).int32(message["start"])
        if message.get("end", 0) != 0: writer.uint32(16).int32(message["end"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = {"start": 0, "end": 0}
        while reader.pos < end:
            tag = reader.uint32()
            field_no = tag >> 3
            if field_no == 1 and tag == 8: message["start"] = reader.int32(); continue
            elif field_no == 2 and tag == 16: message["end"] = reader.int32(); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message


'''Lo'''
class Lo:
    def __init__(self):
        self.format_id: Optional[FormatId] = None
        self.Lj: int = 0
        self.sequenceNumber: int = 0
        self.field4: Optional[LoField4] = None
        self.MZ: int = 0
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        for v in message.get("field1", []): writer.uint32(10).string(v)
        if "field2" in message and message["field2"] is not None: writer.uint32(18).int32(message["field2"])
        if "field3" in message and message["field3"] is not None: writer.uint32(26).int32(message["field3"])
        if "field4" in message and message["field4"] is not None: writer.uint32(32).int32(message["field4"])
        if "field5" in message and message["field5"] is not None: writer.uint32(40).int32(message["field5"])
        if "field6" in message and message["field6"] is not None: writer.uint32(50).int32(message["field6"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = Lo()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.format_id = FormatId.decode(reader, reader.uint32()); continue
            elif field_number == 2 and tag == 16: message.Lj = reader.int32(); continue
            elif field_number == 3 and tag == 24: message.sequenceNumber = reader.int32(); continue
            elif field_number == 4 and tag == 34: message.field4 = LoField4.decode(reader, reader.uint32()); continue
            elif field_number == 5 and tag == 40: message.MZ = reader.int32(); continue
        return message


'''LoField4'''
class LoField4:
    def __init__(self):
        self.field1: int = 0
        self.field2: int = 0
        self.field3: int = 0
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if "field1" in message and message["field1"] is not None: writer.uint32(8).int32(message["field1"])
        if "field2" in message and message["field2"] is not None: writer.uint32(16).int32(message["field2"])
        if "field3" in message and message["field3"] is not None: writer.uint32(24).int32(message["field3"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = LoField4()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 8: message.field1 = reader.int32(); continue
            elif field_number == 2 and tag == 16: message.field2 = reader.int32(); continue
            elif field_number == 3 and tag == 24: message.field3 = reader.int32(); continue
        return message


'''OQa'''
class OQa:
    def __init__(self):
        self.field1: List[str] = []
        self.field2: bytes = bytes()
        self.field3: str = ""
        self.field4: int = 0
        self.field5: int = 0
        self.field6: str = ""
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if "field1" in message and message["field1"] is not None: writer.uint32(8).int32(message["field1"])
        if "field2" in message and message["field2"] is not None: writer.uint32(16).int32(message["field2"])
        if "field3" in message and message["field3"] is not None: writer.uint32(24).int32(message["field3"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = OQa()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.field1.append(reader.string()); continue
            elif field_number == 2 and tag == 18: message.field2 = reader.bytes(); continue
            elif field_number == 3 and tag == 26: message.field3 = reader.string(); continue
            elif field_number == 4 and tag == 32: message.field4 = reader.int32(); continue
            elif field_number == 5 and tag == 40: message.field5 = reader.int32(); continue
            elif field_number == 6 and tag == 50: message.field6 = reader.string(); continue
        return message


'''KobPa'''
class KobPa:
    def __init__(self):
        self.videoId = ""
        self.lmt = 0
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        writer = writer or BinaryWriter()
        if message.get("videoId"): writer.uint32(10).string(message["videoId"])
        if message.get("lmt", 0) != 0: writer.uint32(16).uint64(message["lmt"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = KobPa()
        while reader.pos < end:
            tag = reader.uint32()
            field_num = tag >> 3
            if field_num == 1 and tag == 10: message.videoId = reader.string(); continue
            elif field_num == 2 and tag == 16: message.lmt = longtonumber(reader.uint64())
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''Kob'''
class Kob:
    def __init__(self):
        self.EW = []
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        writer = writer or BinaryWriter()
        for v in message.get("EW", []): KobPa.encode(v, writer.uint32(10).fork()).join()
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = Kob()
        while reader.pos < end:
            tag = reader.uint32()
            field_num = tag >> 3
            if field_num == 1 and tag == 10: message.EW.append(KobPa.decode(reader, reader.uint32())); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''YPa'''
class YPa:
    def __init__(self):
        self.field1 = 0
        self.field2 = 0
        self.field3 = 0
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        writer = writer or BinaryWriter()
        if message.get("field1", 0) != 0: writer.uint32(8).int32(message["field1"])
        if message.get("field2", 0) != 0: writer.uint32(16).int32(message["field2"])
        if message.get("field3", 0) != 0: writer.uint32(24).int32(message["field3"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = YPa()
        while reader.pos < end:
            tag = reader.uint32()
            field_num = tag >> 3
            if field_num == 1 and tag == 8: message.field1 = reader.int32(); continue
            elif field_num == 2 and tag == 16: message.field2 = reader.int32(); continue
            elif field_num == 3 and tag == 24: message.field3 = reader.int32(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''TimeRange'''
class TimeRange:
    def __init__(self):
        self.start: int = 0
        self.duration: int = 0
        self.timescale: int = 0
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = TimeRange
        while reader.pos < end:
            tag = reader.uint32()
            field = tag >> 3
            if field == 1 and tag == 8: message.start = longtonumber(reader.int64()); continue
            elif field == 2 and tag == 16: message.duration = longtonumber(reader.int64()); continue
            elif field == 3 and tag == 24: message.timescale = reader.int32(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message
    '''encode'''
    def encode(self, writer: Optional[BinaryWriter] = None):
        writer = writer or BinaryWriter()
        if self.start != 0: writer.uint32(8).int64(self.start)
        if self.duration != 0: writer.uint32(16).int64(self.duration)
        if self.timescale != 0: writer.uint32(24).int32(self.timescale)
        return writer


'''BufferedRange'''
class BufferedRange:
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        writer = writer or BinaryWriter()
        if message.get("formatId") is not None: FormatId.encode(message["formatId"], writer.uint32(10).fork()).join()
        if message.get("startTimeMs", 0) != 0: writer.uint32(16).int64(message["startTimeMs"])
        if message.get("durationMs", 0) != 0: writer.uint32(24).int64(message["durationMs"])
        if message.get("startSegmentIndex", 0) != 0: writer.uint32(32).int32(message["startSegmentIndex"])
        if message.get("endSegmentIndex", 0) != 0: writer.uint32(40).int32(message["endSegmentIndex"])
        if message.get("timeRange") is not None: TimeRange.encode(message["timeRange"], writer.uint32(50).fork()).join()
        if message.get("field9") is not None: Kob.encode(message["field9"], writer.uint32(74).fork()).join()
        if message.get("field11") is not None: YPa.encode(message["field11"], writer.uint32(90).fork()).join()
        if message.get("field12") is not None: YPa.encode(message["field12"], writer.uint32(98).fork()).join()
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = {"formatId": None, "startTimeMs": 0, "durationMs": 0, "startSegmentIndex": 0, "endSegmentIndex": 0, "timeRange": None, "field9": None, "field11": None, "field12": None}
        while reader.pos < end:
            tag = reader.uint32()
            field_num = tag >> 3
            if field_num == 1 and tag == 10: message["formatId"] = FormatId.decode(reader, reader.uint32()); continue
            elif field_num == 2 and tag == 16: message["startTimeMs"] = longtonumber(reader.int64()); continue
            elif field_num == 3 and tag == 24: message["durationMs"] = longtonumber(reader.int64()); continue
            elif field_num == 4 and tag == 32: message["startSegmentIndex"] = reader.int32(); continue
            elif field_num == 5 and tag == 40: message["endSegmentIndex"] = reader.int32(); continue
            elif field_num == 6 and tag == 50: message["timeRange"] = TimeRange.decode(reader, reader.uint32()); continue
            elif field_num == 9 and tag == 74: message["field9"] = Kob.decode(reader, reader.uint32()); continue
            elif field_num == 11 and tag == 90: message["field11"] = YPa.decode(reader, reader.uint32()); continue
            elif field_num == 12 and tag == 98: message["field12"] = YPa.decode(reader, reader.uint32()); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''Pqa'''
class Pqa:
    def __init__(self):
        self.formats: List[FormatId] = []
        self.ud: List[BufferedRange] = []
        self.clip_id: str = ""
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        for v in message.get("formats", []): FormatId.encode(v, writer.uint32(10).fork()).join()
        for v in message.get("ud", []): BufferedRange.encode(v, writer.uint32(18).fork()).join()
        if "clipId" in message and message["clipId"] is not None: writer.uint32(26).int32(message["clipId"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        message = Pqa()
        end = reader.len if length is None else reader.pos + length
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.formats.append(FormatId.decode(reader, reader.uint32())); continue
            elif field_number == 2 and tag == 18: message.ud.append(BufferedRange.decode(reader, reader.uint32())); continue
            elif field_number == 3 and tag == 26: message.clip_id = reader.string(); continue
        return message


'''PlaybackCookie'''
class PlaybackCookie:
    '''createbase'''
    @staticmethod
    def createbase():
        return {"field1": 0, "field2": 0, "videoFmt": None, "audioFmt": None}
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("field1", 0) != 0: writer.uint32(8).int32(message["field1"])
        if message.get("field2", 0) != 0: writer.uint32(16).int32(message["field2"])
        if message.get("videoFmt") is not None: FormatId.encode(message["videoFmt"], writer.uint32(58).fork()).join()
        if message.get("audioFmt") is not None: FormatId.encode(message["audioFmt"], writer.uint32(66).fork()).join()
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = PlaybackCookie.createbase()
        while reader.pos < end:
            tag = reader.uint32()
            field = tag >> 3
            if field == 1 and tag == 8: message["field1"] = reader.int32(); continue
            elif field == 2 and tag == 16: message["field2"] = reader.int32(); continue
            elif field == 7 and tag == 58: message["videoFmt"] = FormatId.decode(reader, reader.uint32()); continue
            elif field == 8 and tag == 66: message["audioFmt"] = FormatId.decode(reader, reader.uint32()); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''StreamerContextClientInfo'''
class StreamerContextClientInfo:
    def __init__(self):
        self.locale = None
        self.deviceMake = None
        self.deviceModel = None
        self.clientName = None
        self.clientVersion = None
        self.osName = None
        self.osVersion = None
        self.acceptLanguage = None
        self.acceptRegion = None
        self.screenWidthPoints = None
        self.screenHeightPoints = None
        self.screenWidthInches = None
        self.screenHeightInches = None
        self.screenPixelDensity = None
        self.clientFormFactor = None
        self.gmscoreVersionCode = None
        self.windowWidthPoints = None
        self.windowHeightPoints = None
        self.androidSdkVersion = None
        self.screenDensityFloat = None
        self.utcOffsetMinutes = None
        self.timeZone = None
        self.chipset = None
        self.glDeviceInfo = None
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("deviceMake", ""): writer.uint32(98).string(message["deviceMake"])
        if message.get("deviceModel", ""): writer.uint32(106).string(message["deviceModel"])
        if message.get("clientName", 0): writer.uint32(128).int32(message["clientName"])
        if message.get("clientVersion", ""): writer.uint32(138).string(message["clientVersion"])
        if message.get("osName", ""): writer.uint32(146).string(message["osName"])
        if message.get("osVersion", ""): writer.uint32(154).string(message["osVersion"])
        if message.get("acceptLanguage", ""): writer.uint32(170).string(message["acceptLanguage"])
        if message.get("acceptRegion", ""): writer.uint32(178).string(message["acceptRegion"])
        if message.get("screenWidthPoints", 0): writer.uint32(296).int32(message["screenWidthPoints"])
        if message.get("screenHeightPoints", 0): writer.uint32(304).int32(message["screenHeightPoints"])
        if message.get("screenWidthInches", 0): writer.uint32(317).float(message["screenWidthInches"])
        if message.get("screenHeightInches", 0): writer.uint32(325).float(message["screenHeightInches"])
        if message.get("screenPixelDensity", 0): writer.uint32(328).int32(message["screenPixelDensity"])
        if message.get("clientFormFactor", 0): writer.uint32(368).int32(message["clientFormFactor"])
        if message.get("gmscoreVersionCode", 0): writer.uint32(400).int32(message["gmscoreVersionCode"])
        if message.get("windowWidthPoints", 0): writer.uint32(440).int32(message["windowWidthPoints"])
        if message.get("windowHeightPoints", 0): writer.uint32(448).int32(message["windowHeightPoints"])
        if message.get("androidSdkVersion", 0): writer.uint32(512).int32(message["androidSdkVersion"])
        if message.get("screenDensityFloat", 0): writer.uint32(525).float(message["screenDensityFloat"])
        if message.get("utcOffsetMinutes", 0): writer.uint32(536).int64(message["utcOffsetMinutes"])
        if message.get("timeZone", ""): writer.uint32(642).string(message["timeZone"])
        if message.get("chipset", ""): writer.uint32(738).string(message["chipset"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = StreamerContextClientInfo()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.locale = reader.string(); continue
            if field_number == 12 and tag == 98: message.deviceMake = reader.string(); continue
            elif field_number == 13 and tag == 106: message.deviceModel = reader.string(); continue
            elif field_number == 16 and tag == 128: message.clientName = reader.int32(); continue
            elif field_number == 17 and tag == 138: message.clientVersion = reader.string(); continue
            elif field_number == 18 and tag == 146: message.osName = reader.string(); continue
            elif field_number == 19 and tag == 154: message.osVersion = reader.string(); continue
            elif field_number == 21 and tag == 170: message.acceptLanguage = reader.string(); continue
            elif field_number == 22 and tag == 178: message.acceptRegion = reader.string(); continue
            elif field_number == 37 and tag == 296: message.screenWidthPoints = reader.int32(); continue
            elif field_number == 38 and tag == 304: message.screenHeightPoints = reader.int32(); continue
            elif field_number == 39 and tag == 317: message.screenWidthInches = reader.float(); continue
            elif field_number == 40 and tag == 325: message.screenHeightInches = reader.float(); continue
            elif field_number == 41 and tag == 328: message.screenPixelDensity = reader.int32(); continue
            elif field_number == 46 and tag == 368: message.clientFormFactor = reader.int32(); continue
            elif field_number == 50 and tag == 400: message.gmscoreVersionCode = reader.int32(); continue
            elif field_number == 55 and tag == 440: message.windowWidthPoints = reader.int32(); continue
            elif field_number == 56 and tag == 448: message.windowHeightPoints = reader.int32(); continue
            elif field_number == 64 and tag == 512: message.androidSdkVersion = reader.int32(); continue
            elif field_number == 65 and tag == 525: message.screenDensityFloat = reader.float(); continue
            elif field_number == 67 and tag == 536: message.utcOffsetMinutes = longtonumber(reader.int64()); continue
            elif field_number == 80 and tag == 642: message.timeZone = reader.string(); continue
            elif field_number == 92 and tag == 738: message.chipset = reader.string(); continue
            elif field_number == 102 and tag == 818: message.glDeviceInfo = StreamerContextGLDeviceInfo.decode(reader, reader.uint32())
            else:
                if (tag & 7) == 4 or tag == 0: break
                reader.skip(tag & 7)
        return message


'''StreamerContextGLDeviceInfo'''
class StreamerContextGLDeviceInfo:
    def __init__(self):
        self.glRenderer = ""
        self.glEsVersionMajor = 0
        self.glEsVersionMinor = 0
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("glRenderer", ""): writer.uint32(10).string(message["glRenderer"])
        if message.get("glEsVersionMajor", ""): writer.uint32(16).int32(message["glEsVersionMajor"])
        if message.get("glEsVersionMinor", ""): writer.uint32(24).int32(message["glEsVersionMinor"])
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = StreamerContextGLDeviceInfo()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.glRenderer = reader.string(); continue
            elif field_number == 2 and tag == 16: message.glEsVersionMajor = reader.int32(); continue
            elif field_number == 3 and tag == 24: message.glEsVersionMinor = reader.int32(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''StreamerContextUpdate'''
class StreamerContextUpdate:
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("type", 0): writer.uint32(8).int32(message["type"])
        if message.get("value", 0): StreamerContextUpdateValue.encode(message["value"], writer.uint32(18).fork()).join()
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = dict()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 8: message["type"] = reader.int32(); continue
            elif field_number == 2 and tag == 16: message["scope"] = reader.int32(); continue
            elif field_number == 3 and tag == 26: message["value"] = StreamerContextUpdateValue.decode(reader, reader.uint32()); continue
            elif field_number == 4 and tag == 32: message["sendByDefault"] = reader.bool(); continue
            elif field_number == 5 and tag == 40: message["writePolicy"] = reader.int32(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message
    '''SabrContextWritePolicy'''
    class SabrContextWritePolicy(Enum):
        SABR_CONTEXT_WRITE_POLICY_UNSPECIFIED = 0
        SABR_CONTEXT_WRITE_POLICY_OVERWRITE = 1
        SABR_CONTEXT_WRITE_POLICY_KEEP_EXISTING = 2


''''StreamerContextUpdateValue'''
class StreamerContextUpdateValue:
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("field1", 0): StreamerContextUpdateField1.encode(message["field1"], writer.uint32(10).fork()).join()
        if message.get("field2", 0): writer.uint32(18).bytes(message["field2"])
        if message.get("field3", 0): writer.uint32(40).int32(message["field3"])
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = dict()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message["field1"] = StreamerContextUpdateField1.decode(reader, reader.uint32()); continue
            elif field_number == 2 and tag == 18: message["field2"] = reader.bytes(); continue
            elif field_number == 5 and tag == 40: message["field3"] = reader.int32(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''StreamerContextUpdateField1'''
class StreamerContextUpdateField1:
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("timestamp", 0): writer.uint32(8).int64(message["timestamp"])
        if message.get("skip", 0): writer.uint32(16).int32(message["skip"])
        if message.get("fiedl3", 0): writer.uint32(26).bytes(message["fiedl3"])
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = dict()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 8: message["timestamp"] = reader.int64(); continue
            elif field_number == 2 and tag == 16: message["skip"] = reader.int32(); continue
            elif field_number == 3 and tag == 26: message["fiedl3"] = reader.bytes(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''StreamerContextGqa'''
class StreamerContextGqa:
    def __init__(self):
        self.field1 = None
        self.field2 = None
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("field1", 0): writer.uint32(10).bytes(message["field1"])
        if message.get("field2", 0): StreamerContextGqaHqa.encode(message["field2"], writer.uint32(18).fork()).join()
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = StreamerContextGqa()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.field1 = reader.bytes(); continue
            elif field_number == 2 and tag == 18: message.field2 = StreamerContextGqaHqa.decode(reader, reader.uint32()); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''StreamerContextGqaHqa'''
class StreamerContextGqaHqa:
    def __init__(self):
        self.code = 0
        self.message = ""
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("code", 0): writer.uint32(8).int32(message["code"])
        if message.get("message", ""): writer.uint32(18).string(message["message"])
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = StreamerContextGqaHqa()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 8: message.code = reader.int32(); continue
            elif field_number == 2 and tag == 18: message.message = reader.string(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''StreamerContext'''
class StreamerContext:
    def __init__(self):
        self.clientInfo = None
        self.poToken = None
        self.playbackCookie = None
        self.gp = None
        self.sabrContexts = []
        self.field6 = []
        self.field6 = ""
        self.field6 = []
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("clientInfo") is not None: StreamerContextClientInfo.encode(message["clientInfo"], writer.uint32(10).fork()).join()
        if message.get("poToken"): writer.uint32(18).bytes(message["poToken"])
        if message.get("playbackCookie"): writer.uint32(26).bytes(message["playbackCookie"])
        if message.get("gp"): writer.uint32(34).bytes(message["gp"])
        for v in message.get("sabrContexts", []): StreamerContextUpdate.encode(v, writer.uint32(42).fork()).join()
        writer.uint32(50).fork()
        for v in message.get("field6", []): writer.int32(v)
        writer.join()
        if message.get("field7", "") != "": writer.uint32(58).string(message["field7"])
        if message.get("field8") is not None: StreamerContextGqa.encode(message["field8"], writer.uint32(66).fork()).join()
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = StreamerContext()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10:
                message.clientInfo = StreamerContextClientInfo.decode(reader, reader.uint32())
                continue
            if field_number == 2 and tag == 18:
                message.poToken = reader.bytes()
                continue
            if field_number == 3 and tag == 26:
                message.playbackCookie = PlaybackCookie.decode(reader, reader.uint32())
                continue
            if field_number == 4 and tag == 34:
                message.gp = reader.bytes()
                continue
            if field_number == 5 and tag == 42:
                message.sabrContexts.append(StreamerContextUpdate.decode(reader, reader.uint32()))
                continue
            if field_number == 6 and tag == 48:
                message.field6.append(reader.int32())
                continue
            if field_number == 6 and tag == 50:
                end2 = reader.uint32() + reader.pos
                while (reader.pos < end2): message.field6.append(reader.int32())
                continue
            if field_number == 7 and tag == 58: message.field7 = reader.string(); continue
            if field_number == 8 and tag == 66: message.field5.append(StreamerContextGqa.decode(reader, reader.uint32())); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message


'''VideoPlaybackAbrRequest'''
class VideoPlaybackAbrRequest:
    def __init__(self):
        self.client_abr_state = None
        self.selected_format_ids = []
        self.buffered_ranges = []
        self.player_time_ms: int = 0
        self.video_playback_ustreamer_config: bytes = bytes()
        self.lo = None
        self.lj = None
        self.selected_audio_format_ids = []
        self.selected_video_format_ids = []
        self.streamer_context = None
        self.field1 = None
        self.field2 = None
        self.field3 = None
        self.field21 = None
        self.field22: int = 0
        self.field23: int = 0
        self.field1000 = []
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if "clientAbrState" in message and message["clientAbrState"] is not None:
            writer.uint32(10)
            ClientAbrState.encode(message["clientAbrState"], writer.fork())
            writer.join()
        for v in message.get("selectedFormatIds", []):
            writer.uint32(18)
            FormatId.encode(v, writer.fork())
            writer.join()
        for v in message.get("bufferedRanges", []):
            writer.uint32(26)
            BufferedRange.encode(v, writer.fork())
            writer.join()
        if message.get("playerTimeMs", 0):
            writer.uint32(32).int64(message["playerTimeMs"])
        if message.get("videoPlaybackUstreamerConfig", b''):
            writer.uint32(42).bytes(message["videoPlaybackUstreamerConfig"])
        if "lo" in message and message["lo"] is not None:
            writer.uint32(50)
            Lo.encode(message["lo"], writer.fork())
            writer.join()
        for v in message.get("selectedAudioFormatIds", []):
            writer.uint32(130)
            FormatId.encode(v, writer.fork())
            writer.join()
        for v in message.get("selectedVideoFormatIds", []):
            writer.uint32(138)
            FormatId.encode(v, writer.fork())
            writer.join()
        if "streamerContext" in message and message["streamerContext"] is not None:
            writer.uint32(154)
            StreamerContext.encode(message["streamerContext"], writer.fork())
            writer.join()
        if "field21" in message and message["field21"] is not None:
            writer.uint32(170)
            OQa.encode(message["field21"], writer.fork())
            writer.join()
        if message.get("field22", 0):
            writer.uint32(176).int32(message["field22"])
        if message.get("field23", 0):
            writer.uint32(184).int32(message["field23"])
        for v in message.get("field1000", []):
            writer.uint32(8002)
            Pqa.encode(v, writer.fork())
            writer.join()
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = VideoPlaybackAbrRequest()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.client_abr_state = ClientAbrState.decode(reader, reader.uint32()); continue
            elif field_number == 2 and tag == 18: message.selected_format_ids.append(FormatId.decode(reader, reader.uint32())); continue
            elif field_number == 3 and tag == 26: message.buffered_ranges.append(BufferedRange.decode(reader, reader.uint32())); continue
            elif field_number == 4 and tag == 32: message.player_time_ms = longtonumber(reader.int64()); continue
            elif field_number == 5 and tag == 42: message.video_playback_ustreamer_config = reader.bytes(); continue
            elif field_number == 6 and tag == 50: message.lo = Lo.decode(reader, reader.uint32()); continue
            elif field_number == 16 and tag == 130: message.selected_audio_format_ids.append(FormatId.decode(reader, reader.uint32())); continue
            elif field_number == 17 and tag == 138: message.selected_video_format_ids.append(FormatId.decode(reader, reader.uint32())); continue
            elif field_number == 19 and tag == 154: message.streamer_context = StreamerContext.decode(reader, reader.uint32()); continue
            elif field_number == 21 and tag == 170: message.field21 = OQa.decode(reader, reader.uint32()); continue
            elif field_number == 22 and tag == 176: message.field22 = reader.int32(); continue
            elif field_number == 23 and tag == 184: message.field23 = reader.int32(); continue
            elif field_number == 1000 and tag == 8002: message.field1000.append(Pqa.decode(reader, reader.uint32())); continue
        return message


'''SabrError'''
class SabrError:
    def __init__(self):
        self.type = ""
        self.code = 0
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("type") not in (None, ""): writer.uint32(10).string(message["type"])
        if message.get("code") not in (None, 0): writer.uint32(16).int32(message["code"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = SabrError()
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.type = reader.string(); continue
            if field_number == 2 and tag == 16: message.code = reader.int32(); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message


'''MediaHeader'''
class MediaHeader:
    def __init__(self):
        self.headerId: int = 0
        self.videoId: str = ""
        self.itag: int = 0
        self.lmt: int = 0
        self.xtags: str = ""
        self.startRange: int = 0
        self.compressionAlgorithm: int = 0
        self.isInitSeg: bool = False
        self.sequenceNumber: int = 0
        self.field10: int = 0
        self.startMs: int = 0
        self.durationMs: int = 0
        self.formatId: Optional[FormatId] = None
        self.contentLength: int = 0
        self.timeRange: Optional[TimeRange] = None
    '''decode'''
    @staticmethod
    def decode(reader, length: Optional[int] = None):
        if not isinstance(reader, BinaryReader): reader = BinaryReader(reader)
        end = reader.len if length is None else reader.pos + length
        message = MediaHeader()
        while reader.pos < end:
            tag = reader.uint32()
            field = tag >> 3
            if field == 1 and tag == 8: message.headerId = reader.uint32(); continue
            elif field == 2 and tag == 18: message.videoId = reader.string(); continue
            elif field == 3 and tag == 24: message.itag = reader.int32(); continue
            elif field == 4 and tag == 32: message.lmt = longtonumber(reader.uint64()); continue
            elif field == 5 and tag == 42: message.xtags = reader.string(); continue
            elif field == 6 and tag == 48: message.startRange = longtonumber(reader.int64()); continue
            elif field == 7 and tag == 56: message.compressionAlgorithm = reader.int32(); continue
            elif field == 8 and tag == 64: message.isInitSeg = reader.bool(); continue
            elif field == 9 and tag == 72: message.sequenceNumber = longtonumber(reader.int64()); continue
            elif field == 10 and tag == 80: message.field10 = longtonumber(reader.int64()); continue
            elif field == 11 and tag == 88: message.startMs = longtonumber(reader.int64()); continue
            elif field == 12 and tag == 96: message.durationMs = longtonumber(reader.int64()); continue
            elif field == 13 and tag == 106:
                length = reader.uint32()
                message.formatId = FormatId.decode(reader, length)
                continue
            elif field == 14 and tag == 112:
                message.contentLength = longtonumber(reader.int64())
                continue
            elif field == 15 and tag == 122:
                length = reader.uint32()
                message.timeRange = TimeRange.decode(reader, length)
                continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("headerId", 0): writer.uint32(8).uint32(message["headerId"])
        if message.get("videoId", ""): writer.uint32(18).string(message["videoId"])
        if message.get("itag", 0): writer.uint32(24).int32(message["itag"])
        if message.get("lmt", 0): writer.uint32(32).uint64(message["lmt"])
        if message.get("xtags", ""): writer.uint32(42).string(message["xtags"])
        if message.get("startRange", 0): writer.uint32(48).int64(message["startRange"])
        if message.get("compressionAlgorithm", 0): writer.uint32(56).int32(message["compressionAlgorithm"])
        if message.get("isInitSeg", False): writer.uint32(64).bool(message["isInitSeg"])
        if message.get("sequenceNumber", 0): writer.uint32(72).int64(message["sequenceNumber"])
        if message.get("field10", 0): writer.uint32(80).int64(message["field10"])
        if message.get("startMs", 0): writer.uint32(88).int64(message["startMs"])
        if message.get("durationMs", 0): writer.uint32(96).int64(message["durationMs"])
        if message.get("formatId", 0): FormatId.encode(message["formatId"], writer.uint32(106).fork()).join()
        if message.get("contentLength", 0): writer.uint32(112).int64(message["contentLength"])
        if message.get("timeRange", 0): TimeRange.encode(message["timeRange"], writer.uint32(122).fork()).join()
        return writer


'''NextRequestPolicy'''
class NextRequestPolicy:
    def __init__(self):
        self.targetAudioReadaheadMs = 0
        self.targetVideoReadaheadMs = 0
        self.backoffTimeMs = 0
        self.playbackCookie = None
        self.videoId = ""
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("targetAudioReadaheadMs", 0) != 0: writer.uint32(8).int32(message["targetAudioReadaheadMs"])
        if message.get("targetVideoReadaheadMs", 0) != 0: writer.uint32(16).int32(message["targetVideoReadaheadMs"])
        if message.get("backoffTimeMs", 0) != 0: writer.uint32(32).int32(message["backoffTimeMs"])
        if message.get("playbackCookie") is not None: PlaybackCookie.encode(message["playbackCookie"], writer.uint32(58).fork()).join()
        if message.get("videoId", "") != "": writer.uint32(66).string(message["videoId"])
        return writer
    '''decode'''
    @staticmethod
    def decode(data, length=None):
        reader = data if isinstance(data, BinaryReader) else BinaryReader(data)
        end = reader.len if length is None else reader.pos + length
        message = NextRequestPolicy
        while reader.pos < end:
            tag = reader.uint32()
            field = tag >> 3
            if field == 1 and tag == 8: message.targetAudioReadaheadMs = reader.int32(); continue
            elif field == 2 and tag == 16: message.targetVideoReadaheadMs = reader.int32(); continue
            elif field == 4 and tag == 32: message.backoffTimeMs = reader.int32(); continue
            elif field == 7 and tag == 58: message.playbackCookie = PlaybackCookie.decode(reader, reader.uint32()); continue
            elif field == 8 and tag == 66: message.videoId = reader.string(); continue
            elif (tag & 7) == 4 or tag == 0: break
            else: reader.skip(tag & 7)
        return message


'''FormatInitializationMetadata'''
class FormatInitializationMetadata:
    def __init__( self):
        self.videoId = ""
        self.formatId = None
        self.endTimeMs = 0
        self.endSegmentNumber = 0
        self.mimeType = ""
        self.initRange = None
        self.indexRange = None
        self.field8 = 0
        self.durationMs = 0
        self.field10 = 0
    '''encode'''
    @staticmethod
    def encode(message, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.videoId != "":
            writer.uint32(10)
            writer.string(message.videoId)
        if message.formatId is not None:
            writer.uint32(18)
            FormatId.encode(message.formatId, writer.fork()).join()
        if message.endTimeMs != 0:
            writer.uint32(24)
            writer.int32(message.endTimeMs)
        if message.endSegmentNumber != 0:
            writer.uint32(32)
            writer.int64(message.endSegmentNumber)
        if message.mimeType != "":
            writer.uint32(42)
            writer.string(message.mimeType)
        if message.initRange is not None:
            writer.uint32(50)
            InitRange.encode(message.initRange, writer.fork()).join()
        if message.indexRange is not None:
            writer.uint32(58)
            IndexRange.encode(message.indexRange, writer.fork()).join()
        if message.field8 != 0:
            writer.uint32(64)
            writer.int32(message.field8)
        if message.durationMs != 0:
            writer.uint32(72)
            writer.int32(message.durationMs)
        if message.field10 != 0:
            writer.uint32(80)
            writer.int32(message.field10)
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = FormatInitializationMetadata()
        while reader.pos < end:
            tag = reader.uint32()
            field_no = tag >> 3
            if field_no == 1 and tag == 10: message.videoId = reader.string(); continue
            elif field_no == 2 and tag == 18: message.formatId = FormatId.decode(reader, reader.uint32()); continue
            elif field_no == 3 and tag == 24: message.endTimeMs = reader.int32(); continue
            elif field_no == 4 and tag == 32: message.endSegmentNumber = longtonumber(reader.int64()); continue
            elif field_no == 5 and tag == 42: message.mimeType = reader.string(); continue
            elif field_no == 6 and tag == 50: message.initRange = InitRange.decode(reader, reader.uint32()); continue
            elif field_no == 7 and tag == 58: message.indexRange = IndexRange.decode(reader, reader.uint32()); continue
            elif field_no == 8 and tag == 64: message.field8 = reader.int32(); continue
            elif field_no == 9 and tag == 72: message.durationMs = reader.int32(); continue
            elif field_no == 10 and tag == 80: message.field10 = reader.int32(); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message


'''SabrRedirect'''
class SabrRedirect:
    def __init__(self):
        self.url = ""
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("url") not in (None, ""): writer.uint32(10).string(message["url"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = SabrRedirect
        while reader.pos < end:
            tag = reader.uint32()
            field_number = tag >> 3
            if field_number == 1 and tag == 10: message.url = reader.string(); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message


'''StreamProtectionStatus'''
class StreamProtectionStatus:
    def __init__(self):
        self.status = None
        self.field2 = None
    '''encode'''
    @staticmethod
    def encode(message: dict, writer=None):
        if writer is None: writer = BinaryWriter()
        if message.get("status", 0) != 0:
            writer.uint32(8)
            writer.int32(message["status"])
        if message.get("field2") != 0:
            writer.uint32(16)
            writer.int32(message["field2"])
        return writer
    '''decode'''
    @staticmethod
    def decode(input_data, length=None):
        reader = input_data if isinstance(input_data, BinaryReader) else BinaryReader(input_data)
        end = reader.len if length is None else reader.pos + length
        message = StreamProtectionStatus()
        while reader.pos < end:
            tag = reader.uint32()
            field_no = tag >> 3
            if field_no == 1 and tag == 8: message.status = reader.int32(); continue
            elif field_no == 2 and tag == 16: message.field2 = reader.int32(); continue
            if (tag & 7) == 4 or tag == 0: break
            reader.skip(tag & 7)
        return message
    '''Status'''
    class Status(Enum):
        OK = 1
        ATTESTATION_PENDING = 2
        ATTESTATION_REQUIRED = 3


'''ServerAbrStream'''
class ServerAbrStream:
    def __init__(self, stream: Stream, write_chunk: Callable, monostate: Monostate):
        self.stream = stream
        self.write_chunk = write_chunk
        self.youtube = monostate.youtube
        self.po_token = self.stream.po_token
        self.server_abr_streaming_url = self.stream.url
        self.video_playback_ustreamer_config = self.stream.video_playback_ustreamer_config
        self.totalDurationMs = int(self.stream.durationMs)
        self.bytes_remaining = self.stream.filesize
        self.initialized_formats = []
        self.formats_by_key = {}
        self.playback_cookie = None
        self.header_id_to_format_key_map = {}
        self.previous_sequences = {}
        self.RELOAD = False
        self.maximum_reload_attempt = 4
        self.stream_protection_status = PoTokenStatus.UNKNOWN.name
        self.sabr_contexts_to_send = []
        self.sabr_context_updates = dict()
    '''emit'''
    def emit(self, data):
        for formatId in data['initialized_formats']:
            if formatId['formatId']['itag'] == self.stream.itag:
                media_chunks = formatId['mediaChunks']
                for chunk in media_chunks:
                    self.bytes_remaining -= len(chunk)
                    self.write_chunk(chunk, self.bytes_remaining)
    '''start'''
    def start(self):
        audio_format = [{'itag': self.stream.itag, 'lastModified': int(self.stream.last_Modified), 'xtags': self.stream.xtags}] if self.stream.type == 'audio' else []
        video_format = [{'itag': self.stream.itag, 'lastModified': int(self.stream.last_Modified), 'xtags': self.stream.xtags}] if self.stream.type == 'video' else []
        client_abr_state = {
            'lastManualDirection': 0, 'timeSinceLastManualFormatSelectionMs': 0, 'lastManualSelectedResolution': int(self.stream.resolution.replace('p', '')) if video_format else 720,
            'stickyResolution': int(self.stream.resolution.replace('p', '')) if video_format else 720, 'playerTimeMs': 0, 'visibility': 0, 'drcEnabled': self.stream.is_drc,
            'enabledTrackTypesBitfield': 0 if video_format else 1
        }
        while client_abr_state['playerTimeMs'] < self.totalDurationMs:
            data = self.fetchmedia(client_abr_state, audio_format, video_format)
            if data.get("sabr_error"): self.reload()
            self.emit(data)
            if data.get("sabr_context_update"):
                if self.maximum_reload_attempt > 0: continue
                else: raise 
            if client_abr_state["enabledTrackTypesBitfield"] == 0:
                main_format = next((fmt for fmt in data.get("initialized_formats", []) if "video" in (fmt.get("mimeType") or "")), None)
            else:
                main_format = data['initialized_formats'][0] if data['initialized_formats'] else None
            for fmt in data.get("initialized_formats", []):
                format_key = fmt["formatKey"]
                sequence_numbers = [seq.get("sequenceNumber", 0) for seq in fmt.get("sequenceList", [])]
                self.previous_sequences[format_key] = sequence_numbers
            if not self.RELOAD and (main_format is None or not main_format.get("sequenceList")): self.reload()
            if self.RELOAD:
                if self.maximum_reload_attempt > 0:
                    self.RELOAD = False
                    continue
                else:
                    raise 
            if (not main_format or main_format["sequenceCount"] == main_format["sequenceList"][-1].get("sequenceNumber")): break
            total_sequence_duration = sum(seq.get("durationMs", 0) for seq in main_format["sequenceList"])
            client_abr_state["playerTimeMs"] += total_sequence_duration
    '''fetchmedia'''
    def fetchmedia(self, client_abr_state, audio_format, video_format):
        body = VideoPlaybackAbrRequest.encode({
            'clientAbrState': client_abr_state, 'selectedAudioFormatIds': audio_format, 'selectedVideoFormatIds': video_format,
            'selectedFormatIds': [fmt["formatId"] for fmt in self.initialized_formats], 'videoPlaybackUstreamerConfig': self.base64tou8(self.video_playback_ustreamer_config),
            'streamerContext': {
                'sabrContexts': [ctx for ctx in self.sabr_context_updates.values() if ctx["type"] in self.sabr_contexts_to_send],
                'field6': [],
                'poToken': self.base64tou8(self.po_token) if self.po_token else None,
                'playbackCookie': PlaybackCookie.encode(self.playback_cookie).finish() if self.playback_cookie else None,
                'clientInfo': {'clientName': 1, 'clientVersion': '2.20250523.01.00', 'osName': 'Windows', 'osVersion': '10.0', 'platform': 'DESKTOP'}
            },
            'bufferedRanges': [fmt["_state"] for fmt in self.initialized_formats], 'field1000': []
        }).finish()
        base_headers = {"User-Agent": "Mozilla/5.0", "accept-language": "en-US,en", "Content-Type": "application/vnd.yt-ump"}
        request = Request(self.server_abr_streaming_url, headers=base_headers, method="POST", data=bytes(body))
        return self.parseumpresponse(bytes(urlopen(request).read()))
    '''parseumpresponse'''
    def parseumpresponse(self, resp):
        self.header_id_to_format_key_map.clear()
        for k, v in enumerate(self.initialized_formats): self.initialized_formats[k]['sequenceList'], self.initialized_formats[k]['mediaChunks'] = [], []
        sabr_error, sabr_redirect, sabr_context_update = None, None, False
        ump = UMP(ChunkedDataBuffer([resp]))
        def callback(part):
            data = list(part['data'].chunks[0] if part['data'].chunks else [])
            if part['type'] == PART.MEDIA_HEADER.value:
                self.processmediaheader(data)
            elif part['type'] == PART.MEDIA.value:
                self.processmediadata(part['data'])
            elif part['type'] == PART.MEDIA_END.value:
                self.processendofmedia(part['data'])
            elif part['type'] == PART.NEXT_REQUEST_POLICY.value:
                self.processnextrequestpolicy(data)
            elif part['type'] == PART.FORMAT_INITIALIZATION_METADATA.value:
                self.processformatinitialization(data)
            elif part['type'] == PART.SABR_ERROR.value:
                nonlocal sabr_error
                sabr_error = SabrError.decode(data)
            elif part['type'] == PART.SABR_REDIRECT.value:
                nonlocal sabr_redirect
                sabr_redirect = self.processsabrredirect(data)
            elif part['type'] == PART.STREAM_PROTECTION_STATUS.value:
                self.processstreamprotectionstatus(data)
            elif part['type'] == PART.RELOAD_PLAYER_RESPONSE.value:
                self.reload()
            elif part["type"] == PART.PLAYBACK_START_POLICY.value:
                pass
            elif part["type"] == PART.REQUEST_CANCELLATION_POLICY.value:
                pass
            elif part["type"] == PART.SABR_CONTEXT_UPDATE.value:
                nonlocal sabr_context_update
                sabr_context_update = True
                self.processsabrcontextupdate(data)
            elif part["type"] == PART.SNACKBAR_MESSAGE.value:
                sabr_context_update = True
                self.processsnackbarmessage()
        ump.parse(callback)
        return {"initialized_formats": self.initialized_formats, "sabr_redirect": sabr_redirect, "sabr_error": sabr_error, "sabr_context_update": sabr_context_update}
    '''processmediaheader'''
    def processmediaheader(self, data):
        media_header = MediaHeader.decode(data)
        if not media_header.formatId: return
        format_key = self.getformatkey(media_header.formatId)
        current_format = self.formats_by_key.get(format_key) or self.registerformat(media_header)
        if not current_format: return
        sequence_number = media_header.sequenceNumber
        if sequence_number is not None:
            if format_key in self.previous_sequences:
                if sequence_number in self.previous_sequences[format_key]: return
        header_id = media_header.headerId
        if header_id is not None:
            if header_id not in self.header_id_to_format_key_map:
                self.header_id_to_format_key_map[header_id] = format_key
        if not any(seq.get("sequenceNumber") == (media_header.sequenceNumber or 0) for seq in current_format["sequenceList"]):
            current_format["sequenceList"].append({
                "itag": media_header.itag, "formatId": media_header.formatId, "isInitSegment": media_header.isInitSeg, "durationMs": media_header.durationMs, "startMs": media_header.startMs, 
                "startDataRange": media_header.startRange, "sequenceNumber": media_header.sequenceNumber, "contentLength": media_header.contentLength, "timeRange": media_header.timeRange
            })
            if isinstance(sequence_number, int):
                current_format["_state"]["durationMs"] += media_header.durationMs
                current_format["_state"]["endSegmentIndex"] += 1
    '''processmediadata'''
    def processmediadata(self, data):
        header_id = data.getuint8(0)
        stream_data = data.split(1)['remaining_buffer']
        format_key = self.header_id_to_format_key_map.get(header_id)
        if not format_key: return
        current_format = self.formats_by_key.get(format_key)
        if not current_format: return
        current_format['mediaChunks'].append(stream_data.chunks[0])
    '''processendofmedia'''
    def processendofmedia(self, data):
        header_id = data.getuint8(0)
        self.header_id_to_format_key_map.pop(header_id, None)
    '''processnextrequestpolicy'''
    def processnextrequestpolicy(self, data):
        next_request_policy = NextRequestPolicy.decode(data)
        self.playback_cookie = next_request_policy.playbackCookie
    '''processformatinitialization'''
    def processformatinitialization(self, data):
        format_metadata = FormatInitializationMetadata.decode(data)
        self.registerformat(format_metadata)
    '''processsabrredirect'''
    def processsabrredirect(self, data):
        sabr_redirect = SabrRedirect.decode(data)
        if not sabr_redirect.url:
            raise ValueError("Invalid SABR redirect")
        self.server_abr_streaming_url = sabr_redirect.url
        return sabr_redirect
    '''processsnackbarmessage'''
    def processsnackbarmessage(self):
        skip = self.sabr_context_updates[self.sabr_contexts_to_send[-1]].get("skip", 1000) / 1000
        if skip >= 60: raise
        time.sleep(skip)
        self.maximum_reload_attempt -= 1
    '''processstreamprotectionstatus'''
    def processstreamprotectionstatus(self, data):
        protection_status = StreamProtectionStatus.decode(data).status
        if protection_status == StreamProtectionStatus.Status.OK.value:
            result_status = PoTokenStatus.OK.name if self.po_token else PoTokenStatus.NOT_REQUIRED.name
        elif protection_status == StreamProtectionStatus.Status.ATTESTATION_PENDING.value:
            result_status = PoTokenStatus.PENDING.name if self.po_token else PoTokenStatus.PENDING_MISSING.name
        elif protection_status == StreamProtectionStatus.Status.ATTESTATION_REQUIRED.value:
            result_status = PoTokenStatus.INVALID.name if self.po_token else PoTokenStatus.MISSING.name
        else:
            result_status = PoTokenStatus.UNKNOWN.name
        self.stream_protection_status = result_status
    '''processsabrcontextupdate'''
    def processsabrcontextupdate(self, data):
        sabr_ctx_update = StreamerContextUpdate.decode(data)
        if not (sabr_ctx_update["type"] and sabr_ctx_update["value"] and sabr_ctx_update["writePolicy"]): return
        if (sabr_ctx_update["writePolicy"] == StreamerContextUpdate.SabrContextWritePolicy.SABR_CONTEXT_WRITE_POLICY_KEEP_EXISTING.value and sabr_ctx_update["type"] in self.sabr_context_updates): return
        self.sabr_context_updates[sabr_ctx_update["type"]] = sabr_ctx_update
        timestamp = sabr_ctx_update.get("value", "").get("field1", "").get("timestamp", "")
        skip = sabr_ctx_update.get("value", "").get("field1", "").get("skip", "")
        self.sabr_context_updates[sabr_ctx_update["type"]]["timestamp"] = timestamp
        self.sabr_context_updates[sabr_ctx_update["type"]]["skip"] = skip
        if sabr_ctx_update["sendByDefault"] is True: self.sabr_contexts_to_send.append(sabr_ctx_update["type"])
    '''getformatkey'''
    @staticmethod
    def getformatkey(format_id):
        return f"{format_id['itag']};{format_id['lastModified']};"
    '''registerformat'''
    def registerformat(self, data):
        if data.formatId is None: return None
        format_key = self.getformatkey(data.formatId)
        if format_key not in self.formats_by_key:
            format_ = {
                "formatId": data.formatId, "formatKey": format_key, "durationMs": data.durationMs, "mimeType": data.mimeType, "sequenceCount": data.endSegmentNumber,
                "sequenceList": [], "mediaChunks": [], "_state": {"formatId": data.formatId, "startTimeMs": 0, "durationMs": 0, "startSegmentIndex": 1, "endSegmentIndex": 0}
            }
            self.initialized_formats.append(format_)
            self.formats_by_key[format_key] = self.initialized_formats[-1]
            return format_
        return None
    '''reload'''
    def reload(self):
        self.RELOAD = True
        self.maximum_reload_attempt -= 1
        self.sabr_contexts_to_send = []
        self.sabr_context_updates = dict()
        self.youtube.vid_info = None
        refresh_url = self.youtube.server_abr_streaming_url
        if not refresh_url: raise ValueError("Invalid SABR refresh")
        self.server_abr_streaming_url = refresh_url
        self.video_playback_ustreamer_config = self.youtube.video_playback_ustreamer_config
    '''base64tou8'''
    @staticmethod
    def base64tou8(base64_str: str):
        standard_base64 = base64_str.replace('-', '+').replace('_', '/')
        padded_base64 = standard_base64 + '=' * ((4 - len(standard_base64) % 4) % 4)
        byte_data = base64.b64decode(padded_base64)
        return bytearray(byte_data)


'''StreamQuery'''
class StreamQuery(Sequence):
    def __init__(self, fmt_streams):
        self.fmt_streams = fmt_streams
        self.itag_index = {int(s.itag): s for s in fmt_streams}
    '''filter'''
    def filter(self, fps=None, res=None, resolution=None, mime_type=None, type=None, subtype=None, file_extension=None, abr=None, bitrate=None, video_codec=None, audio_codec=None, 
               only_audio=None, only_video=None, progressive=None, adaptive=None, is_dash=None, is_drc=None, audio_track_name=None, custom_filter_functions=None):
        filters = []
        if res or resolution:
            if isinstance(res, str) or isinstance(resolution, str): filters.append(lambda s: s.resolution == (res or resolution))
            elif isinstance(res, list) or isinstance(resolution, list): filters.append(lambda s: s.resolution in (res or resolution))
        if fps: filters.append(lambda s: s.fps == fps)
        if mime_type: filters.append(lambda s: s.mime_type == mime_type)
        if type: filters.append(lambda s: s.type == type)
        if subtype or file_extension: filters.append(lambda s: s.subtype == (subtype or file_extension))
        if abr or bitrate: filters.append(lambda s: s.abr == (abr or bitrate))
        if video_codec: filters.append(lambda s: s.video_codec == video_codec)
        if audio_codec: filters.append(lambda s: s.audio_codec == audio_codec)
        if only_audio: filters.append(lambda s: (s.includesaudiotrack and not s.includesvideotrack))
        if only_video: filters.append(lambda s: (s.includesvideotrack and not s.includesaudiotrack))
        if progressive: filters.append(lambda s: s.isprogressive)
        if adaptive: filters.append(lambda s: s.isadaptive)
        if audio_track_name: filters.append(lambda s: s.audio_track_name == audio_track_name)
        if custom_filter_functions: filters.extend(custom_filter_functions)
        if is_dash is not None: filters.append(lambda s: s.is_dash == is_dash)
        if is_drc is not None: filters.append(lambda s: s.is_drc == is_drc)
        return self._filter(filters)
    '''_filter'''
    def _filter(self, filters: List[Callable]):
        fmt_streams = self.fmt_streams
        for filter_lambda in filters: fmt_streams = filter(filter_lambda, fmt_streams)
        return StreamQuery(list(fmt_streams))
    '''orderby'''
    def orderby(self, attribute_name: str):
        has_attribute = [s for s in self.fmt_streams if getattr(s, attribute_name) is not None]
        if has_attribute and isinstance(getattr(has_attribute[0], attribute_name), str):
            try: return StreamQuery(sorted(has_attribute, key=lambda s: int("".join(filter(str.isdigit, getattr(s, attribute_name))))))
            except ValueError: pass
        return StreamQuery(sorted(has_attribute, key=lambda s: getattr(s, attribute_name)))
    '''desc'''
    def desc(self):
        return StreamQuery(self.fmt_streams[::-1])
    '''asc'''
    def asc(self):
        return self
    '''getbyitag'''
    def getbyitag(self, itag: Union[int, str]):
        if isinstance(itag, int): return self.itag_index.get(itag)
        elif isinstance(itag, str) and itag.isdigit(): return self.itag_index.get(int(itag))
    '''getbyresolution'''
    def getbyresolution(self, resolution: str):
        return self.filter(progressive=True, subtype="mp4", resolution=resolution).first()
    '''getdefaultaudiotrack'''
    def getdefaultaudiotrack(self):
        return self._filter([lambda s: s.is_default_audio_track])
    '''getextraaudiotrack'''
    def getextraaudiotrack(self):
        return self._filter([lambda s: not s.is_default_audio_track and s.includesaudiotrack and not s.includesvideotrack])
    '''getextraaudiotrackbyname'''
    def getextraaudiotrackbyname(self, name):
        return self._filter([lambda s: s.audio_track_name == name])
    '''getlowestresolution'''
    def getlowestresolution(self, progressive=True):
        return self.filter(progressive=progressive, subtype="mp4").orderby("resolution").first()
    '''gethighestresolution'''
    def gethighestresolution(self, progressive=True, mime_type=None):
        return self.filter(progressive=progressive, mime_type=mime_type).orderby("resolution").last()
    '''getaudioonly'''
    def getaudioonly(self, subtype: str = "mp4"):
        return self.filter(only_audio=True, subtype=subtype).orderby("abr").last()
    '''otf'''
    def otf(self, is_otf: bool = False):
        return self._filter([lambda s: s.is_otf == is_otf])
    '''first'''
    def first(self):
        try: return self.fmt_streams[0]
        except IndexError: return None
    '''last'''
    def last(self):
        try: return self.fmt_streams[-1]
        except IndexError: pass
    '''count'''
    def count(self, value: Optional[str] = None):
        return self.fmt_streams.count(value) if value else len(self)
    '''all'''
    def all(self):
        return self.fmt_streams
    '''getitem'''
    def __getitem__(self, i: Union[slice, int]):
        return self.fmt_streams[i]
    '''len'''
    def __len__(self):
        return len(self.fmt_streams)


'''InnerTube'''
class InnerTube:
    def __init__(self, client='ANDROID_VR', use_oauth=False, allow_cache=True, token_file=None, oauth_verifier=None, use_po_token=False, po_token_verifier=None):
        self.client_name = client
        self.innertube_context = DEFAULT_CLIENTS[client]['innertube_context']
        self.header = DEFAULT_CLIENTS[client]['header']
        self.api_key = DEFAULT_CLIENTS[client]['api_key']
        self.require_js_player = DEFAULT_CLIENTS[client]['require_js_player']
        self.require_po_token = DEFAULT_CLIENTS[client]['require_po_token']
        self.access_token = None
        self.refresh_token = None
        self.access_po_token = None
        self.access_visitorData = None
        self.use_oauth = use_oauth
        self.allow_cache = allow_cache
        self.oauth_verifier = oauth_verifier or defaultoauthverifier
        self.expires = None
        self.use_po_token = use_po_token
        self.po_token_verifier = po_token_verifier or defaultpotokenverifier
        if not self.allow_cache:
            cache_dir = os.path.join(os.path.dirname(__file__), '__cache__')
            if os.path.exists(cache_dir) and os.path.isdir(cache_dir):
                shutil.rmtree(cache_dir)
        self.token_file = token_file or os.path.join(pathlib.Path(__file__).parent.resolve() / '__cache__', 'tokens.json')
        if self.use_oauth and self.allow_cache and os.path.exists(self.token_file):
            with open(self.token_file) as f:
                data = json.load(f)
                if data['access_token']:
                    self.access_token = data['access_token']
                    self.refresh_token = data['refresh_token']
                    self.expires = data['expires']
                    self.refreshbearertoken()
        if self.use_po_token and self.allow_cache and os.path.exists(self.token_file):
            with open(self.token_file) as f:
                data = json.load(f)
                self.access_visitorData = data['visitorData']
                self.access_po_token = data['po_token']
    '''cachetokens'''
    def cachetokens(self):
        if not self.allow_cache: return
        data = {'access_token': self.access_token, 'refresh_token': self.refresh_token, 'expires': self.expires, 'visitorData': self.access_visitorData, 'po_token': self.access_po_token}
        cache_dir = os.path.dirname(self.token_file)
        if not os.path.exists(cache_dir): os.makedirs(cache_dir, exist_ok=True)
        with open(self.token_file, 'w') as f: json.dump(data, f)
    '''refreshbearertoken'''
    def refreshbearertoken(self, force=False):
        if not self.use_oauth: return
        if self.expires > time.time() and not force: return
        start_time = int(time.time() - 30)
        data = {'client_id': CLIENT_ID, 'client_secret': CLIENT_SECRET, 'grant_type': 'refresh_token', 'refresh_token': self.refresh_token}
        resp = RequestWrapper._executerequest('https://oauth2.googleapis.com/token', 'POST', headers={'Content-Type': 'application/json'}, data=data)
        resp_data = json.loads(resp.read())
        self.access_token = resp_data['access_token']
        self.expires = start_time + resp_data['expires_in']
        self.cachetokens()
    '''fetchbearertoken'''
    def fetchbearertoken(self):
        start_time = int(time.time() - 30)
        data = {'client_id': CLIENT_ID, 'scope': 'https://www.googleapis.com/auth/youtube'}
        resp = RequestWrapper._executerequest('https://oauth2.googleapis.com/device/code', 'POST', headers={'Content-Type': 'application/json'}, data=data)
        resp_data = json.loads(resp.read())
        verification_url = resp_data['verification_url']
        user_code = resp_data['user_code']
        self.oauth_verifier(verification_url, user_code)
        data = {'client_id': CLIENT_ID, 'client_secret': CLIENT_SECRET, 'device_code': resp_data['device_code'], 'grant_type': 'urn:ietf:params:oauth:grant-type:device_code'}
        resp = RequestWrapper._executerequest('https://oauth2.googleapis.com/token', 'POST', headers={'Content-Type': 'application/json'}, data=data)
        resp_data = json.loads(resp.read())
        self.access_token = resp_data['access_token']
        self.refresh_token = resp_data['refresh_token']
        self.expires = start_time + resp_data['expires_in']
        self.cachetokens()
    '''insertvisitordata'''
    def insertvisitordata(self, visitor_data: str):
        self.innertube_context['context']['client'].update({"visitorData": visitor_data})
    '''insertpotoken'''
    def insertpotoken(self, visitor_data: str = None, po_token : str = None):
        self.insertvisitordata(self.access_visitorData or visitor_data)
        self.innertube_context.update({"serviceIntegrityDimensions": {"poToken": self.access_po_token or po_token}})
    '''fetchpotoken'''
    def fetchpotoken(self):
        self.access_visitorData, self.access_po_token = self.po_token_verifier()
        self.cachetokens()
        self.insertpotoken()
    '''baseurl'''
    @property
    def baseurl(self):
        return 'https://www.youtube.com/youtubei/v1'
    '''basedata'''
    @property
    def basedata(self):
        return self.innertube_context
    '''baseparams'''
    @property
    def baseparams(self):
        return {'prettyPrint': "false"}
    '''callapi'''
    def callapi(self, endpoint, query, data):
        endpoint_url = f'{endpoint}?{parse.urlencode(query)}'
        headers = {'Content-Type': 'application/json'}
        if self.use_oauth:
            if self.access_token: self.refreshbearertoken()
            else: self.fetchbearertoken()
            headers['Authorization'] = f'Bearer {self.access_token}'
        if self.use_po_token:
            if self.access_po_token: self.insertpotoken()
            else: self.fetchpotoken()
        headers.update(self.header)
        resp = RequestWrapper._executerequest(endpoint_url, 'POST', headers=headers, data=data)
        return json.loads(resp.read())
    '''browse'''
    def browse(self, continuation=None, visitor_data=None):
        endpoint = f'{self.baseurl}/browse'
        query = self.baseparams
        if continuation: self.basedata.update({"continuation": continuation})
        if visitor_data: self.basedata['context']['client'].update({"visitorData": visitor_data})
        return self.callapi(endpoint, query, self.basedata)
    '''next'''
    def next(self, video_id: str = None, continuation: str = None):
        if continuation: self.basedata.update({"continuation": continuation})
        if video_id: self.basedata.update({'videoId': video_id, 'contentCheckOk': "true"})
        endpoint = f'{self.baseurl}/next'
        query = self.baseparams
        return self.callapi(endpoint, query, self.basedata)
    '''player'''
    def player(self, video_id):
        endpoint = f'{self.baseurl}/player'
        query = self.baseparams
        self.basedata.update({'videoId': video_id, 'contentCheckOk': "true"})
        return self.callapi(endpoint, query, self.basedata)
    '''search'''
    def search(self, search_query, continuation=None, data=None):
        endpoint = f'{self.baseurl}/search'
        query = self.baseparams
        data = data if data else {}
        self.basedata.update({'query': search_query})
        if continuation: data['continuation'] = continuation
        data.update(self.basedata)
        return self.callapi(endpoint, query, data)
    '''verifyage'''
    def verifyage(self, video_id):
        endpoint = f'{self.baseurl}/verify_age'
        data = {'nextEndpoint': {'watchEndpoint': {'racyCheckOk': True, 'contentCheckOk': True, 'videoId': video_id}}, 'setControvercy': True}
        data.update(self.basedata)
        result = self.callapi(endpoint, self.baseparams, data)
        return result
    '''gettranscript'''
    def gettranscript(self, video_id):
        endpoint = f'{self.baseurl}/get_transcript'
        query = {'videoId': video_id}
        query.update(self.baseparams)
        result = self.callapi(endpoint, query, self.basedata)
        return result


'''YouTubeMetadata'''
class YouTubeMetadata:
    def __init__(self, metadata):
        self._raw_metadata = metadata
        self._metadata = [{}]
        for el in metadata:
            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']
            if el.get('hasDividerLine', False): self._metadata.append({})
        if self._metadata[-1] == {}: self._metadata = self._metadata[:-1]
    '''getitem'''
    def __getitem__(self, key):
        return self._metadata[key]
    '''iter'''
    def __iter__(self):
        for el in self._metadata:
            yield el
    '''str'''
    def __str__(self):
        return json.dumps(self._metadata)
    '''rawmetadata'''
    @property
    def rawmetadata(self):
        return self._raw_metadata
    '''metadata'''
    @property
    def metadata(self):
        return self._metadata


'''Cipher'''
class Cipher:
    def __init__(self, js: str, js_url: str):
        self.js_url = js_url
        self.js = js
        self._sig_param_val = None
        self._nsig_param_val = None
        self.sig_function_name = self.getsigfunctionname(js, js_url)
        self.nsig_function_name = self.getnsigfunctionname(js, js_url)
        self.runner_sig = NodeRunner(js)
        self.runner_sig.loadfunction(self.sig_function_name)
        self.runner_nsig = NodeRunner(js)
        self.runner_nsig.loadfunction(self.nsig_function_name)
        self.calculated_n = None
    '''getnsig'''
    def getnsig(self, n: str):
        try:
            if self._nsig_param_val:
                for param in self._nsig_param_val:
                    nsig = self.runner_nsig.call([param, n])
                    if not isinstance(nsig, str): continue
                    else: break
            else:
                nsig = self.runner_nsig.call([n])
        except Exception as err:
            raise err
        if 'error' in nsig or '_w8_' in nsig or not isinstance(nsig, str): raise 
        return nsig
    '''getsig'''
    def getsig(self, ciphered_signature: str):
        try:
            if self._sig_param_val: sig = self.runner_sig.call([self._sig_param_val, ciphered_signature])
            else: sig = self.runner_sig.call([ciphered_signature])
        except Exception as err:
            raise err
        if 'error' in sig or not isinstance(sig, str): raise 
        return sig
    '''getsigfunctionname'''
    def getsigfunctionname(self, js: str, js_url: str):
        function_patterns = [
            r'(?P<sig>[a-zA-Z0-9_$]+)\s*=\s*function\(\s*(?P<arg>[a-zA-Z0-9_$]+)\s*\)\s*{\s*(?P=arg)\s*=\s*(?P=arg)\.split\(\s*[a-zA-Z0-9_\$\"\[\]]+\s*\)\s*;\s*[^}]+;\s*return\s+(?P=arg)\.join\(\s*[a-zA-Z0-9_\$\"\[\]]+\s*\)',
            r'(?:\b|[^a-zA-Z0-9_$])(?P<sig>[a-zA-Z0-9_$]{2,})\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)(?:;[a-zA-Z0-9_$]{2}\.[a-zA-Z0-9_$]{2}\(a,\d+\))?',
            r'\b(?P<var>[a-zA-Z0-9_$]+)&&\((?P=var)=(?P<sig>[a-zA-Z0-9_$]{2,})\((?:(?P<param>\d+),decodeURIComponent|decodeURIComponent)\((?P=var)\)\)',
            r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
            r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
            r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
            r'("|\')signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
            r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
            r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
            r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
            r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('
        ]
        for pattern in function_patterns:
            regex = re.compile(pattern)
            function_match = regex.search(js)
            if function_match:
                sig = function_match.group('sig')
                if "param" in function_match.groupdict():
                    param = function_match.group('param')
                    if param: self._sig_param_val = int(param)
                return sig
        raise
    '''getnsigfunctionname'''
    def getnsigfunctionname(self, js: str, js_url: str):
        try:
            pattern = r"var\s*[a-zA-Z0-9$_]{3}\s*=\s*\[(?P<funcname>[a-zA-Z0-9$_]{3})\]"
            func_name = re.search(pattern, js)
            if func_name: return func_name.group("funcname")
            else:
                global_obj, varname, code = extractplayerjsglobalvar(js)
                if global_obj and varname and code:
                    global_obj = JSInterpreter(js).interpretexpression(code, {}, 100)
                    for k, v in enumerate(global_obj):
                        if v.endswith('_w8_'):
                            pattern = r'''(?xs)
                                    [;\n](?:
                                        (?P<f>function\s+)|
                                        (?:var\s+)?
                                    )(?P<funcname>[a-zA-Z0-9_$]+)\s*(?(f)|=\s*function\s*)
                                    \(\s*(?:[a-zA-Z0-9_$]+\s*,\s*)?(?P<argname>[a-zA-Z0-9_$]+)(?:\s*,\s*[a-zA-Z0-9_$]+)*\s*\)\s*\{
                                    (?:(?!(?<!\{)\};(?![\]\)])).)*
                                    \}\s*catch\(\s*[a-zA-Z0-9_$]+\s*\)\s*
                                    \{\s*(?:return\s+|[\w=]+)%s\[%d\]\s*\+\s*(?P=argname)\s*[\};].*?\s*return\s+[^}]+\}[;\n]
                                '''  % (re.escape(varname), k)
                            func_name = re.search(pattern, js)
                            if func_name:
                                n_func = func_name.group("funcname")
                                self._nsig_param_val = self._extractnsigparamval(js, n_func)
                                return n_func
                            raise
        except Exception as err:
            raise err
    '''_extractnsigparamval'''
    @staticmethod
    def _extractnsigparamval(code: str, func_name: str):
        pattern = re.compile(
            rf'(?<![A-Za-z0-9_$\.])' 
            rf'(?P<func>{re.escape(func_name)})\s*'
            r'\[\w\[\d+\]\]'
            r'\(\s*'
            r'(?P<arg1>[A-Za-z0-9_$]+)'
            r'(?:\s*,\s*(?P<arg2>[A-Za-z0-9_$]+))?'
            r'(?:\s*,\s*[^)]*)?'
            r'\s*\)',
            re.MULTILINE
        )
        results = []
        for m in pattern.finditer(code):
            chosen = m.group('arg2') if m.group('arg1') == 'this' and m.group('arg2') else m.group('arg1')
            results.append(chosen)
        return results


'''YouTube'''
class YouTube:
    def __init__(self, video_id: str, client: str = InnerTube().client_name, on_progress_callback: Optional[Callable[[Any, bytes, int], None]] = None, on_complete_callback: Optional[Callable[[Any, Optional[str]], None]] = None,
                 use_oauth: bool = False, allow_oauth_cache: bool = True, token_file: Optional[str] = None, oauth_verifier: Optional[Callable[[str, str], None]] = None, use_po_token: Optional[bool] = False,
                 po_token_verifier: Optional[Callable[[None], Tuple[str, str]]] = None):
        self._js: Optional[str] = None
        self._js_url: Optional[str] = None
        self._vid_info: Optional[Dict] = None
        self._vid_details: Optional[Dict] = None
        self._watch_html: Optional[str] = None
        self._embed_html: Optional[str] = None
        self._player_config_args: Optional[Dict] = None
        self._age_restricted: Optional[bool] = None
        self._fmt_streams: Optional[List[Stream]] = None
        self._initial_data = None
        self._metadata = None
        self.video_id = video_id
        self.watch_url = f"https://youtube.com/watch?v={self.video_id}"
        self.embed_url = f"https://www.youtube.com/embed/{self.video_id}"
        self.client = client
        self.client = 'TV' if use_oauth else self.client
        self.fallback_clients = ['TV', 'IOS']
        self._signature_timestamp: dict = {}
        self._visitor_data = None
        self.stream_monostate = Monostate(on_progress=on_progress_callback, on_complete=on_complete_callback, youtube=self)
        self._author = None
        self._title = None
        self.use_oauth = use_oauth
        self.allow_oauth_cache = allow_oauth_cache
        self.token_file = token_file
        self.oauth_verifier = oauth_verifier
        self.use_po_token = use_po_token
        self.po_token_verifier = po_token_verifier
        self.po_token = None
        self._pot = None
    '''watch_html'''
    @property
    def watch_html(self):
        if self._watch_html: return self._watch_html
        self._watch_html = RequestWrapper.get(url=self.watch_url)
        return self._watch_html
    '''embed_html'''
    @property
    def embed_html(self):
        if self._embed_html: return self._embed_html
        self._embed_html = RequestWrapper.get(url=self.embed_url)
        return self._embed_html
    '''age_restricted'''
    @property
    def age_restricted(self):
        if self._age_restricted: return self._age_restricted
        self._age_restricted = isagerestricted(self.watch_html)
        return self._age_restricted
    '''js_url'''
    @property
    def js_url(self):
        if self._js_url: return self._js_url
        if self.age_restricted: self._js_url = extractjsurl(self.embed_html)
        else: self._js_url = extractjsurl(self.watch_html)
        return self._js_url
    '''js'''
    @property
    def js(self):
        if self._js: return self._js
        self._js = RequestWrapper.get(self.js_url)
        return self._js
    '''visitor_data'''
    @property
    def visitor_data(self):
        if self._visitor_data: return self._visitor_data
        if InnerTube(self.client).require_po_token:
            try:
                self._visitor_data = extractvisitordata(str(self.initial_data['responseContext']))
                return self._visitor_data
            except:
                pass
        innertube_response = InnerTube('WEB').player(self.video_id)
        try:
            self._visitor_data = innertube_response['responseContext']['visitorData']
        except KeyError:
            p_dicts = innertube_response['responseContext']['serviceTrackingParams'][0]['params']
            self._visitor_data = next(p for p in p_dicts if p['key'] == 'visitor_data')['value']
        return self._visitor_data
    '''pot'''
    @property
    def pot(self):
        if self._pot: return self._pot
        try:
            self._pot = generatepotoken(video_id=self.video_id)
        except Exception as err:
            pass
        return self._pot
    '''initial_data'''
    @property
    def initial_data(self):
        if self._initial_data: return self._initial_data
        self._initial_data = extractinitialdata(self.watch_html)
        return self._initial_data
    '''streaming_data'''
    @property
    def streaming_data(self):
        invalid_id_list = ['aQvGIIdgFDM']
        if 'streamingData' not in self.vid_info or self.vid_info['videoDetails']['videoId'] in invalid_id_list:
            for client in self.fallback_clients:
                self.client = client
                self.vid_info = None
                if 'streamingData' in self.vid_info: break
        return self.vid_info['streamingData']
    '''fmt_streams'''
    @property
    def fmt_streams(self):
        if self._fmt_streams: return self._fmt_streams
        self._fmt_streams = []
        stream_manifest = applydescrambler(self.streaming_data)
        inner_tube = InnerTube(self.client)
        if self.po_token: applypotoken(stream_manifest, self.vid_info, self.po_token)
        if inner_tube.require_js_player:
            try:
                applysignature(stream_manifest, self.vid_info, self.js, self.js_url)
            except:
                self._js = None
                self._js_url = None
                applysignature(stream_manifest, self.vid_info, self.js, self.js_url)
        for stream in stream_manifest:
            video = Stream(stream=stream, monostate=self.stream_monostate, po_token=self.po_token, video_playback_ustreamer_config=self.video_playback_ustreamer_config)
            self._fmt_streams.append(video)
        self.stream_monostate.title = self.title
        self.stream_monostate.duration = self.length
        return self._fmt_streams
    '''signature_timestamp'''
    @property
    def signature_timestamp(self):
        if not self._signature_timestamp:
            self._signature_timestamp = {'playbackContext': {'contentPlaybackContext': {'signatureTimestamp': extractsignaturetimestamp(self.js)}}}
        return self._signature_timestamp
    '''video_playback_ustreamer_config'''
    @property
    def video_playback_ustreamer_config(self):
        return self.vid_info['playerConfig']['mediaCommonConfig']['mediaUstreamerRequestConfig']['videoPlaybackUstreamerConfig']
    '''server_abr_streaming_url'''
    @property
    def server_abr_streaming_url(self):
        try:
            url = self.vid_info['streamingData']['serverAbrStreamingUrl']
            stream_manifest = [{"url": url}]
            applysignature(stream_manifest, vid_info=self.vid_info, js=self.js, url_js=self.js_url)
            return stream_manifest[0]["url"]
        except Exception:
            return None
    '''vid_info'''
    @property
    def vid_info(self):
        if self._vid_info: return self._vid_info
        self._vid_info = self.vid_info_client()
        return self._vid_info
    @vid_info.setter
    def vid_info(self, value):
        self._vid_info = value
    '''vid_info_client'''
    def vid_info_client(self, optional_client=None):
        if optional_client is None:
            if self._vid_info: return self._vid_info
            optional_client = self.client
        def _callinnertube(optional_client):
            innertube = InnerTube(
                client=optional_client, use_oauth=self.use_oauth, allow_cache=self.allow_oauth_cache, token_file=self.token_file, oauth_verifier=self.oauth_verifier,
                use_po_token=self.use_po_token, po_token_verifier=self.po_token_verifier
            )
            if innertube.require_js_player: innertube.innertube_context.update(self.signature_timestamp)
            if innertube.require_po_token and not self.use_po_token: innertube.insertvisitordata(visitor_data=self.visitor_data)
            elif not self.use_po_token: innertube.insertvisitordata(visitor_data=self.visitor_data)
            response = innertube.player(self.video_id)
            if self.use_po_token or innertube.require_po_token: self.po_token = innertube.access_po_token or self.pot
            return response
        innertube_response = _callinnertube(optional_client)
        for client in self.fallback_clients:
            playability_status = innertube_response['playabilityStatus']
            if playability_status['status'] == 'UNPLAYABLE' and 'reason' in playability_status and playability_status['reason'] == 'This video is not available':
                self.client = client
                innertube_response = _callinnertube(client)
            else:
                break
        return innertube_response
    '''vid_details'''
    @property
    def vid_details(self):
        if self._vid_details: return self._vid_details
        innertube = InnerTube(
            client='TV' if self.use_oauth else 'WEB', use_oauth=self.use_oauth, allow_cache=self.allow_oauth_cache, token_file=self.token_file,
            oauth_verifier=self.oauth_verifier, use_po_token=self.use_po_token, po_token_verifier=self.po_token_verifier
        )
        innertube_response = innertube.next(self.video_id)
        self._vid_details = innertube_response
        return self._vid_details
    @vid_details.setter
    def vid_details(self, value):
        self._vid_details = value
    '''streams'''
    @property
    def streams(self):
        return StreamQuery(self.fmt_streams)
    '''vid_engagement_items'''
    def vid_engagement_items(self):
        for i in range(len(self.vid_details.get('engagementPanels', []))):
            try:
                return self.vid_details['engagementPanels'][i]['engagementPanelSectionListRenderer']['content']['structuredDescriptionContentRenderer']['items']
            except:
                continue
    '''title'''
    @property
    def title(self):
        self._author = self.vid_info.get("videoDetails", {}).get("author", "unknown")
        if self._title: return self._title
        if self.use_oauth == True: self._title = self.vid_engagement_items()[0]['videoDescriptionHeaderRenderer']['title']['runs'][0]['text']
        if 'title' in self.vid_info['videoDetails']:
            self._title = self.vid_info['videoDetails']['title']
        else:
            if 'singleColumnWatchNextResults' in self.vid_details['contents']:
                contents = self.vid_details['contents']['singleColumnWatchNextResults']['results']['results']['contents'][0]['itemSectionRenderer']['contents'][0]
                if 'videoMetadataRenderer' in contents:
                    self._title = contents['videoMetadataRenderer']['title']['runs'][0]['text']
                else:
                    self._title = contents['musicWatchMetadataRenderer']['title']['simpleText']
            elif 'twoColumnWatchNextResults' in self.vid_details['contents']:
                contents = self.vid_details['contents']['twoColumnWatchNextResults']['results']['results']['contents']
                for videoPrimaryInfoRenderer in contents:
                    if 'videoPrimaryInfoRenderer' in videoPrimaryInfoRenderer:
                        self._title = videoPrimaryInfoRenderer['videoPrimaryInfoRenderer']['title']['runs'][0]['text']
                        break
        return self._title
    @title.setter
    def title(self, value):
        self._title = value
    '''length'''
    @property
    def length(self):
        return int(self.vid_info.get('videoDetails', {}).get('lengthSeconds'))
    '''author'''
    @property
    def author(self):
        _author = self.vid_info.get("videoDetails", {}).get("author", "unknown")
        if self.use_oauth == True: _author = self.vid_engagement_items()[0]['videoDescriptionHeaderRenderer']['channel']['simpleText']
        self._author = _author
        return self._author
    @author.setter
    def author(self, value):
        self._author = value
    '''metadata'''
    @property
    def metadata(self):
        if not self._metadata:
            self._metadata = extractmetadata(self.initial_data)
        return self._metadata