+ 
+
Netflix-DL 6.0 |HDR-HEVC-MPL-HPL Working| ! 
++
+ +# Use Python 3.9.8 & install + +## Quick start +``` +install.requirements.bat +``` +``` +For Chrome install the following addon +https://chrome.google.com/webstore/detail/get-cookiestxt/bgaddhkoddajcdgocldbbfleckgcbcid?hl=en + +``` +``` +get cookies.txt from netflix site you should be login in the browser and put it in as cookies.txt in +\configs\Cookies +``` +``` +Now edit config.py in following path +\configs\config.py +line no .108-109 + "email": "xxx", + "password": "xxxx", + put your login details here +``` +``` +Now enjoy using it +``` +Examples + +netflix.pyc 81478916 -q 1080 --hdr + +netflix.pyc 81478916 -q 1080 --hevc + +netflix.pyc 81478916 -q 1080 --main + +netflix.pyc 81478916 -q 1080 --high + +``` +USAGE： + -h，--help Display the complete parameter setting help file and exit + -q
+ 
+
Hello Fellow < Developers/ >!
++
+ + + +About Me
+ +
+
+
+- 👯 Sharing is caring
+
+
+- ⚡ CDM L1 BUY it from wvfuck@protonmail.com ⚡
+
+
++
+
diff --git a/configs/Cookies/cookies.txt b/configs/Cookies/cookies.txt new file mode 100644 index 0000000..08778d7 --- /dev/null +++ b/configs/Cookies/cookies.txt @@ -0,0 +1 @@ +{\rtf1} \ No newline at end of file diff --git a/configs/Tokens/test.txt b/configs/Tokens/test.txt new file mode 100644 index 0000000..e69de29 diff --git a/configs/Tokens/txt.txt b/configs/Tokens/txt.txt new file mode 100644 index 0000000..e69de29 diff --git a/configs/__init__.py b/configs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/configs/config.py b/configs/config.py new file mode 100644 index 0000000..656481f --- /dev/null +++ b/configs/config.py @@ -0,0 +1,163 @@ +import sys, os, random, string, platform +from os.path import dirname +from os.path import join +from pywidevine.cdm import cdm, deviceconfig + +dirPath = dirname(dirname(__file__)).replace("\\", "/") + +class utils: + def __init__(self): + self.dir = dirPath + + def random_hex(self, length: int) -> str: + """return {length} of random string""" + return "".join(random.choice("0123456789ABCDEF") for _ in range(length)) + +utils_ = utils() + +#####################################(DEVICES)##################################### + +devices_dict = { + "android_general": deviceconfig.device_android_general, +} + +DEVICES = { + "NETFLIX-MANIFEST": devices_dict["android_general"], + "NETFLIX-LICENSE": devices_dict["android_general"], +} + +#####################################(MUXER)##################################### + +MUXER = { + "muxer_file": f"{dirPath}/bin/muxer.json", + "mkv_folder": None, + "DEFAULT": False, # to use the normal renaming. EX: Stranger Things S01E01 [1080p].mkv + "AUDIO": "", # default audio language. + "SUB": "", # default subtitle language. EX: "eng" or "spa" + "GROUP": "WVDUMP", # to change the group name!. it's also possible to use this "--gr LOL", on the ripping commands. + "noTitle": False, # this will remove titles from the episodes EX: (The Witcher S01E01). insstead of (The Witcher S01E01 The End's Beginning). + "scheme": "p2p", # add/change any needed scheme naming. it's also possible to use this "--muxscheme repack", on the ripping commands. + "schemeslist": { + "p2p": "{t}.{r}.{s}.WEB-DL.{ac}.{vc}-{gr}", + "test": "{t}.{r}.{s}.WEB-DL-{gr}", + }, + "EXTRAS": [], # extra mkvmerge.exe commands. + "FPS24": [], +} + +#####################################(PATHS)##################################### + +PATHS = { + "DL_FOLDER": f"{dirPath}", # + "DIR_PATH": f"{dirPath}", + "BINARY_PATH": f"{dirPath}/bin", + "COOKIES_PATH": f"{dirPath}/configs/Cookies", + "KEYS_PATH": f"{dirPath}/configs/KEYS", + "TOKENS_PATH": f"{dirPath}/configs/Tokens", + "JSON_PATH": f"{dirPath}/json", + "LOGA_PATH": f"{dirPath}/helpers/bin/tools/aria2c", +} + +ARIA2C = { + "enable_logging": False, # True +} + +SETTINGS = { + "skip_video_demux": [], +} + +#####################################(VPN)##################################### + +VPN = { + "proxies": None, # "", + "nordvpn": { + "port": "80", + "email": "xxx", + "passwd": "xxx", + "http": "http://{email}:{passwd}@{ip}:{port}", + }, + "private": { + "port": "8080", + "email": "", + "passwd": "", + "http": "http://{email}:{passwd}@{ip}:{port}", + }, +} + +#####################################(BIN)##################################### + +BIN = { + "mp4decrypt_moded": f"{dirPath}/helpers/bin/tools/mp4decrypt.exe", + "mp4dump": f"{dirPath}/helpers/bin/tools/mp4dump.exe", + "ffmpeg": f"{dirPath}/helpers/bin/tools/ffmpeg.exe", + "ffprobe": f"{dirPath}/helpers/bin/tools/ffprobe.exe", + "MediaInfo": f"{dirPath}/helpers/bin/tools/MediaInfo.exe", + "mkvmerge": f"{dirPath}/helpers/bin/tools/mkvmerge.exe", + "aria2c": f"{dirPath}/helpers/bin/tools/aria2c.exe", + } + +#####################################(Config)##################################### + +Config = {} + +Config["NETFLIX"] = { + "cookies_file": f"{dirPath}/configs/Cookies/cookies_nf.txt", + "cookies_txt": f"{dirPath}/configs/Cookies/cookies.txt", + "keys_file": f"{dirPath}/configs/KEYS/netflix.keys", + "token_file": f"{dirPath}/configs/Tokens/netflix_token.json", + "email": "xxx", + "password": "xxx", + "manifest_language": "en-US", + "metada_language": "en", + "manifestEsn": "NFCDIE-03-{}".format(utils().random_hex(30)), + "androidEsn": "NFANDROID1-PRV-P-GOOGLEPIXEL=4=XL-12995-" + utils_.random_hex(64), +} + +#####################################(DIRS & FILES)############################## + +def make_dirs(): + FILES = [] + + DIRS = [ + f"{dirPath}/configs/Cookies", + f"{dirPath}/configs/Tokens", + f"{dirPath}/helpers/bin/tools/aria2c", + ] + + for dirs in DIRS: + if not os.path.exists(dirs): + os.makedirs(dirs) + + for files in FILES: + if not os.path.isfile(files): + with open(files, "w") as f: + f.write("\n") + +make_dirs() + +#####################################(tool)##################################### + +class tool: + def config(self, service): + return Config[service] + + def bin(self): + return BIN + + def vpn(self): + return VPN + + def paths(self): + return PATHS + + def muxer(self): + return MUXER + + def devices(self): + return DEVICES + + def aria2c(self): + return ARIA2C + + def video_settings(self): + return SETTINGS diff --git a/configs/keys/key.txt b/configs/keys/key.txt new file mode 100644 index 0000000..e69de29 diff --git a/configs/keys/netflix.keys b/configs/keys/netflix.keys new file mode 100644 index 0000000..e69de29 diff --git a/helpers/Muxer.py b/helpers/Muxer.py new file mode 100644 index 0000000..288459f --- /dev/null +++ b/helpers/Muxer.py @@ -0,0 +1,632 @@ + +import re, os, sys, subprocess, contextlib, json, glob +from configs.config import tool +from helpers.ripprocess import ripprocess +from pymediainfo import MediaInfo +import logging + + +class Muxer(object): + def __init__(self, **kwargs): + self.logger = logging.getLogger(__name__) + self.CurrentName_Original = kwargs.get("CurrentName", None) + self.CurrentName = kwargs.get("CurrentName", None) + self.SeasonFolder = kwargs.get("SeasonFolder", None) + self.CurrentHeigh = kwargs.get("CurrentHeigh", None) + self.CurrentWidth = kwargs.get("CurrentWidth", None) + self.source_tag = kwargs.get("Source", None) + self.AudioProfile = self.get_audio_id() # kwargs.get("AudioProfile", None) + self.VideoProfile = self.get_video_id() # kwargs.get("VideoProfile", None) + self.mkvmerge = tool().bin()["mkvmerge"] + self.merge = [] + self.muxer_settings = tool().muxer() + + ############################################################################## + self.packer = kwargs.get("group", None) + self.extra_output_folder = self.packer["EXTRA_FOLDER"] + self.Group = ( + self.packer["GROUP"] + if self.packer["GROUP"] + else self.muxer_settings["GROUP"] + ) + self.muxer_scheme = ( + self.packer["SCHEME"] + if self.packer["SCHEME"] + else self.muxer_settings["scheme"] + ) + + self.scheme = self.muxer_settings["schemeslist"][self.muxer_scheme] + self.Extras = self.muxer_settings["EXTRAS"] + self.fps24 = True if self.source_tag in self.muxer_settings["FPS24"] else False + self.default_mux = True if self.muxer_settings["DEFAULT"] else False + self.PrepareMuxer() + + def is_extra_folder(self): + extra_folder = None + if self.extra_output_folder: + if not os.path.isabs(self.extra_output_folder): + raise ValueError("Error you should provide full path dir: {}.".format(self.extra_output_folder)) + if not os.path.exists(self.extra_output_folder): + try: + os.makedirs(self.extra_output_folder) + except Exception as e: + raise ValueError("Error when create folder dir [{}]: {}.".format(e, self.extra_output_folder)) + extra_folder = self.extra_output_folder + return extra_folder + + if self.muxer_settings["mkv_folder"]: + if not os.path.isabs(self.muxer_settings["mkv_folder"]): + raise ValueError("Error you should provide full path dir: {}.".format(self.muxer_settings["mkv_folder"])) + if not os.path.exists(self.muxer_settings["mkv_folder"]): + try: + os.makedirs(self.muxer_settings["mkv_folder"]) + except Exception as e: + raise ValueError("Error when create folder dir [{}]: {}.".format(e, self.muxer_settings["mkv_folder"])) + extra_folder = self.muxer_settings["mkv_folder"] + return extra_folder + + return extra_folder + + def PrepareMuxer(self): + if self.muxer_settings["noTitle"]: + self.CurrentName = self.noTitle() + + extra_folder = self.is_extra_folder() + + if extra_folder: + self.SeasonFolder = extra_folder + else: + if not self.default_mux: + if self.SeasonFolder: + self.SeasonFolder = self.setFolder() + + return + + def SortFilesBySize(self): + file_list = [] + audio_tracks = ( + glob.glob(f"{self.CurrentName_Original}*.eac3") + + glob.glob(f"{self.CurrentName_Original}*.ac3") + + glob.glob(f"{self.CurrentName_Original}*.aac") + + glob.glob(f"{self.CurrentName_Original}*.m4a") + + glob.glob(f"{self.CurrentName_Original}*.dts") + ) + + if audio_tracks == []: + raise FileNotFoundError("no audio files found") + + for file in audio_tracks: + file_list.append({"file": file, "size": os.path.getsize(file)}) + + file_list = sorted(file_list, key=lambda k: int(k["size"])) + return file_list[-1]["file"] + + def GetVideoFile(self): + videofiles = [ + "{} [{}p]_Demuxed.mp4", + "{} [{}p]_Demuxed.mp4", + "{} [{}p] [UHD]_Demuxed.mp4", + "{} [{}p] [UHD]_Demuxed.mp4", + "{} [{}p] [VP9]_Demuxed.mp4", + "{} [{}p] [HIGH]_Demuxed.mp4", + "{} [{}p] [VP9]_Demuxed.mp4", + "{} [{}p] [HEVC]_Demuxed.mp4", + "{} [{}p] [HDR]_Demuxed.mp4", + "{} [{}p] [HDR-DV]_Demuxed.mp4", + ] + + for videofile in videofiles: + filename = videofile.format(self.CurrentName_Original, self.CurrentHeigh) + if os.path.isfile(filename): + return filename + + return None + + def get_video_id(self): + video_file = self.GetVideoFile() + if not video_file: + raise ValueError("No Video file in Dir...") + + media_info = MediaInfo.parse(video_file) + track = [track for track in media_info.tracks if track.track_type == "Video"][0] + + if track.format == "AVC": + if track.encoding_settings: + return "x264" + return "H.264" + elif track.format == "HEVC": + if track.commercial_name == "HDR10" and track.color_primaries: + return "HDR.HEVC" + if track.commercial_name == "HEVC" and track.color_primaries: + return "HEVC" + + return "DV.HEVC" + + return None + + def get_audio_id(self): + audio_id = None + media_info = MediaInfo.parse(self.SortFilesBySize()) + track = [track for track in media_info.tracks if track.track_type == "Audio"][0] + + if track.format == "E-AC-3": + audioCodec = "DDP" + elif track.format == "AC-3": + audioCodec = "DD" + elif track.format == "AAC": + audioCodec = "AAC" + elif track.format == "DTS": + audioCodec = "DTS" + elif "DTS" in track.format: + audioCodec = "DTS" + else: + audioCodec = "DDP" + + if track.channel_s == 8: + channels = "7.1" + elif track.channel_s == 6: + channels = "5.1" + elif track.channel_s == 2: + channels = "2.0" + elif track.channel_s == 1: + channels = "1.0" + else: + channels = "5.1" + + audio_id = ( + f"{audioCodec}{channels}.Atmos" + if "Atmos" in track.commercial_name + else f"{audioCodec}{channels}" + ) + + return audio_id + + def Heigh(self): + try: + Width = int(self.CurrentWidth) + Heigh = int(self.CurrentHeigh) + except Exception: + return self.CurrentHeigh + + res1080p = "1080p" + res720p = "720p" + sd = "" + + if Width >= 3840: + return "2160p" + + if Width >= 2560: + return "1440p" + + if Width > 1920: + if Heigh > 1440: + return "2160p" + return "1440p" + + if Width == 1920: + return res1080p + elif Width == 1280: + return res720p + + if Width >= 1400: + return res1080p + + if Width < 1400 and Width >= 1100: + return res720p + + if Heigh == 1080: + return res1080p + elif Heigh == 720: + return res720p + + if Heigh >= 900: + return res1080p + + if Heigh < 900 and Heigh >= 700: + return res720p + + return sd + + def noTitle(self): + regex = re.compile("(.*) [S]([0-9]+)[E]([0-9]+)") + if regex.search(self.CurrentName): + return regex.search(self.CurrentName).group(0) + + return self.CurrentName + + def Run(self, command): + self.logger.debug("muxing command: {}".format(command)) + + def unbuffered(proc, stream="stdout"): + newlines = ["\n", "\r\n", "\r"] + stream = getattr(proc, stream) + with contextlib.closing(stream): + while True: + out = [] + last = stream.read(1) + # Don't loop forever + if last == "" and proc.poll() is not None: + break + while last not in newlines: + # Don't loop forever + if last == "" and proc.poll() is not None: + break + out.append(last) + last = stream.read(1) + out = "".join(out) + yield out + + proc = subprocess.Popen( + command, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + bufsize=1, + universal_newlines=True, + ) + self.logger.info("\nStart Muxing...") + for line in unbuffered(proc): + if "Progress:" in line: + sys.stdout.write("\r%s" % (line)) + sys.stdout.flush() + elif "Multiplexing" in line: + sys.stdout.write("\r%s" % (line.replace("Multiplexing", "Muxing"))) + sys.stdout.flush() + elif "Error" in line: + sys.stdout.write("\r%s" % (line)) + sys.stdout.flush() + + self.logger.info("") + + def setName(self): + + outputVideo = ( + self.scheme.replace( + "{t}", ripprocess().CleanMyFileNamePlease(self.CurrentName) + ) + .replace("{r}", self.Heigh()) + .replace("{s}", self.source_tag) + .replace("{ac}", self.AudioProfile) + .replace("{vc}", self.VideoProfile) + .replace("{gr}", self.Group) + ) + + for i in range(10): + outputVideo = re.sub(r"(\.\.)", ".", outputVideo) + + if self.SeasonFolder: + outputVideo = os.path.join(os.path.abspath(self.SeasonFolder), outputVideo) + outputVideo = outputVideo.replace("\\", "/") + + return f"{outputVideo}.mkv" + + def setFolder(self): + folder = ( + self.scheme.replace( + "{t}", ripprocess().CleanMyFileNamePlease(self.SeasonFolder) + ) + .replace("{r}", self.Heigh()) + .replace("{s}", self.source_tag) + .replace("{ac}", self.AudioProfile) + .replace("{vc}", self.VideoProfile) + .replace("{gr}", self.Group) + ) + + for i in range(10): + folder = re.sub(r"(\.\.)", ".", folder) + + return folder + + def LanguageList(self): + LanguageList = [ + ["English", "eng", "eng", "English"], + ["Afrikaans", "af", "afr", "Afrikaans"], + ["Arabic", "ara", "ara", "Arabic"], + ["Arabic (Syria)", "araSy", "ara", "Arabic Syria"], + ["Arabic (Egypt)", "araEG", "ara", "Arabic Egypt"], + ["Arabic (Kuwait)", "araKW", "ara", "Arabic Kuwait"], + ["Arabic (Lebanon)", "araLB", "ara", "Arabic Lebanon"], + ["Arabic (Algeria)", "araDZ", "ara", "Arabic Algeria"], + ["Arabic (Bahrain)", "araBH", "ara", "Arabic Bahrain"], + ["Arabic (Iraq)", "araIQ", "ara", "Arabic Iraq"], + ["Arabic (Jordan)", "araJO", "ara", "Arabic Jordan"], + ["Arabic (Libya)", "araLY", "ara", "Arabic Libya"], + ["Arabic (Morocco)", "araMA", "ara", "Arabic Morocco"], + ["Arabic (Oman)", "araOM", "ara", "Arabic Oman"], + ["Arabic (Saudi Arabia)", "araSA", "ara", "Arabic Saudi Arabia"], + ["Arabic (Tunisia)", "araTN", "ara", "Arabic Tunisia"], + [ + "Arabic (United Arab Emirates)", + "araAE", + "ara", + "Arabic United Arab Emirates", + ], + ["Arabic (Yemen)", "araYE", "ara", "Arabic Yemen"], + ["Armenian", "hye", "arm", "Armenian"], + ["Assamese", "asm", "asm", "Assamese"], + ["Bengali", "ben", "ben", "Bengali"], + ["Basque", "eus", "baq", "Basque"], + ["British English", "enGB", "eng", "British English"], + ["Bulgarian", "bul", "bul", "Bulgarian"], + ["Cantonese", "None", "chi", "Cantonese"], + ["Catalan", "cat", "cat", "Catalan"], + ["Croatian", "hrv", "hrv", "Croatian"], + ["Czech", "ces", "cze", "Czech"], + ["Danish", "dan", "dan", "Danish"], + ["Dutch", "nld", "dut", "Dutch"], + ["Estonian", "est", "est", "Estonian"], + ["Filipino", "fil", "fil", "Filipino"], + ["Finnish", "fin", "fin", "Finnish"], + ["Flemish", "nlBE", "dut", "Flemish"], + ["French", "fra", "fre", "French"], + ["French Canadian", "caFra", "fre", "French Canadian"], + ["Canadian French", "caFra", "fre", "Canadian French"], + ["German", "deu", "ger", "German"], + ["Greek", "ell", "gre", "Greek"], + ["Gujarati", "guj", "guj", "Gujarati"], + ["Hebrew", "heb", "heb", "Hebrew"], + ["Hungarian", "hun", "hun", "Hungarian"], + ["Icelandic", "isl", "ice", "Icelandic"], + ["Indonesian", "ind", "ind", "Indonesian"], + ["Italian", "ita", "ita", "Italian"], + ["Japanese", "jpn", "jpn", "Japanese"], + ["Kannada (India)", "kan", "kan", "Kannada (India)"], + ["Khmer", "khm", "khm", "Khmer"], + ["Klingon", "tlh", "tlh", "Klingon"], + ["Korean", "kor", "kor", "Korean"], + ["Lithuanian", "lit", "lit", "Lithuanian"], + ["Latvian", "lav", "lav", "Latvian"], + ["Malay", "msa", "may", "Malay"], + ["Malayalam", "mal", "mal", "Malayalam"], + ["Mandarin", "None", "chi", "Mandarin"], + ["Mandarin (Putonghua)", "zho", "chi", "Mandarin (Putonghua)"], + ["Mandarin Chinese (Simplified)", "zh-Hans", "chi", "Simplified"], + ["Mandarin Chinese (Traditional)", "zh-Hant", "chi", "Traditional"], + ["Yue Chinese", "yue", "chi", "(Yue Chinese)"], + ["Manipuri", "mni", "mni", "Manipuri"], + ["Marathi", "mar", "mar", "Marathi"], + ["No Dialogue", "zxx", "zxx", "No Dialogue"], + ["Norwegian", "nor", "nor", "Norwegian"], + ["Norwegian Bokmal", "nob", "nob", "Norwegian Bokmal"], + ["Persian", "fas", "per", "Persian"], + ["Polish", "pol", "pol", "Polish"], + ["Portuguese", "por", "por", "Portuguese"], + ["Brazilian Portuguese", "brPor", "por", "Brazilian Portuguese"], + ["Punjabi", "pan", "pan", "Punjabi"], + ["Panjabi", "pan", "pan", "Panjabi"], + ["Romanian", "ron", "rum", "Romanian"], + ["Russian", "rus", "rus", "Russian"], + ["Serbian", "srp", "srp", "Serbian"], + ["Sinhala", "sin", "sin", "Sinhala"], + ["Slovak", "slk", "slo", "Slovak"], + ["Slovenian", "slv", "slv", "Slovenian"], + ["Spanish", "spa", "spa", "Spanish"], + ["European Spanish", "euSpa", "spa", "European Spanish"], + ["Swedish", "swe", "swe", "Swedish"], + ["Hindi", "hin", "hin", "Hindi"], + ["Tamil", "tam", "tam", "Tamil"], + ["Telugu", "tel", "tel", "Telugu"], + ["Thai", "tha", "tha", "Thai"], + ["Tagalog", "tgl", "tgl", "Tagalog"], + ["Turkish", "tur", "tur", "Turkish"], + ["Ukrainian", "ukr", "ukr", "Ukrainian"], + ["Urdu", "urd", "urd", "Urdu"], + ["Vietnamese", "vie", "vie", "Vietnamese"], + ["Simplified Chinese", "zhoS", "chi", "Chinese Simplified"], + ["Traditional Chinese", "zhoT", "chi", "Chinese Traditional"], + ] + + return LanguageList + + def ExtraLanguageList(self): + ExtraLanguageList = [ + ["Polish - Dubbing", "pol", "pol", "Polish - Dubbing"], + ["Polish - Lektor", "pol", "pol", "Polish - Lektor"], + ] + + return ExtraLanguageList + + def AddChapters(self): + if os.path.isfile(self.CurrentName_Original + " Chapters.txt"): + self.merge += [ + "--chapter-charset", + "UTF-8", + "--chapters", + self.CurrentName_Original + " Chapters.txt", + ] + + return + + def AddVideo(self): + inputVideo = None + + videofiles = [ + "{} [{}p]_Demuxed.mp4", + "{} [{}p]_Demuxed.mp4", + "{} [{}p] [UHD]_Demuxed.mp4", + "{} [{}p] [UHD]_Demuxed.mp4", + "{} [{}p] [VP9]_Demuxed.mp4", + "{} [{}p] [HIGH]_Demuxed.mp4", + "{} [{}p] [VP9]_Demuxed.mp4", + "{} [{}p] [HEVC]_Demuxed.mp4", + "{} [{}p] [HDR]_Demuxed.mp4", + "{} [{}p] [HDR-DV]_Demuxed.mp4", + ] + + for videofile in videofiles: + filename = videofile.format(self.CurrentName_Original, self.CurrentHeigh) + if os.path.isfile(filename): + inputVideo = filename + break + + if not inputVideo: + self.logger.info("cannot found video file.") + exit(-1) + + if self.default_mux: + outputVideo = ( + re.compile("|".join([".h264", ".h265", ".vp9", ".mp4"])).sub("", inputVideo) + + ".mkv" + ) + if self.SeasonFolder: + outputVideo = os.path.join( + os.path.abspath(self.SeasonFolder), outputVideo + ) + outputVideo = outputVideo.replace("\\", "/") + else: + outputVideo = self.setName() + + self.outputVideo = outputVideo + + if self.fps24: + self.merge += [ + self.mkvmerge, + "--output", + outputVideo, + "--default-duration", + "0:24000/1001p", + "--language", + "0:und", + "--default-track", + "0:yes", + "(", + inputVideo, + ")", + ] + else: + self.merge += [ + self.mkvmerge, + "--output", + outputVideo, + "--title", + '', + "(", + inputVideo, + ")", + ] + + return + + def AddAudio(self): + + audiofiles = [ + "{} {}.ac3", + "{} {} - Audio Description.ac3", + "{} {}.eac3", + "{} {} - Audio Description.eac3", + "{} {}.aac", + "{} {} - Audio Description.aac", + "{} {}.m4a", + "{} {} - Audio Description.m4a", + ] + + for (audio_language, subs_language, language_id, language_name,) in ( + self.LanguageList() + self.ExtraLanguageList() + ): + for audiofile in audiofiles: + filename = audiofile.format(self.CurrentName_Original, audio_language) + if os.path.isfile(filename): + self.merge += [ + "--language", + f"0:{language_id}", + "--track-name", + "0:Audio Description" if 'Audio Description' in filename + else f"0:{language_name}", + "--default-track", + "0:yes" + if subs_language == self.muxer_settings["AUDIO"] + else "0:no", + "(", + filename, + ")", + ] + + return + + def AddSubtitles(self): + + srts = [ + "{} {}.srt", + ] + forceds = [ + "{} forced-{}.srt", + ] + sdhs = [ + "{} sdh-{}.srt", + ] + + for ( + audio_language, + subs_language, + language_id, + language_name, + ) in self.LanguageList(): + for subtitle in srts: + filename = subtitle.format(self.CurrentName_Original, subs_language) + if os.path.isfile(filename): + self.merge += [ + "--language", + f"0:{language_id}", + "--track-name", + f"0:{language_name}", + "--forced-track", + "0:no", + "--default-track", + "0:yes" + if subs_language == self.muxer_settings["SUB"] + else "0:no", + "--compression", + "0:none", + "(", + filename, + ")", + ] + + for subtitle in forceds: + filename = subtitle.format(self.CurrentName_Original, subs_language) + if os.path.isfile(filename): + self.merge += [ + "--language", + f"0:{language_id}", + "--track-name", + f"0:Forced", + "--forced-track", + "0:yes", + "--default-track", + "0:no", + "--compression", + "0:none", + "(", + filename, + ")", + ] + + for subtitle in sdhs: + filename = subtitle.format(self.CurrentName_Original, subs_language) + if os.path.isfile(filename): + self.merge += [ + "--language", + f"0:{language_id}", + "--track-name", + f"0:SDH", + "--forced-track", + "0:no", + "--default-track", + "0:no", + "--compression", + "0:none", + "(", + filename, + ")", + ] + + return + + def startMux(self): + self.AddVideo() + self.AddAudio() + self.AddSubtitles() + self.AddChapters() + if not os.path.isfile(self.outputVideo): + self.Run(self.merge + self.Extras) + + return self.outputVideo \ No newline at end of file diff --git a/helpers/Parsers/Netflix/MSLClient.py b/helpers/Parsers/Netflix/MSLClient.py new file mode 100644 index 0000000..f3e940a --- /dev/null +++ b/helpers/Parsers/Netflix/MSLClient.py @@ -0,0 +1,551 @@ +import base64, binascii, json, os, re, random, requests, string, time, traceback, logging +from datetime import datetime +from Cryptodome.Cipher import AES, PKCS1_OAEP +from Cryptodome.Util import Padding +from Cryptodome.Hash import HMAC, SHA256 +from Cryptodome.PublicKey import RSA +from pywidevine.cdm import cdm, deviceconfig +from configs.config import tool + +class MSLClient: + def __init__(self, profiles=None, wv_keyexchange=True, proxies=None): + + self.session = requests.session() + self.logger = logging.getLogger(__name__) + if proxies: + self.session.proxies.update(proxies) + + self.nf_endpoints = { + "manifest": "https://www.netflix.com/nq/msl_v1/cadmium/pbo_manifests/^1.0.0/router", + "license": "https://www.netflix.com/nq/msl_v1/cadmium/pbo_licenses/^1.0.0/router", + } + + ###################################################################### + + self.config = tool().config("NETFLIX") + self.email = self.config["email"] + self.password = self.config["password"] + self.device = tool().devices()["NETFLIX-MANIFEST"] + self.save_rsa_location = self.config["token_file"] + self.languages = self.config["manifest_language"] + self.license_path = None + + ###################################################################### + + if os.path.isfile(self.save_rsa_location): + self.generatePrivateKey = RSA.importKey( + json.loads(open(self.save_rsa_location, "r").read())["RSA_KEY"] + ) + else: + self.generatePrivateKey = RSA.generate(2048) + + if wv_keyexchange: + self.wv_keyexchange = True + self.cdm = cdm.Cdm() + self.cdm_session = None + else: + self.wv_keyexchange = False + self.cdm = None + self.cdm_session = None + + self.manifest_challenge = '' # set desired wv data to overide wvexchange data + + self.profiles = profiles + + self.logger.debug("Using profiles: {}".format(self.profiles)) + + esn = self.config["androidEsn"] + if esn is None: + self.logger.error( + '\nandroid esn not found, set esn with cdm systemID in config.py' + ) + else: + self.esn = esn + + self.logger.debug("Using esn: " + self.esn) + + self.messageid = random.randint(0, 2 ** 52) + self.session_keys = {} #~ + self.header = { + "sender": self.esn, + "handshake": True, + "nonreplayable": 2, + "capabilities": {"languages": [], "compressionalgos": []}, + "recipient": "Netflix", + "renewable": True, + "messageid": self.messageid, + "timestamp": time.time(), + } + + self.setRSA() + + def get_header_extra(self): + + if self.wv_keyexchange: + self.cdm_session = self.cdm.open_session( + None, + deviceconfig.DeviceConfig(self.device), + b"\x0A\x7A\x00\x6C\x38\x2B", + True, + ) + wv_request = base64.b64encode( + self.cdm.get_license_request(self.cdm_session) + ).decode("utf-8") + + self.header["keyrequestdata"] = [ + { + "scheme": "WIDEVINE", + "keydata": { + "keyrequest": wv_request + } + } + ] + + else: + self.header["keyrequestdata"] = [ + { + "scheme": "ASYMMETRIC_WRAPPED", + "keydata": { + "publickey": base64.b64encode( + self.generatePrivateKey.publickey().exportKey("DER") + ).decode("utf8"), + "mechanism": "JWK_RSA", + "keypairid": "rsaKeypairId", + }, + } + ] + + return self.header + + def setRSA(self): + if os.path.isfile(self.save_rsa_location): + master_token = self.load_tokens() + expires = master_token["expiration"] + valid_until = datetime.utcfromtimestamp(int(expires)) + present_time = datetime.now() + + difference = valid_until - present_time + difference = difference.total_seconds() / 60 / 60 + if difference < 10: + self.logger.debug("rsa file found. expired soon") + self.session_keys["session_keys"] = self.generate_handshake() + else: + self.logger.debug("rsa file found") + self.session_keys["session_keys"] = { + "mastertoken": master_token["mastertoken"], + "sequence_number": master_token["sequence_number"], + "encryption_key": master_token["encryption_key"], + "sign_key": master_token["sign_key"], + } + else: + self.logger.debug("rsa file not found") + self.session_keys["session_keys"] = self.generate_handshake() + + def load_playlist(self, viewable_id): + + payload = { + "version": 2, + "url": "/manifest", #"/licensedManifest" + "id": int(time.time()), + "languages": self.languages, + "params": { + #"challenge": self.manifest_challenge, + "type": "standard", + "viewableId": viewable_id, + "profiles": self.profiles, + "flavor": "STANDARD", #'PRE_FETCH' + "drmType": "widevine", + "usePsshBox": True, + "useHttpsStreams": True, + "supportsPreReleasePin": True, + "supportsWatermark": True, + 'supportsUnequalizedDownloadables': True, + 'requestEligibleABTests': True, + "isBranching": False, + 'isNonMember': False, + 'isUIAutoPlay': False, + "imageSubtitleHeight": 1080, + "uiVersion": "shakti-v4bf615c3", + 'uiPlatform': 'SHAKTI', + "clientVersion": "6.0026.291.011", + 'desiredVmaf': 'plus_lts', # phone_plus_exp + "showAllSubDubTracks": True, + #"preferredTextLocale": "ar", + #"preferredAudioLocale": "ar", + #"maxSupportedLanguages": 2, + "preferAssistiveAudio": False, + "deviceSecurityLevel": "3000", + 'licenseType': 'standard', + 'titleSpecificData': { + str(viewable_id): { + 'unletterboxed': True + } + }, + "videoOutputInfo": [ + { + "type": "DigitalVideoOutputDescriptor", + "outputType": "unknown", + "supportedHdcpVersions": ['2.2'], + "isHdcpEngaged": True, + } + ], + }, + } + + request_data = self.msl_request(payload) + response = self.session.post(self.nf_endpoints["manifest"], data=request_data) + manifest = json.loads(json.dumps(self.decrypt_response(response.text))) + + if manifest.get("result"): + #with open('videoTraks.json', 'w', encoding='utf-8') as d: + #["result"]["video_tracks"] + # d.write(json.dumps(manifest, indent=2)) + self.license_path = manifest["result"]["links"]["license"]["href"] + return manifest + + if manifest.get("errormsg"): + self.logger.info(manifest["errormsg"]) + return None + else: + self.logger.info(manifest) + return None + + def decrypt_response(self, payload): + errored = False + try: + p = json.loads(payload) + if p.get("errordata"): + return json.loads(base64.b64decode(p["errordata"]).decode()) + except: + payloads = re.split( + r',"signature":"[0-9A-Za-z/+=]+"}', payload.split("}}")[1] + ) + payloads = [x + "}" for x in payloads] + new_payload = payloads[:-1] + + chunks = [] + for chunk in new_payload: + try: + payloadchunk = json.loads(chunk)["payload"] + encryption_envelope = payloadchunk + cipher = AES.new( + self.session_keys["session_keys"]["encryption_key"], + AES.MODE_CBC, + base64.b64decode( + json.loads( + base64.b64decode(encryption_envelope).decode("utf8") + )["iv"] + ), + ) + + plaintext = cipher.decrypt( + base64.b64decode( + json.loads( + base64.b64decode(encryption_envelope).decode("utf8") + )["ciphertext"] + ) + ) + + plaintext = json.loads(Padding.unpad(plaintext, 16).decode("utf8")) + + data = plaintext["data"] + data = base64.b64decode(data).decode("utf8") + chunks.append(data) + except: + continue + + decrypted_payload = "".join(chunks) + try: + return json.loads(decrypted_payload) + except: + traceback.print_exc() + self.logger.info("Unable to decrypt payloads...exiting") + exit(-1) + + def generate_handshake(self): + self.logger.debug("generate_handshake") + header = self.get_header_extra() + + request = { + "entityauthdata": { + "scheme": "NONE", + "authdata": {"identity": self.esn,} + }, + "signature": "", + "headerdata": base64.b64encode(json.dumps(header).encode("utf8")).decode("utf8"), + } + response = self.session.post( + url=self.nf_endpoints["manifest"], + json=request, + ) + try: + if response.json().get("errordata"): + self.logger.info("ERROR") + self.logger.info( + base64.b64decode(response.json()["errordata"]).decode() + ) + exit(-1) + handshake = self.parse_handshake(response=response.json()) + return handshake + except: + traceback.print_exc() + self.logger.info(response.text) + exit(-1) + + def load_tokens(self): + + with open(self.save_rsa_location, "r", encoding='utf-8') as f: + tokens_data = json.loads(f.read()) + + data = { + "mastertoken": tokens_data["mastertoken"], + "sequence_number": tokens_data["sequence_number"], + "encryption_key": base64.standard_b64decode(tokens_data["encryption_key"]), + "sign_key": base64.standard_b64decode(tokens_data["sign_key"]), + "RSA_KEY": tokens_data["RSA_KEY"], + "expiration": tokens_data["expiration"], + } + + return data + + def save_tokens(self, tokens_data): + + data = { + "mastertoken": tokens_data["mastertoken"], + "sequence_number": tokens_data["sequence_number"], + "encryption_key": base64.standard_b64encode( + tokens_data["encryption_key"] + ).decode("utf-8"), + "sign_key": base64.standard_b64encode(tokens_data["sign_key"]).decode( + "utf-8" + ), + "RSA_KEY": tokens_data["RSA_KEY"], + "expiration": tokens_data["expiration"], + } + + with open(self.save_rsa_location, 'w', encoding='utf-8') as f: + f.write(json.dumps(data, indent=2)) + + def parse_handshake(self, response): + headerdata = json.loads(base64.b64decode(response["headerdata"]).decode("utf8")) + + keyresponsedata = headerdata["keyresponsedata"] + mastertoken = headerdata["keyresponsedata"]["mastertoken"] + sequence_number = json.loads( + base64.b64decode(mastertoken["tokendata"]).decode("utf8") + )["sequencenumber"] + + if self.wv_keyexchange: + expected_scheme = "WIDEVINE" + else: + expected_scheme = "ASYMMETRIC_WRAPPED" + + scheme = keyresponsedata["scheme"] + + if scheme != expected_scheme: + self.logger.info("Key Exchange failed:") + return False + + keydata = keyresponsedata["keydata"] + + if self.wv_keyexchange: + encryption_key, sign_key = self.__process_wv_keydata(keydata) + else: + encryption_key, sign_key = self.__parse_rsa_wrapped_crypto_keys(keydata) + + tokens_data = { + "mastertoken": mastertoken, + "sequence_number": sequence_number, + "encryption_key": encryption_key, + "sign_key": sign_key, + } + + tokens_data_save = tokens_data + tokens_data_save.update( + {"RSA_KEY": self.generatePrivateKey.exportKey().decode()} + ) + tokens_data_save.update( + { + "expiration": json.loads( + base64.b64decode( + json.loads(base64.b64decode(response["headerdata"]))[ + "keyresponsedata" + ]["mastertoken"]["tokendata"] + ) + )["expiration"] + } + ) + self.save_tokens(tokens_data_save) + return tokens_data + + def __process_wv_keydata(self, keydata): + + wv_response_b64 = keydata["cdmkeyresponse"] # pass as b64 + encryptionkeyid = base64.standard_b64decode(keydata["encryptionkeyid"]) + hmackeyid = base64.standard_b64decode(keydata["hmackeyid"]) + self.cdm.provide_license(self.cdm_session, wv_response_b64) + keys = self.cdm.get_keys(self.cdm_session) + self.logger.debug("wv key exchange: obtained wv key exchange keys %s" % keys) + return ( + self.__find_wv_key(encryptionkeyid, keys, ["AllowEncrypt", "AllowDecrypt"]), + self.__find_wv_key(hmackeyid, keys, ["AllowSign", "AllowSignatureVerify"]), + ) + + def __find_wv_key(self, kid, keys, permissions): + for key in keys: + if key.kid != kid: + continue + if key.type != "OPERATOR_SESSION": + self.logger.debug( + "wv key exchange: Wrong key type (not operator session) key %s" + % key + ) + continue + + if not set(permissions) <= set(key.permissions): + self.logger.debug( + "wv key exchange: Incorrect permissions, key %s, needed perms %s" + % (key, permissions) + ) + continue + return key.key + + return None + + def __parse_rsa_wrapped_crypto_keys(self, keydata): + # Init Decryption + encrypted_encryption_key = base64.b64decode(keydata["encryptionkey"]) + + encrypted_sign_key = base64.b64decode(keydata["hmackey"]) + + oaep_cipher = PKCS1_OAEP.new(self.generatePrivateKey) + encryption_key_data = json.loads( + oaep_cipher.decrypt(encrypted_encryption_key).decode("utf8") + ) + + encryption_key = self.base64_check(encryption_key_data["k"]) + + sign_key_data = json.loads( + oaep_cipher.decrypt(encrypted_sign_key).decode("utf8") + ) + + sign_key = self.base64_check(sign_key_data["k"]) + return (encryption_key, sign_key) + + def base64key_decode(self, payload): + l = len(payload) % 4 + if l == 2: + payload += "==" + elif l == 3: + payload += "=" + elif l != 0: + raise ValueError("Invalid base64 string") + return base64.urlsafe_b64decode(payload.encode("utf-8")) + + def base64_check(self, string): + + while len(string) % 4 != 0: + string = string + "=" + return base64.urlsafe_b64decode(string.encode()) + + def msl_request(self, data, is_handshake=False): + + header = self.header.copy() + header["handshake"] = is_handshake + header["userauthdata"] = { + "scheme": "EMAIL_PASSWORD", + "authdata": {"email": self.email, "password": self.password}, + } + + header_envelope = self.msl_encrypt(self.session_keys, json.dumps(header)) + + header_signature = HMAC.new( + self.session_keys["session_keys"]["sign_key"], header_envelope, SHA256 + ).digest() + + encrypted_header = { + "headerdata": base64.b64encode(header_envelope).decode("utf8"), + "signature": base64.b64encode(header_signature).decode("utf8"), + "mastertoken": self.session_keys["session_keys"]["mastertoken"], + } + + payload = { + "messageid": self.messageid, + "data": base64.b64encode(json.dumps(data).encode()).decode("utf8"), + "sequencenumber": 1, + "endofmsg": True, + } + + payload_envelope = self.msl_encrypt(self.session_keys, json.dumps(payload)) + + payload_signature = HMAC.new( + self.session_keys["session_keys"]["sign_key"], payload_envelope, SHA256 + ).digest() + + payload_chunk = { + "payload": base64.b64encode(payload_envelope).decode("utf8"), + "signature": base64.b64encode(payload_signature).decode("utf8"), + } + return json.dumps(encrypted_header) + json.dumps(payload_chunk) + + def msl_encrypt(self, msl_session, plaintext): + + cbc_iv = os.urandom(16) + encryption_envelope = { + "keyid": "%s_%s" + % (self.esn, msl_session["session_keys"]["sequence_number"]), + "sha256": "AA==", + "iv": base64.b64encode(cbc_iv).decode("utf8"), + } + + plaintext = Padding.pad(plaintext.encode("utf8"), 16) + cipher = AES.new( + msl_session["session_keys"]["encryption_key"], AES.MODE_CBC, cbc_iv + ) + + ciphertext = cipher.encrypt(plaintext) + + encryption_envelope["ciphertext"] = base64.b64encode(ciphertext).decode("utf8") + + return json.dumps(encryption_envelope).encode("utf8") + + def get_license(self, challenge, session_id): + + if not isinstance(challenge, bytes): + raise TypeError("challenge must be of type bytes") + + if not isinstance(session_id, str): + raise TypeError("session_id must be of type string") + + timestamp = int(time.time() * 10000) + + license_request_data = { + "version": 2, + "url": self.license_path, + "id": timestamp, + "languages": "en_US", + "echo": "drmsessionId", + "params": [ + { + "drmSessionId": session_id, + "clientTime": int(timestamp / 10000), + "challengeBase64": base64.b64encode(challenge).decode("utf8"), + "xid": str(timestamp + 1610), + } + ] + } + + request_data = self.msl_request(license_request_data) + + resp = self.session.post(url=self.nf_endpoints["license"],data=request_data) + + try: + resp.json() + + except ValueError: + msl_license_data = json.loads(json.dumps(self.decrypt_response(resp.text))) + if msl_license_data.get("result"): + return msl_license_data + if msl_license_data.get("errormsg"): + raise ValueError(msl_license_data["errormsg"]) + raise ValueError(msl_license_data) diff --git a/helpers/Parsers/Netflix/get_keys.py b/helpers/Parsers/Netflix/get_keys.py new file mode 100644 index 0000000..837ca3b --- /dev/null +++ b/helpers/Parsers/Netflix/get_keys.py @@ -0,0 +1,162 @@ +import time, os, json, logging, base64 +from helpers.Parsers.Netflix.MSLClient import MSLClient +from configs.config import tool +from pywidevine.decrypt.wvdecryptcustom import WvDecrypt + +logger = logging.getLogger(__name__) + +''' "av1-main-L20-dash-cbcs-prk", + "av1-main-L21-dash-cbcs-prk", + "av1-main-L30-dash-cbcs-prk", + "av1-main-L31-dash-cbcs-prk", + "av1-main-L40-dash-cbcs-prk", + "av1-main-L41-dash-cbcs-prk", + "av1-main-L50-dash-cbcs-prk", + "av1-main-L51-dash-cbcs-prk",''' + +''' "vp9-profile0-L21-dash-cenc", + "vp9-profile0-L30-dash-cenc", + "vp9-profile0-L31-dash-cenc", + "vp9-profile0-L40-dash-cenc", + "vp9-profile2-L30-dash-cenc-prk", + "vp9-profile2-L31-dash-cenc-prk", + "vp9-profile2-L40-dash-cenc-prk", + "vp9-profile2-L50-dash-cenc-prk", + "vp9-profile2-L51-dash-cenc-prk"''' + +def from_kid(kid): + array_of_bytes = bytearray(b"\x00\x00\x002pssh\x00\x00\x00\x00") + array_of_bytes.extend(bytes.fromhex("edef8ba979d64acea3c827dcd51d21ed")) + array_of_bytes.extend(b"\x00\x00\x00\x12\x12\x10") + array_of_bytes.extend(bytes.fromhex(kid.replace("-", ""))) + pssh = base64.b64encode(bytes.fromhex(array_of_bytes.hex())) + return pssh.decode() + +def __profiles(profile, addHEVCDO=False): + + profiles = [ + "heaac-2-dash", + "dfxp-ls-sdh", + "webvtt-lssdh-ios8", + "BIF240", + "BIF320", + ] + + if profile == "High KEYS": + profiles += [ + "playready-h264hpl22-dash", + "playready-h264hpl30-dash", + "playready-h264hpl31-dash", + #'playready-h264hpl40-dash' + ] + + elif profile == "Main KEYS": + profiles += [ + "playready-h264bpl30-dash", + "playready-h264mpl30-dash", + "playready-h264mpl31-dash", + "playready-h264mpl40-dash", + ] + + elif profile == "HEVC KEYS": + profiles += [ + "hevc-main-L30-dash-cenc", + "hevc-main10-L30-dash-cenc", + "hevc-main10-L30-dash-cenc-prk", + "hevc-main-L31-dash-cenc" + "hevc-main10-L31-dash-cenc", + "hevc-main10-L31-dash-cenc-prk", + "hevc-main-L40-dash-cenc", + "hevc-main10-L40-dash-cenc", + "hevc-main10-L40-dash-cenc-prk", + "hevc-main-L41-dash-cenc", + "hevc-main10-L41-dash-cenc", + "hevc-main10-L41-dash-cenc-prk" + ] + if addHEVCDO: + profiles += [ + "hevc-main10-L31-dash-cenc-prk-do", + "hevc-main10-L31-dash-cenc-prk-do", + "hevc-main10-L40-dash-cenc-prk-do", + "hevc-main10-L41-dash-cenc-prk-do", + ] + + elif profile == 'HDR-10 KEYS': + profiles += [ + "hevc-hdr-main10-L30-dash-cenc", + "hevc-hdr-main10-L30-dash-cenc-prk", + "hevc-hdr-main10-L31-dash-cenc", + "hevc-hdr-main10-L31-dash-cenc-prk", + "hevc-hdr-main10-L40-dash-cenc", + "hevc-hdr-main10-L41-dash-cenc", + "hevc-hdr-main10-L40-dash-cenc-prk", + "hevc-hdr-main10-L41-dash-cenc-prk" + ] + else: + profiles += [ + "playready-h264mpl30-dash", + ] + + return profiles + +def GettingKEYS_Netflixv2(nfID, profile): # + + KEYS = [] + + available_profiles = [ + "High KEYS", + "HEVC KEYS", + "HDR-10 KEYS", + "Main KEYS" + ] + + if not profile in available_profiles: + logger.info("Error: Unknown profile: {}".format(profile)) + exit(1) + + logger.info(f"\nGetting {profile}...") + + profiles = __profiles(profile) + + try: + client = MSLClient(profiles=profiles) + resp = client.load_playlist(int(nfID)) + if resp is None: + if profile == 'HEVC KEYS': + profiles = __profiles(profile, addHEVCDO=True) + client = MSLClient(profiles=profiles) + resp = client.load_playlist(int(nfID)) + + except Exception as e: + logger.error("Manifest Error: {}".format(e)) + return KEYS + + try: + #init_data_b64 = from_kid('0000000005edabd50000000000000000') + init_data_b64 = resp["result"]["video_tracks"][0]["drmHeader"]["bytes"] + except KeyError: + logger.error("cannot get pssh, {}".format(resp)) + return KEYS + + cert_data_b64 = "CAUSwwUKvQIIAxIQ5US6QAvBDzfTtjb4tU/7QxiH8c+TBSKOAjCCAQoCggEBAObzvlu2hZRsapAPx4Aa4GUZj4/GjxgXUtBH4THSkM40x63wQeyVxlEEo1D/T1FkVM/S+tiKbJiIGaT0Yb5LTAHcJEhODB40TXlwPfcxBjJLfOkF3jP6wIlqbb6OPVkDi6KMTZ3EYL6BEFGfD1ag/LDsPxG6EZIn3k4S3ODcej6YSzG4TnGD0szj5m6uj/2azPZsWAlSNBRUejmP6Tiota7g5u6AWZz0MsgCiEvnxRHmTRee+LO6U4dswzF3Odr2XBPD/hIAtp0RX8JlcGazBS0GABMMo2qNfCiSiGdyl2xZJq4fq99LoVfCLNChkn1N2NIYLrStQHa35pgObvhwi7ECAwEAAToQdGVzdC5uZXRmbGl4LmNvbRKAA4TTLzJbDZaKfozb9vDv5qpW5A/DNL9gbnJJi/AIZB3QOW2veGmKT3xaKNQ4NSvo/EyfVlhc4ujd4QPrFgYztGLNrxeyRF0J8XzGOPsvv9Mc9uLHKfiZQuy21KZYWF7HNedJ4qpAe6gqZ6uq7Se7f2JbelzENX8rsTpppKvkgPRIKLspFwv0EJQLPWD1zjew2PjoGEwJYlKbSbHVcUNygplaGmPkUCBThDh7p/5Lx5ff2d/oPpIlFvhqntmfOfumt4i+ZL3fFaObvkjpQFVAajqmfipY0KAtiUYYJAJSbm2DnrqP7+DmO9hmRMm9uJkXC2MxbmeNtJHAHdbgKsqjLHDiqwk1JplFMoC9KNMp2pUNdX9TkcrtJoEDqIn3zX9p+itdt3a9mVFc7/ZL4xpraYdQvOwP5LmXj9galK3s+eQJ7bkX6cCi+2X+iBmCMx4R0XJ3/1gxiM5LiStibCnfInub1nNgJDojxFA3jH/IuUcblEf/5Y0s1SzokBnR8V0KbA==" + + device = tool().devices()["NETFLIX-LICENSE"] + + wvdecrypt = WvDecrypt( + init_data_b64=init_data_b64, cert_data_b64=cert_data_b64, device=device + ) + challenge = wvdecrypt.get_challenge() + current_sessionId = str(time.time()).replace(".", "")[0:-2] + data = client.get_license(challenge, current_sessionId) + + try: + license_b64 = data["result"][0]["licenseResponseBase64"] + except Exception: + logger.error("MSL LICENSE Error Message: {}".format(data)) + return KEYS + + wvdecrypt.update_license(license_b64) + Correct, keyswvdecrypt = wvdecrypt.start_process() + KEYS = keyswvdecrypt + + return KEYS diff --git a/helpers/Parsers/Netflix/get_manifest.py b/helpers/Parsers/Netflix/get_manifest.py new file mode 100644 index 0000000..61d5b38 --- /dev/null +++ b/helpers/Parsers/Netflix/get_manifest.py @@ -0,0 +1,736 @@ +from helpers.ripprocess import ripprocess +from helpers.Parsers.Netflix.MSLClient import MSLClient +from configs.config import tool +import re, os, json, logging + +def MSLprofiles(): + PROFILES = { + "BASICS": ["BIF240", "BIF320", "webvtt-lssdh-ios8", "dfxp-ls-sdh"], + "MAIN": { + "SD": [ + "playready-h264bpl30-dash", + "playready-h264mpl22-dash", + "playready-h264mpl30-dash", + ], + "HD": [ + "playready-h264bpl30-dash", + "playready-h264mpl22-dash", + "playready-h264mpl30-dash", + "playready-h264mpl31-dash", + ], + "FHD": [ + "playready-h264bpl30-dash", + "playready-h264mpl22-dash", + "playready-h264mpl30-dash", + "playready-h264mpl31-dash", + "playready-h264mpl40-dash", + ], + "ALL": [ + "playready-h264bpl30-dash", + "playready-h264mpl22-dash", + "playready-h264mpl30-dash", + "playready-h264mpl31-dash", + "playready-h264mpl40-dash", + ], + }, + "HIGH": { + "SD": [ + "playready-h264hpl22-dash", + "playready-h264hpl30-dash", + ], + "HD": [ + "playready-h264hpl22-dash", + "playready-h264hpl30-dash", + "playready-h264hpl31-dash", + ], + "FHD": [ + "playready-h264hpl22-dash", + "playready-h264hpl30-dash", + "playready-h264hpl31-dash", + "playready-h264hpl40-dash", + ], + "ALL": [ + "playready-h264hpl22-dash", + "playready-h264hpl30-dash", + "playready-h264hpl31-dash", + "playready-h264hpl40-dash", + ], + }, + "HEVC": { + "SD": [ + "hevc-main-L30-dash-cenc", + "hevc-main10-L30-dash-cenc", + "hevc-main10-L30-dash-cenc-prk", + ], + "HD": [ + "hevc-main-L30-dash-cenc", + "hevc-main10-L30-dash-cenc", + "hevc-main10-L30-dash-cenc-prk", + "hevc-main-L31-dash-cenc", + "hevc-main10-L31-dash-cenc", + "hevc-main10-L31-dash-cenc-prk", + ], + "FHD": [ + "hevc-main-L30-dash-cenc", + "hevc-main10-L30-dash-cenc", + "hevc-main10-L30-dash-cenc-prk", + "hevc-main-L31-dash-cenc" + "hevc-main10-L31-dash-cenc", + "hevc-main10-L31-dash-cenc-prk", + "hevc-main-L40-dash-cenc", + "hevc-main10-L40-dash-cenc", + "hevc-main10-L40-dash-cenc-prk", + "hevc-main-L41-dash-cenc", + "hevc-main10-L41-dash-cenc", + "hevc-main10-L41-dash-cenc-prk", + ], + "ALL": [ + "hevc-main-L30-dash-cenc", + "hevc-main10-L30-dash-cenc", + "hevc-main10-L30-dash-cenc-prk", + "hevc-main-L31-dash-cenc" + "hevc-main10-L31-dash-cenc", + "hevc-main10-L31-dash-cenc-prk", + "hevc-main-L40-dash-cenc", + "hevc-main10-L40-dash-cenc", + "hevc-main10-L40-dash-cenc-prk", + "hevc-main-L41-dash-cenc", + "hevc-main10-L41-dash-cenc", + "hevc-main10-L41-dash-cenc-prk", + ], + }, + "HEVCDO": { + "SD": [ + "hevc-main10-L30-dash-cenc-prk-do", + ], + "HD": [ + "hevc-main10-L30-dash-cenc-prk-do", + "hevc-main10-L31-dash-cenc-prk-do" + ], + "FHD": [ + "hevc-main10-L31-dash-cenc-prk-do", + "hevc-main10-L31-dash-cenc-prk-do", + "hevc-main10-L40-dash-cenc-prk-do", + "hevc-main10-L41-dash-cenc-prk-do", + ], + "ALL": [ + "hevc-main10-L31-dash-cenc-prk-do", + "hevc-main10-L31-dash-cenc-prk-do", + "hevc-main10-L40-dash-cenc-prk-do", + "hevc-main10-L41-dash-cenc-prk-do", + ], + }, + "HDR": { + "SD": [ + "hevc-hdr-main10-L30-dash-cenc", + "hevc-hdr-main10-L30-dash-cenc-prk", + ], + "HD": [ + "hevc-hdr-main10-L30-dash-cenc", + "hevc-hdr-main10-L30-dash-cenc-prk", + "hevc-hdr-main10-L31-dash-cenc", + "hevc-hdr-main10-L31-dash-cenc-prk", + ], + "FHD": [ + "hevc-hdr-main10-L30-dash-cenc", + "hevc-hdr-main10-L30-dash-cenc-prk", + "hevc-hdr-main10-L31-dash-cenc", + "hevc-hdr-main10-L31-dash-cenc-prk", + "hevc-hdr-main10-L40-dash-cenc", + "hevc-hdr-main10-L41-dash-cenc", + "hevc-hdr-main10-L40-dash-cenc-prk", + "hevc-hdr-main10-L41-dash-cenc-prk", + ], + "ALL": [ + "hevc-hdr-main10-L30-dash-cenc", + "hevc-hdr-main10-L30-dash-cenc-prk", + "hevc-hdr-main10-L31-dash-cenc", + "hevc-hdr-main10-L31-dash-cenc-prk", + "hevc-hdr-main10-L40-dash-cenc", + "hevc-hdr-main10-L41-dash-cenc", + "hevc-hdr-main10-L40-dash-cenc-prk", + "hevc-hdr-main10-L41-dash-cenc-prk", + ], + }, + } + + return PROFILES + +class get_manifest: + + def __init__(self, args, nfid): + self.logger = logging.getLogger(__name__) + self.args = args + self.nfid = nfid + self.ripprocess = ripprocess() + self.profiles = MSLprofiles() + self.config = tool().config("NETFLIX") + + def LoadProfies(self, addHEVCDO=False): + getHigh = False + profiles = self.profiles["BASICS"] + + if self.args.video_main: + if self.args.customquality: + if int(self.args.customquality[0]) == 1080: + profiles += self.profiles["MAIN"]["FHD"] + elif ( + int(self.args.customquality[0]) < 1080 + and int(self.args.customquality[0]) >= 720 + ): + profiles += self.profiles["MAIN"]["HD"] + elif int(self.args.customquality[0]) < 720: + profiles += self.profiles["MAIN"]["SD"] + else: + profiles += self.profiles["MAIN"]["ALL"] + else: + if self.args.video_high: + if self.args.customquality: + if int(self.args.customquality[0]) == 1080: + profiles += self.profiles["HIGH"]["FHD"] + elif ( + int(self.args.customquality[0]) < 1080 + and int(self.args.customquality[0]) >= 720 + ): + profiles += self.profiles["HIGH"]["HD"] + elif int(self.args.customquality[0]) < 720: + profiles += self.profiles["HIGH"]["SD"] + else: + profiles += self.profiles["HIGH"]["ALL"] + else: + if self.args.hdr: + if self.args.customquality: + if int(self.args.customquality[0]) == 1080: + profiles += self.profiles["HDR"]["FHD"] + elif ( + int(self.args.customquality[0]) < 1080 + and int(self.args.customquality[0]) >= 720 + ): + profiles += self.profiles["HDR"]["HD"] + elif int(self.args.customquality[0]) < 720: + profiles += self.profiles["HDR"]["SD"] + else: + profiles += self.profiles["HDR"]["ALL"] + + elif self.args.hevc: + if self.args.customquality: + if int(self.args.customquality[0]) == 1080: + profiles += self.profiles["HEVC"]["FHD"] + if addHEVCDO: + profiles += self.profiles['HEVCDO']['FHD'] + elif ( + int(self.args.customquality[0]) < 1080 + and int(self.args.customquality[0]) >= 720 + ): + profiles += self.profiles["HEVC"]["HD"] + if addHEVCDO: + profiles += self.profiles['HEVCDO']['HD'] + elif int(self.args.customquality[0]) < 720: + profiles += self.profiles["HEVC"]["SD"] + if addHEVCDO: + profiles += self.profiles['HEVCDO']['SD'] + else: + profiles += self.profiles["HEVC"]["ALL"] + if addHEVCDO: + profiles += self.profiles['HEVCDO']['ALL'] + + else: + getHigh = True + if self.args.customquality: + if int(self.args.customquality[0]) == 1080: + profiles += self.profiles["MAIN"]["FHD"] + elif ( + int(self.args.customquality[0]) < 1080 + and int(self.args.customquality[0]) >= 720 + ): + profiles += self.profiles["MAIN"]["HD"] + elif int(self.args.customquality[0]) < 720: + profiles += self.profiles["MAIN"]["SD"] + else: + profiles += self.profiles["MAIN"]["ALL"] + + if self.args.aformat_2ch: + if str(self.args.aformat_2ch[0]) == "aac": + profiles.append("heaac-2-dash") + profiles.append("heaac-2hq-dash") + elif str(self.args.aformat_2ch[0]) == "eac3": + profiles.append("ddplus-2.0-dash") + elif str(self.args.aformat_2ch[0]) == "ogg": + profiles.append("playready-oggvorbis-2-dash") + else: + if self.args.only_2ch_audio: + profiles.append("ddplus-2.0-dash") + else: + if self.args.aformat_51ch: + if str(self.args.aformat_51ch[0]) == "aac": + profiles.append("heaac-5.1-dash") + profiles.append("heaac-5.1hq-dash") + elif str(self.args.aformat_51ch[0]) == "eac3": + profiles.append("ddplus-5.1-dash") + profiles.append("ddplus-5.1hq-dash") + elif str(self.args.aformat_51ch[0]) == "ac3": + profiles.append("dd-5.1-dash") + elif str(self.args.aformat_51ch[0]) == "atmos": + profiles.append("dd-5.1-dash") + profiles.append("ddplus-atmos-dash") + else: + profiles.append("dd-5.1-dash") + profiles.append("ddplus-5.1-dash") + profiles.append("ddplus-5.1hq-dash") + else: + profiles.append("ddplus-2.0-dash") + profiles.append("dd-5.1-dash") + profiles.append("ddplus-5.1-dash") + profiles.append("ddplus-5.1hq-dash") + profiles.append("ddplus-atmos-dash") + + return list(set(profiles)), getHigh + + def PyMSL(self, profiles): + + client = MSLClient(profiles=profiles) + + try: + resp = client.load_playlist(int(self.nfid)) + return resp + + except Exception as e: + self.logger.error("Manifest Error: {}".format(e)) + + return None + + def HighVideoMSL(self): + # for bitrate compare with main ~ + + self.logger.info("Getting High Profile Manifest...") + + profiles = self.profiles["BASICS"] + + if self.args.customquality: + if int(self.args.customquality[0]) == 1080: + profiles += self.profiles["HIGH"]["FHD"] + elif ( + int(self.args.customquality[0]) < 1080 + and int(self.args.customquality[0]) >= 720 + ): + profiles += self.profiles["HIGH"]["HD"] + elif int(self.args.customquality[0]) < 720: + profiles += self.profiles["HIGH"]["SD"] + else: + profiles += self.profiles["HIGH"]["ALL"] + + resp = self.PyMSL(profiles=profiles) + + VideoList = list() + + manifest = resp["result"] + + for video_track in manifest["video_tracks"]: + for downloadable in video_track["streams"]: + size_in_bytes = int(float(downloadable["size"])) + vid_size = ( + f"{size_in_bytes/1048576:0.2f} MiB" + if size_in_bytes < 1073741824 + else f"{size_in_bytes/1073741824:0.2f} GiB" + ) + vid_url = downloadable["urls"][0]["url"] + L3 = 'L3' if 'SEGMENT_MAP_2KEY' in str(downloadable['tags']) else '' # + + VideoList.append( + { + "Type": "video", + "Drm": downloadable["isDrm"], + "vmaf": downloadable["vmaf"], + "FrameRate": downloadable["framerate_value"], + "Height": downloadable["res_h"], + "Width": downloadable["res_w"], + "Size": vid_size, + "Url": vid_url, + "Bitrate": str(downloadable["bitrate"]), + "Profile": downloadable["content_profile"], + "L3": L3 # + } + ) + + VideoList = sorted(VideoList, key=lambda k: int(k["Bitrate"])) + + if self.args.customquality: + inp_height = int(self.args.customquality[0]) + top_height = sorted(VideoList, key=lambda k: int(k["Height"]))[-1]["Height"] + + if top_height >= inp_height: + height = [x for x in VideoList if int(x["Height"]) >= inp_height] + if not height == []: + VideoList = height + + return VideoList + + def ParseVideo(self, resp, getHigh): + manifest = resp["result"] + VideoList = [] + checkerinfo = "" + + for video_track in manifest["video_tracks"]: + for downloadable in video_track["streams"]: + size_in_bytes = int(float(downloadable["size"])) + vid_size = ( + f"{size_in_bytes/1048576:0.2f} MiB" + if size_in_bytes < 1073741824 + else f"{size_in_bytes/1073741824:0.2f} GiB" + ) + vid_url = downloadable["urls"][0]["url"] + + VideoList.append( + { + "Type": "video", + "Drm": downloadable["isDrm"], + "vmaf": downloadable["vmaf"], + "FrameRate": downloadable["framerate_value"], + "Height": downloadable["res_h"], + "Width": downloadable["res_w"], + "Size": vid_size, + "Url": vid_url, + "Bitrate": str(downloadable["bitrate"]), + "Profile": downloadable["content_profile"], + } + ) + + VideoList = sorted(VideoList, key=lambda k: int(k["Bitrate"])) + self.logger.debug("VideoList: {}".format(VideoList)) + + if self.args.customquality: + inp_height = int(self.args.customquality[0]) + top_height = sorted(VideoList, key=lambda k: int(k["Height"]))[-1]["Height"] + + if top_height >= inp_height: + height = [x for x in VideoList if int(x["Height"]) >= inp_height] + if not height == []: + VideoList = height + + if getHigh: + HighVideoList = self.HighVideoMSL() + if not HighVideoList == []: + checkerinfo = "\nNetflix Profile Checker v1.0\nMAIN: {}kbps | {}\nHIGH: {}kbps | {}\n\n{}\n" + checkerinfo = checkerinfo.format( + str(dict(VideoList[-1])["Bitrate"]), + str(dict(VideoList[-1])["Profile"]), + str(dict(HighVideoList[-1])["Bitrate"]), + str(dict(HighVideoList[-1])["Profile"]), + "result: MAIN is Better" + if int(dict(VideoList[-1])["Bitrate"]) + >= int(dict(HighVideoList[-1])["Bitrate"]) + else "result: HIGH is Better", + ) + + VideoList += HighVideoList + self.logger.debug("HighVideoList: {}".format(HighVideoList)) + + VideoList = sorted(VideoList, key=lambda k: int(k["Bitrate"])) + + return VideoList, checkerinfo + + def ParseAudioSubs(self, resp): + + def remove_dups(List, keyword=""): + # function to remove all dups based on list items ~ + Added_ = set() + Proper_ = [] + for L in List: + if L[keyword] not in Added_: + Proper_.append(L) + Added_.add(L[keyword]) + + return Proper_ + + def isOriginal(language_text): + # function to detect the original audio ~ + if "Original" in language_text: + return True + + brackets = re.search(r"\[(.*)\]", language_text) + if brackets: + return True + + return False + + def noOriginal(language_text): + # function to remove (original) from audio language to be detected in --alang ~ + brackets = re.search(r"\[(.*)\]", language_text) + if brackets: + return language_text.replace(brackets[0], "").strip() + + return language_text + + # start audio, subs parsing ~ + + manifest = resp["result"] + + AudioList, SubtitleList, ForcedList = list(), list(), list() + + # parse audios and return all (AD, non AD) as a list + for audio_track in manifest["audio_tracks"]: + AudioDescription = 'Audio Description' if "audio description" in \ + audio_track["languageDescription"].lower() else 'Audio' + Original = isOriginal(audio_track["languageDescription"]) + LanguageName, LanguageCode = self.ripprocess.countrycode( + audio_track["language"] + ) + LanguageName = noOriginal(audio_track["languageDescription"]) + + for downloadable in audio_track["streams"]: + aud_url = downloadable["urls"][0]["url"] + size = ( + str(format(float(int(downloadable["size"])) / 1058816, ".2f")) + + " MiB" + ) + + audioDict = { + "Type": AudioDescription, + "Drm": downloadable["isDrm"], + "Original": Original, + "Language": LanguageName, + "langAbbrev": LanguageCode, + "Size": size, + "Url": aud_url, + "channels": str(downloadable["channels"]), + "Bitrate": str(downloadable["bitrate"]), + "Profile": downloadable["content_profile"], + } + + if self.args.custom_audio_bitrate: + # only append the audio langs with the given bitrate + if int(downloadable["bitrate"]) <= \ + int(self.args.custom_audio_bitrate[0]): + AudioList.append(audioDict) + else: + AudioList.append(audioDict) + + AudioList = sorted(AudioList, key=lambda k: int(k["Bitrate"]), reverse=True) + + self.logger.debug("AudioList: {}".format(AudioList)) + + ################################################################################# + + AudioList = sorted( # keep only highest bitrate for every language + remove_dups(AudioList, keyword="Language"), + key=lambda k: int(k["Bitrate"]), + reverse=True, + ) + + OriginalAudioList = ( # for detect automatically forced subs ~ + AudioList + if len(AudioList) == 1 + else [x for x in AudioList if x["Original"]] + ) + + ################################################################################# + + # now parser AudioList based on user input to + # --alang X X --AD X X or original if none + + if self.args.AD: + ADlist = list() + UserLanguagesLower = list(map(lambda x: x.lower(), self.args.AD)) + for aud in AudioList: + if aud['Type'] == 'Audio': + if self.args.allaudios: + ADlist.append(aud) + else: + if aud["Original"]: + ADlist.append(aud) + + if aud['Type'] == 'Audio Description': + if ( + aud["Language"].lower() in UserLanguagesLower + or aud["langAbbrev"].lower() in UserLanguagesLower + ): + ADlist.append(aud) + + AudioList = ADlist + + if self.args.audiolang: + NewAudioList = list() + UserLanguagesLower = list(map(lambda x: x.lower(), self.args.audiolang)) + for aud in AudioList: + if self.args.AD: + # I already have AD langs parsed + if aud['Type'] == 'Audio Description': + NewAudioList.append(aud) + if aud['Type'] == 'Audio': + if ( + aud["Language"].lower() in UserLanguagesLower + or aud["langAbbrev"].lower() in UserLanguagesLower + ): + NewAudioList.append(aud) + + AudioList = NewAudioList + + else: + # so I know have the complete Audiolist + if self.args.allaudios: # remove AD tracks if not --AD X X + AllaudiosList = list() + if self.args.AD: + for aud in AudioList: + AllaudiosList.append(aud) + AudioList = AllaudiosList + else: + for aud in AudioList: + if aud['Type'] == 'Audio': + AllaudiosList.append(aud) + AudioList.clear() + AudioList = AllaudiosList + + else: + if self.args.AD: + AudioList = AudioList # I mean the ADlist + else: + # I mean no audio options are given, so we go with the original + AudioList = [x for x in AudioList if x["Original"] or len(AudioList) == 1] + + #####################################(Subtitles)##################################### + + for text_track in manifest["timedtexttracks"]: + if ( + not text_track["languageDescription"] == "Off" + and text_track["language"] is not None + ): + Language, langAbbrev = self.ripprocess.countrycode( + text_track["language"] + ) + Language = text_track["languageDescription"] + Type = text_track["trackType"] + rawTrackType = ( + text_track["rawTrackType"] + .replace("closedcaptions", "CC") + .replace("subtitles", "SUB") + ) + isForced = "NO" + + if ( + "CC" in rawTrackType + and langAbbrev != "ara" + and "dfxp-ls-sdh" in str(text_track["ttDownloadables"]) + ): + Profile = "dfxp-ls-sdh" + Url = next( + iter( + text_track["ttDownloadables"]["dfxp-ls-sdh"][ + "downloadUrls" + ].values() + ) + ) + else: + Profile = "webvtt-lssdh-ios8" + Url = next( + iter( + text_track["ttDownloadables"]["webvtt-lssdh-ios8"][ + "downloadUrls" + ].values() + ) + ) + + SubtitleList.append( + { + "Type": Type, + "rawTrackType": rawTrackType, + "Language": Language, + "isForced": isForced, + "langAbbrev": langAbbrev, + "Url": Url, + "Profile": Profile, + } + ) + + self.logger.debug("SubtitleList: {}".format(SubtitleList)) + SubtitleList = remove_dups(SubtitleList, keyword="Language") + + if self.args.sublang: + NewSubtitleList = list() + UserLanguagesLower = list(map(lambda x: x.lower(), self.args.sublang)) + for sub in SubtitleList: + if ( + sub["Language"].lower() in UserLanguagesLower + or sub["langAbbrev"].lower() in UserLanguagesLower + ): + NewSubtitleList.append(sub) + SubtitleList = remove_dups(NewSubtitleList, keyword="Language") + + #####################################(Forced Subtitles)############################### + + for text_track in manifest["timedtexttracks"]: + if text_track["isForcedNarrative"] and text_track["language"] is not None: + LanguageName, LanguageCode = self.ripprocess.countrycode( + text_track["language"] + ) + # LanguageName = text_track["languageDescription"] # no i will use pycountry instead bcs it's off dude. + ForcedList.append( + { + "Type": text_track["trackType"], + "rawTrackType": text_track["rawTrackType"] + .replace("closedcaptions", "CC ") + .replace("subtitles", "SUB"), + "Language": LanguageName, + "isForced": "YES", + "langAbbrev": LanguageCode, + "Url": next( + iter( + text_track["ttDownloadables"]["webvtt-lssdh-ios8"][ + "downloadUrls" + ].values() + ) + ), + "Profile": "webvtt-lssdh-ios8", + } + ) + + ForcedList = remove_dups(ForcedList, keyword="Language") + + if self.args.forcedlang: + NewForcedList = [] + UserLanguagesLower = list(map(lambda x: x.lower(), self.args.forcedlang)) + for sub in ForcedList: + if ( + sub["Language"].lower() in UserLanguagesLower + or sub["langAbbrev"].lower() in UserLanguagesLower + ): + NewForcedList.append(sub) + ForcedList = remove_dups(NewForcedList, keyword="Language") + else: + if not self.args.allforcedlang: + if len(OriginalAudioList) != 0: + OriginalLanguage = OriginalAudioList[0]["langAbbrev"] + ForcedList = [ + x for x in ForcedList if x["langAbbrev"] == OriginalLanguage + ] + + return AudioList, SubtitleList, ForcedList + + def LoadManifest(self): + + profiles, getHigh = self.LoadProfies() + + if self.args.hevc: + self.logger.info("Getting HEVC Manifest...") + elif self.args.hdr: + self.logger.info("Getting HDR-10 Manifest...") + elif self.args.video_high: + self.logger.info("Getting High Profile Manifest...") + else: + self.logger.info("Getting Main Profile Manifest...") + + resp = self.PyMSL(profiles=profiles) + + if not resp: + if self.args.hevc: + profiles, getHigh = self.LoadProfies(addHEVCDO=True) + self.logger.info('\nGetting HEVC DO Manifest...') + resp = self.PyMSL(profiles=profiles) + + if not resp: + self.logger.info("Failed getting Manifest") + exit(-1) + + VideoList, checkerinfo = self.ParseVideo(resp, getHigh) + AudioList, SubtitleList, ForcedList = self.ParseAudioSubs(resp) + + return VideoList, AudioList, SubtitleList, ForcedList, checkerinfo \ No newline at end of file diff --git a/helpers/__init__.py b/helpers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/helpers/aria2.py b/helpers/aria2.py new file mode 100644 index 0000000..1e3d012 --- /dev/null +++ b/helpers/aria2.py @@ -0,0 +1,369 @@ +import os +import shutil +import subprocess +import sys +import re +import logging +from configs.config import tool +from helpers.ripprocess import ripprocess + + +class aria2Error(Exception): + pass + + +class aria2_moded: + def __init__(self, aria2_download_command): + self.logger = logging.getLogger(__name__) + self.aria2_download_command = aria2_download_command + self.env = self.aria2DisableProxies() + self.ripprocess = ripprocess() + self.tool = tool() + self.LOGA_PATH = self.tool.paths()["LOGA_PATH"] + self.bin = self.tool.bin() + self.aria2c_exe = self.bin["aria2c"] + self.last_message_printed = 0 + self.speed_radar = "0kbps" + + def aria2DisableProxies(self): + env = os.environ.copy() + + if env.get("http_proxy"): + del env["http_proxy"] + + if env.get("HTTP_PROXY"): + del env["HTTP_PROXY"] + + if env.get("https_proxy"): + del env["https_proxy"] + + if env.get("HTTPS_PROXY"): + del env["HTTPS_PROXY"] + + return env + + def read_stdout(self, line): + speed = re.search(r"DL:(.+?)ETA", line) + eta = re.search(r"ETA:(.+?)]", line) + connection = re.search(r"CN:(.+?)DL", line) + percent = re.search(r"\((.*?)\)", line) + size = re.search(r" (.*?)/(.*?)\(", line) + + if speed and eta and connection and percent and size: + percent = percent.group().strip().replace(")", "").replace("(", "") + size = size.group().strip().replace(")", "").replace("(", "") + complete, total = size.split("/") + connection = connection.group(1).strip() + eta = eta.group(1).strip() + speed = speed.group(1).strip() + self.speed_radar = speed + + stdout_data = { + "percent": str(percent), + "size": str(total), + "complete": str(complete), + "total": str(total), + "connection": str(connection), + "eta": str(eta), + "speed": str(speed), + } + + return stdout_data + + return None + + def if_errors(self, line): + if "exception" in str(line).lower() or "errorcode" in str(line).lower(): + return line + return None + + def delete_last_message_printed(self): + print(" " * len(str(self.last_message_printed)), end="\r") + + def get_status(self, stdout_data: dict): + return "Aria2c_Status; Size: {Size} | Speed: {Speed} | ETA: {ETA} | Progress: {Complete} -> {Total} ({Percent})".format( + Size=stdout_data.get("size"), + Speed=stdout_data.get("speed"), + ETA=stdout_data.get("eta"), + Complete=stdout_data.get("complete"), + Total=stdout_data.get("total"), + Percent=stdout_data.get("percent"), + ) + + def is_download_completed(self, line): + if "(ok):download completed." in str(line).lower(): + return "Download completed: (OK) ({}\\s)".format(self.speed_radar) + return None + + def start_download(self): + proc = subprocess.Popen( + self.aria2_download_command, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + bufsize=1, + universal_newlines=True, + env=self.env, + ) + + check_errors = True + for line in getattr(proc, "stdout"): + if check_errors: + if self.if_errors(line): + raise aria2Error("Aria2c Error {}".format(self.if_errors(line))) + check_errors = False + stdout_data = self.read_stdout(line) + if stdout_data: + status_text = self.get_status(stdout_data) + self.delete_last_message_printed() + print(status_text, end="\r", flush=True) + self.last_message_printed = status_text + else: + download_finished = self.is_download_completed(line) + if download_finished: + self.delete_last_message_printed() + print(download_finished, end="\r", flush=True) + self.last_message_printed = download_finished + self.logger.info("") + return + + +class aria2: + def __init__(self,): + self.env = self.aria2DisableProxies() + self.ripprocess = ripprocess() + self.tool = tool() + self.bin = self.tool.bin() + self.LOGA_PATH = self.tool.paths()["LOGA_PATH"] + self.config = self.tool.aria2c() + self.aria2c_exe = self.bin["aria2c"] + self.logger = logging.getLogger(__name__) + + def convert_args(self, arg): + if arg is True: + return "true" + elif arg is False: + return "false" + elif arg is None: + return "none" + else: + return str(arg) + + def append_commands(self, command, option_define, option): + if option == "skip": + return [] + + return ["{}{}".format(option_define, option)] + + def append_two_commands(self, command, cmd1, cmd2): + if cmd2 == "skip": + return [] + + return [cmd1] + [cmd2] + + def aria2Options( + self, + allow_overwrite=True, + file_allocation=None, + auto_file_renaming=False, + async_dns=False, + retry_wait=5, + summary_interval=0, + enable_color=False, + connection=16, + concurrent_downloads=16, + split=16, + header="skip", + user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36", + uri_selector="inorder", + console_log_level="skip", + download_result="hide", + quiet="false", + extra_commands=[], + ): + + options = [] + extra_commands + allow_overwrite = self.convert_args(allow_overwrite) + quiet = self.convert_args(quiet) + file_allocation = self.convert_args(file_allocation) + auto_file_renaming = self.convert_args(auto_file_renaming) + async_dns = self.convert_args(async_dns) + retry_wait = self.convert_args(retry_wait) + enable_color = self.convert_args(enable_color) + connection = self.convert_args(connection) + concurrent_downloads = self.convert_args(concurrent_downloads) + split = self.convert_args(split) + header = self.convert_args(header) + uri_selector = self.convert_args(uri_selector) + console_log_level = self.convert_args(console_log_level) + download_result = self.convert_args(download_result) + + ############################################################################## + + options += self.append_commands(options, "--allow-overwrite=", allow_overwrite) + options += self.append_commands(options, "--quiet=", quiet) + options += self.append_commands(options, "--file-allocation=", file_allocation) + options += self.append_commands( + options, "--auto-file-renaming=", auto_file_renaming + ) + options += self.append_commands(options, "--async-dns=", async_dns) + options += self.append_commands(options, "--retry-wait=", retry_wait) + options += self.append_commands(options, "--enable-color=", enable_color) + + options += self.append_commands( + options, "--max-connection-per-server=", connection + ) + + options += self.append_commands( + options, "--max-concurrent-downloads=", concurrent_downloads + ) + options += self.append_commands(options, "--split=", split) + options += self.append_commands(options, "--header=", header) + options += self.append_commands(options, "--uri-selector=", uri_selector) + options += self.append_commands( + options, "--console-log-level=", console_log_level + ) + options += self.append_commands(options, "--download-result=", download_result) + + return options + + def aria2DisableProxies(self): + env = os.environ.copy() + + if env.get("http_proxy"): + del env["http_proxy"] + + if env.get("HTTP_PROXY"): + del env["HTTP_PROXY"] + + if env.get("https_proxy"): + del env["https_proxy"] + + if env.get("HTTPS_PROXY"): + del env["HTTPS_PROXY"] + + return env + + def aria2DownloadUrl(self, url, output, options, debug=False, moded=False): + self.debug = debug + aria2_download_command = [self.aria2c_exe] + options + + if self.config["enable_logging"]: + LogFile = os.path.join(self.LOGA_PATH, output.replace(".mp4", ".log")) + if os.path.isfile(LogFile): + os.remove(LogFile) + aria2_download_command.append("--log={}".format(LogFile)) + + if not url.startswith("http"): + raise aria2Error("Url does not start with http/https: {}".format(url)) + + aria2_download_command.append(url) + aria2_download_command += self.append_two_commands( + aria2_download_command, "-o", output + ) + + self.aria2Debug("Sending Commands to aria2c...") + self.aria2Debug(aria2_download_command) + self.logger.debug("aria2_download_command: {}".format(aria2_download_command)) + + if moded: + aria2_moded_download = aria2_moded(aria2_download_command) + aria2_moded_download.start_download() + else: + try: + aria = subprocess.call(aria2_download_command, env=self.env) + except FileNotFoundError: + self.logger.info("UNABLE TO FIND {}".format(self.aria2c_exe)) + exit(-1) + if aria != 0: + raise aria2Error("Aria2c exited with code {}".format(aria)) + + return + + def aria2DownloadDash( + self, segments, output, options, debug=False, moded=False, fixbytes=False + ): + self.debug = debug + aria2_download_command = [self.aria2c_exe] + options + + if self.config["enable_logging"]: + LogFile = os.path.join(self.LOGA_PATH, output.replace(".mp4", ".log")) + if os.path.isfile(LogFile): + os.remove(LogFile) + aria2_download_command.append("--log={}".format(LogFile)) + + if not isinstance(segments, list) or segments == []: + raise aria2Error("invalid list of urls: {}".format(segments)) + + if moded: + raise aria2Error("moded version not supported for dash downloads atm...") + + txt = output.replace(".mp4", ".txt") + folder = output.replace(".mp4", "") + segments = list(dict.fromkeys(segments)) + + if os.path.exists(folder): + shutil.rmtree(folder) + if not os.path.exists(folder): + os.makedirs(folder) + + segments_location = [] + + opened_txt = open(txt, "w+") + for num, url in enumerate(segments, start=1): + segment_name = str(num).zfill(5) + ".mp4" + segments_location.append(os.path.join(*[os.getcwd(), folder, segment_name])) + opened_txt.write(url + f"\n out={segment_name}" + f"\n dir={folder}" + "\n") + opened_txt.close() + + aria2_download_command += self.append_commands( + aria2_download_command, "--input-file=", txt + ) + + try: + aria = subprocess.call(aria2_download_command, env=self.env) + except FileNotFoundError: + self.logger.info("UNABLE TO FIND {}".format(self.aria2c_exe)) + exit(-1) + if aria != 0: + raise aria2Error("Aria2c exited with code {}".format(aria)) + + self.logger.info("\nJoining files...") + openfile = open(output, "wb") + total = int(len(segments_location)) + for current, fragment in enumerate(segments_location): + if os.path.isfile(fragment): + if fixbytes: + with open(fragment, "rb") as f: + wvdll = f.read() + if ( + re.search( + b"tfhd\x00\x02\x00\x1a\x00\x00\x00\x01\x00\x00\x00\x02", + wvdll, + re.MULTILINE | re.DOTALL, + ) + is not None + ): + fw = open(fragment, "wb") + m = re.search( + b"tfhd\x00\x02\x00\x1a\x00\x00\x00\x01\x00\x00\x00", + wvdll, + re.MULTILINE | re.DOTALL, + ) + segment_fixed = ( + wvdll[: m.end()] + b"\x01" + wvdll[m.end() + 1 :] + ) + fw.write(segment_fixed) + fw.close() + shutil.copyfileobj(open(fragment, "rb"), openfile) + os.remove(fragment) + self.ripprocess.updt(total, current + 1) + openfile.close() + + if os.path.isfile(txt): + os.remove(txt) + if os.path.exists(folder): + shutil.rmtree(folder) + + def aria2Debug(self, txt): + if self.debug: + self.logger.info(txt) diff --git a/helpers/bin/BeHappy/plugins32/LSMASHSource.dll b/helpers/bin/BeHappy/plugins32/LSMASHSource.dll new file mode 100644 index 0000000000000000000000000000000000000000..feeeeffba5f15d0fda37363961ebe61c07e85ddb GIT binary patch literal 9712128 zcmeFa4Rlo3m7rS%g)MC1U8Ln$rbVL6$UQJkG9qJ7%YM#`oJYSFHnBxQVsPkA3EPq& zSXVMqj1xk+m%
G94
zdF29m*;gPpcFT<>xzQ>&g5sYId(0Jo&T{eRJzAgnBe9AKNnK28pD{hXTvSBrm832w
z^~O0wy@7yUbJWZ
zRlfn!fIc%Sad}o%&}ljpCB^u9Hj+a4`uWDBO!b+R6<{j?L+xiMd+CeEUm-(3iX$NQ
zBRJ%|Tr?f!16SC6uG1&$`gL9AjMjD83|(J%NEF&|gQ=?k##L-6lF@*nW=lLuMLo&F
zMQEYzFI%{WI#e)mRnQjO9vFDF>JmP~^Qk 5(!960Y=