Violet
/
ttt
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

更新 'yk.py'

Browse Source
main
Violet 6 months ago
parent 903d188823
commit 1f617717a6
1 changed files with 428 additions and 251 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 679
      yk.py

679
yk.py
Unescape View File

@ -1,251 +1,428 @@
import os import os
import re, requests, time, json import re, requests, time, json
from hashlib import md5 from hashlib import md5
from urllib.parse import parse_qsl, urlsplit from urllib.parse import parse_qsl, urlsplit
import base64 import base64
from Crypto.Cipher import AES from Crypto.Cipher import AES
from tabulate import tabulate from tabulate import tabulate
from pywidevineb.L3.cdm import deviceconfig from pywidevine.L3.cdm import deviceconfig
from pywidevineb.L3.decrypt.wvdecryptcustom import WvDecrypt from pywidevine.L3.decrypt.wvdecryptcustom import WvDecrypt
from tools import get_pssh, dealck from tools import get_pssh, dealck
requests = requests.Session() requests = requests.Session()
class YouKu: class YouKu:
def __init__(self, cookie): def __init__(self, cookie):
self.cookie = dealck(cookie) self.cookie = dealck(cookie)
self.r = "xWrtQpP4Z4RsrRCY" self.r = "xWrtQpP4Z4RsrRCY"
self.R = "aq1mVooivzaolmJY5NrQ3A==" self.R = "aq1mVooivzaolmJY5NrQ3A=="
self.key = "" self.key = ""
self.headers = { self.headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36",
} }
requests.headers.update(self.headers) requests.headers.update(self.headers)
requests.cookies.update(self.cookie) requests.cookies.update(self.cookie)
self.ptoken = self.cookie.get("P_pck_rm")
def youku_sign(self, t, data, token): self.utida = "ZIH81OVlRSMDAOQQiG52i4cO"
appKey = '24679788' # 固定值
'''token值在cookie中''' def youku_sign(self, t, data, token):
sign = token + '&' + t + '&' + appKey + '&' + data appKey = '24679788' # 固定值
md = md5() '''token值在cookie中'''
md.update(sign.encode('UTF-8')) sign = token + '&' + t + '&' + appKey + '&' + data
sign = md.hexdigest() md = md5()
return sign md.update(sign.encode('UTF-8'))
sign = md.hexdigest()
def utid(self): return sign
json_cookie = requests.cookies.get_dict()
requests.cookies.clear() def utid(self):
requests.cookies.update(json_cookie) json_cookie = requests.cookies.get_dict()
utid = json_cookie.get("cna") requests.cookies.clear()
token = json_cookie.get("_m_h5_tk").split("_")[0] requests.cookies.update(json_cookie)
return {"utid": utid, "token": token} utid = json_cookie.get("cna")
token = json_cookie.get("_m_h5_tk").split("_")[0]
# 若直接在首页小窗口上复制的视频网址，是重定向的网址。 return {"utid": utid, "token": token}
def redirect(self, url):
headers = { # 若直接在首页小窗口上复制的视频网址，是重定向的网址。
"referer": "https://www.youku.com/", def redirect(self, url):
"user-agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36", headers = {
} "referer": "https://www.youku.com/",
resp = requests.get(url=url) "user-agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36",
return resp.url }
resp = requests.get(url=url)
def page_parser(self, url): return resp.url
vid = re.findall(r"id_(.*?)\.html", url)[0]
url = "https://openapi.youku.com/v2/videos/show.json" def page_parser(self, url):
params = { vid = re.findall(r"id_(.*?)\.html", url)[0]
"client_id": "53e6cc67237fc59a", url = "https://openapi.youku.com/v2/videos/show.json"
"package": "com.huawei.hwvplayer.youku", params = {
"ext": "show", "client_id": "53e6cc67237fc59a",
"video_id": vid "package": "com.huawei.hwvplayer.youku",
} "ext": "show",
try: "video_id": vid
response = requests.get(url, params=params).json() }
showid = response["show"]["id"] try:
return {"current_showid": showid, "videoId": 0, "vid": vid} response = requests.get(url, params=params).json()
except Exception as e: showid = response["show"]["id"]
print(f"获取showid失败:{e}") return {"current_showid": showid, "videoId": 0, "vid": vid}
print(f"[red]获取showid失败[/red]") except Exception as e:
print(f"获取showid失败:{e}")
def get_emb(self, videoId): print(f"[red]获取showid失败[/red]")
emb = base64.b64encode(("%swww.youku.com/" % videoId).encode('utf-8')).decode('utf-8')
return emb def get_emb(self, videoId):
emb = base64.b64encode(("%swww.youku.com/" % videoId).encode('utf-8')).decode('utf-8')
# 这个函数用来获取元素的第一个值 return emb
def takeOne(self, elem):
return float(elem[0]) # 这个函数用来获取元素的第一个值
def takeOne(self, elem):
def m3u8_url(self, t, params_data, sign): return float(elem[0])
url = "https://acs.youku.com/h5/mtop.youku.play.ups.appinfo.get/1.1/"
def save_m3u8(self, video, auto=1):
params = { title, size, resolution, drm_type, key, stream_type, _, m3u8_url, _ = video
"jsv": "2.5.8", title = f"{title}_{resolution}_{size}_{stream_type}"
"appKey": "24679788", savepath = os.path.join(os.getcwd(), "/download/yk")
"t": t, rm3u8_url = m3u8_url.replace("%", "%%")
"sign": sign, if rm3u8_url.startswith("http"):
"api": "mtop.youku.play.ups.appinfo.get", common_args = f"N_m3u8DL-RE.exe \"{rm3u8_url}\" --tmp-dir ./cache --save-name \"{title}\" --save-dir \"{savepath}\" --thread-count 16 --download-retry-count 30 --check-segments-count"
"v": "1.1", if auto:
"timeout": "20000", common_args += " --auto-select"
"YKPid": "20160317PLF000211", if drm_type == "default":
"YKLoginRequest": "true", cmd = common_args
"AntiFlood": "true", elif drm_type == "cbcs":
"AntiCreep": "true", cmd = f"{common_args} --key {key} -M format=mp4"
"type": "jsonp", else:
"dataType": "jsonp", key = key if ":" not in key else base64.b64encode(bytes.fromhex(key.split(":")[1])).decode()
"callback": "mtopjsonp1", txt = f'''
"data": params_data, #OUT,{savepath}
} #DECMETHOD,ECB
resp = requests.get(url=url, params=params) #KEY,{key}
result = resp.text {title},{m3u8_url}
# print(result) '''
data = json.loads(result[12:-1]) with open("{}.txt".format(title), "a", encoding="gbk") as f:
# print(data) f.write(txt)
ret = data["ret"] print("下载链接已生成")
video_lists = [] return
if ret == ["SUCCESS::调用成功"]: else:
stream = data["data"]["data"]["stream"] m3u8_path = "{}.m3u8".format(title)
title = data["data"]["data"]["video"]["title"] with open(m3u8_path, "w", encoding="utf-8") as f:
print("解析成功:") f.write(m3u8_url)
for video in stream: common_args = f"N_m3u8DL-RE.exe \"{m3u8_path}\" --tmp-dir ./cache --save-name \"{title}\" --save-dir \"{savepath}\" --thread-count 16 --download-retry-count 30 --check-segments-count"
m3u8_url = video["m3u8_url"] if ":" not in key:
width = video["width"] uri = re.findall(r'(http.*)\n', m3u8_url)[0]
height = video["height"] m3u8_text = requests.get(uri).text
size = video.get("size", 0) keyid = re.findall(r'KEYID=0x(.*),IV', m3u8_text)[0].lower()
size = '{:.1f}'.format(float(size) / 1048576) key = "--key {}:{}".format(keyid, base64.b64decode(key).hex())
drm_type = video["drm_type"] cmd = f"{common_args} {key} -M format=mp4"
if video['drm_type'] == "default": with open("{}.bat".format(title), "a", encoding="gbk") as f:
key = "" f.write(cmd)
elif drm_type == "cbcs": f.write("\n")
license_url = video["stream_ext"]["uri"] f.close()
key = self.get_cbcs_key(license_url, m3u8_url) print("下载链接已生成")
if key[0]:
key = key[1][0] def m3u8_url(self, t, params_data, sign, vid):
else: url = "https://acs.youku.com/h5/mtop.youku.play.ups.appinfo.get/1.1/"
encryptR_server = video['encryptR_server']
copyright_key = video['stream_ext']['copyright_key'] params = {
key = self.copyrightDRM(self.r, encryptR_server, copyright_key) "jsv": "2.5.8",
video_lists.append([title, size + "M", f"{width}x{height}", drm_type, key, m3u8_url]) "appKey": "24679788",
tb = tabulate([[*video_lists[i][:5]] for i in range(len(video_lists))], "t": t,
headers=["标题", "分辨率", "视频大小", "drm_type", "base64key"], tablefmt="pretty", "sign": sign,
showindex=range(1, len(video_lists) + 1)) "api": "mtop.youku.play.ups.appinfo.get",
ch = input(f"{tb}\n请输入要下载的视频序号：") "v": "1.1",
ch = ch.split(",") "timeout": "20000",
for i in ch: "YKPid": "20160317PLF000211",
title, size, resolution, drm_type, key, m3u8_url = video_lists[int(i) - 1] "YKLoginRequest": "true",
savename = f"{title}_{resolution}_{size}" "AntiFlood": "true",
savepath = os.path.join(os.getcwd(), "/download/yk") "AntiCreep": "true",
rm3u8_url = m3u8_url.replace("%", "%%") "type": "jsonp",
common_args = f"N_m3u8DL-RE.exe \"{rm3u8_url}\" --tmp-dir ./cache --save-name \"{title}\" --save-dir \"{savepath}\" --thread-count 16 --download-retry-count 30 --auto-select --check-segments-count" "dataType": "jsonp",
if drm_type == "default": "callback": "mtopjsonp1",
cmd = common_args "data": params_data,
elif drm_type == "cbcs": }
cmd = f"{common_args} --key {key} -M format=mp4" resp = requests.get(url=url, params=params)
else: result = resp.text
txt = f''' # print(result)
#OUT,{savepath} data = json.loads(result[12:-1])
#DECMETHOD,ECB # print(data)
#KEY,{key} ret = data["ret"]
{title}_{resolution}_{size},{m3u8_url} video_lists = []
''' if ret == ["SUCCESS::调用成功"]:
with open("{}.txt".format(title), "a", encoding="gbk") as f: stream = data["data"]["data"].get("stream", [])
f.write(txt) title = data["data"]["data"].get("video", {}).get("title", "")
print("下载链接已生成") print("解析成功:")
continue keys = {}
with open("{}.bat".format(title), "a", encoding="gbk") as f: tv_stream = self.get_TV_stream(vid)
f.write(cmd) stream.extend(tv_stream)
f.write("\n") for video in stream:
print("下载链接已生成") m3u8_url = video["m3u8_url"]
elif ret == ["FAIL_SYS_ILLEGAL_ACCESS::非法请求"]: width = video["width"]
print("请求参数错误") height = video["height"]
elif ret == ["FAIL_SYS_TOKEN_EXOIRED::令牌过期"]: size = video.get("size", 0)
print("Cookie过期") size = '{:.1f}'.format(float(size) / 1048576)
return 10086 drm_type = video["drm_type"]
else: audio_lang = video["audio_lang"]
print(ret[0]) audio = video['stream_ext'].get("audioGroupId", "") or "default"
return 0 if audio_lang == "default":
audio_lang = "guoyu"
def copyrightDRM(self, r, encryptR_server, copyright_key): language = []
crypto_1 = AES.new(r.encode(), AES.MODE_ECB) language = re.findall(r'LANGUAGE="([\w\s]+)"', m3u8_url)
key_2 = crypto_1.decrypt(base64.b64decode(encryptR_server)) # print("language是------------------>>>>>", language)
crypto_2 = AES.new(key_2, AES.MODE_ECB) if 'en' in language:
return base64.b64encode(base64.b64decode(crypto_2.decrypt(base64.b64decode(copyright_key)))).decode() audio_lang = "en"
if video['drm_type'] == "default":
def get_cbcs_key(self, license_url, m3u8_url): key = ""
headers = { elif audio_lang not in keys.keys():
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 Edg/114.0.1823.82" if drm_type == "cbcs":
} license_url = video["stream_ext"]["uri"]
m3u8data = requests.get(m3u8_url, headers=headers).text key = self.get_cbcs_key(license_url, m3u8_url)
key_url = re.findall(r"URI=\"(.*?)\"", m3u8data)[0] if key[0]:
response = requests.get(key_url, headers=headers).text key = key[1][0]
pssh = response.split("data:text/plain;base64,").pop().split('",')[0] else:
wvdecrypt = WvDecrypt(init_data_b64=pssh, cert_data_b64="", device=deviceconfig.device_android_generic) encryptR_server = video['encryptR_server']
headers = { copyright_key = video['stream_ext']['copyright_key']
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 Edg/114.0.1823.82", key = self.copyrightDRM(self.r, encryptR_server, copyright_key)
} keys[audio_lang] = key
dic = dict(parse_qsl(urlsplit(license_url).query)) else:
url = license_url.split("?")[0] key = keys[audio_lang]
dic["licenseRequest"] = base64.b64encode(wvdecrypt.get_challenge()).decode() video_lists.append(
dic["drmType"] = "widevine" [title, size + "M", f"{width}x{height}", drm_type, key, video["stream_type"],
response = requests.post(url, data=dic, headers=headers) audio + "_" + audio_lang, m3u8_url,
license_b64 = response.json()["data"] video.get("size", 0)])
wvdecrypt.update_license(license_b64) video_lists = sorted(video_lists, key=lambda x: x[-1], reverse=True)
Correct, keyswvdecrypt = wvdecrypt.start_process() tb = tabulate([[*video_lists[i][:7]] for i in range(len(video_lists))],
if Correct: headers=["标题", "视频大小", "分辨率", "drm_type", "base64key", "stream_type", "audio"],
return Correct, keyswvdecrypt tablefmt="pretty",
showindex=range(1, len(video_lists) + 1))
def get(self, url): ch = input(f"{tb}\n请输入要下载的视频序号,输入0尝试自动选择最高清晰度视频：")
t = str(int(time.time() * 1000)) if ch == "0":
user_info = self.utid() self.save_m3u82(video_lists)
userid = user_info["utid"] return 0
page_info = self.page_parser(url) ch = ch.split(",")
emb = self.get_emb(page_info["videoId"]) for i in ch:
steal_params = { video = video_lists[int(i) - 1]
"ccode": "0502", self.save_m3u8(video)
"utid": userid, elif ret == ["FAIL_SYS_ILLEGAL_ACCESS::非法请求"]:
"version": "9.4.39", print("请求参数错误")
"ckey": "DIl58SLFxFNndSV1GFNnMQVYkx1PP5tKe1siZu/86PR1u/Wh1Ptd+WOZsHHWxysSfAOhNJpdVWsdVJNsfJ8Sxd8WKVvNfAS8aS8fAOzYARzPyPc3JvtnPHjTdKfESTdnuTW6ZPvk2pNDh4uFzotgdMEFkzQ5wZVXl2Pf1/Y6hLK0OnCNxBj3+nb0v72gZ6b0td+WOZsHHWxysSo/0y9D2K42SaB8Y/+aD2K42SaB8Y/+ahU+WOZsHcrxysooUeND", elif ret == ["FAIL_SYS_TOKEN_EXOIRED::令牌过期"]:
"client_ip": "192.168.1.1", print("Cookie过期")
"client_ts": 1698373135 return 10086
} else:
biz_params = { print(ret[0])
"vid": page_info["vid"], return 0
"h265": 1,
"preferClarity": 4, def copyrightDRM(self, r, encryptR_server, copyright_key):
"media_type": "standard,subtitle", try:
"app_ver": "9.4.39", crypto_1 = AES.new(r.encode(), AES.MODE_ECB)
"extag": "EXT-X-PRIVINF", key_2 = crypto_1.decrypt(base64.b64decode(encryptR_server))
"play_ability": 16782592, crypto_2 = AES.new(key_2, AES.MODE_ECB)
"master_m3u8": 1, return base64.b64encode(base64.b64decode(crypto_2.decrypt(base64.b64decode(copyright_key)))).decode()
"drm_type": 19, except:
"key_index": "web01", return ""
"encryptR_client": self.R,
"skh": 1, def get_cbcs_key(self, license_url, m3u8_url):
"last_clarity": 5, headers = {
"clarity_chg_ts": 1689341442 "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 Edg/114.0.1823.82"
} }
ad_params = { m3u8data = requests.get(m3u8_url, headers=headers).text
"vip": 1, key_url = re.findall(r"URI=\"(.*?)\"", m3u8data)[0]
} response = requests.get(key_url, headers=headers).text
params_data = { pssh = response.split("data:text/plain;base64,").pop().split('",')[0]
"steal_params": json.dumps(steal_params), wvdecrypt = WvDecrypt(init_data_b64=pssh, cert_data_b64="", device=deviceconfig.device_android_generic)
"biz_params": json.dumps(biz_params), headers = {
"ad_params": json.dumps(ad_params), "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 Edg/114.0.1823.82",
} }
params_data = json.dumps(params_data) dic = dict(parse_qsl(urlsplit(license_url).query))
sign = self.youku_sign(t, params_data, user_info["token"]) url = license_url.split("?")[0]
return self.m3u8_url(t, params_data, sign) dic["licenseRequest"] = base64.b64encode(wvdecrypt.get_challenge()).decode()
dic["drmType"] = "widevine"
def start(self, url=None): response = requests.post(url, data=dic, headers=headers)
url = input("请输入视频链接：") if url is None else url license_b64 = response.json()["data"]
url = self.redirect(url) wvdecrypt.update_license(license_b64)
for i in range(3): Correct, keyswvdecrypt = wvdecrypt.start_process()
ret = self.get(url) if Correct:
if ret: return Correct, keyswvdecrypt
continue
break def get_TV_stream(self, vid):
headers = {
"user-agent": "OTTSDK;1.0.8.6;Android;9;2203121C"
if __name__ == '__main__': }
cookie =""
youku = YouKu(cookie) def getdata():
youku.start() response = requests.get(url, headers=headers, params=params)
try:
data = response.json()["data"]
title = data['show']["title"]
streams = data["stream"]
streamss.extend(streams)
return title, streams
except Exception as e:
return None, []
url = "https://ups.youku.com/ups/get.json" # light_get.json
params = {
"ckey": "7B19C0AB12633B22E7FE81271162026020570708D6CC189E4924503C49D243A0DE6CD84A766832C2C99898FC5ED31F3709BB3CDD82C96492E721BDD381735026",
"client_ip": "192.168.3.1",
"client_ts": "1697343919",
"utid": self.utida,
"pid": "b777e6ae3c99e26",
# HAIER_PID = "36214723575196"; JIMI_PID = "3b777e6ae3c99e26";SONY_PID = "36281532078091";
"player_type": "dnahard", # system:hls,dnahard: cmfv
"app_ver": "11.4.6.4", # 2121104604,2121100600,11.0.6.0,11.4.6.4
"ccode": "0103010261", # sony :0103010261, jimi:010301025C,haier:0103010275 280
"player_source": "21", # 20 sdr 21hfr 22dolby 23bit10
"encryptR_client": "fTWuKHLOVUoOide+VH/h8w==",
"key_index": "key01",
"vid": vid,
"h265": "1",
"media_type": "standard,sei",
"client_id": "",
"ptoken": self.ptoken,
"drm_type": "7",
"extag": "EXT-X-PRIVINF",
"extag_fields": "STREAMTYPE",
"device_name": "XR-98X90L",
"play_ability": "405929984",
"preferClarity": "23",
"master_m3u8": "0",
"play_ability_v2": "2222222",
"site": "1",
"fu": "1",
"vs": "1.0",
"os": "android",
"osv": "12.1.1",
"bt": "tv",
"aw": "a",
"p": "27",
"mdl": "XR-98X90L",
"device_model": "XR-98X90L",
"": ""
}
streamss = []
player_source = [20, 23, 22, 21]
player_type = ["system", "dnahard"]
for i in player_source:
params["player_source"] = str(i)
for j in player_type:
params["player_type"] = j
getdata()
params["ccode"] = "0103010275"
params["player_source"] = "21"
params["player_type"] = "system"
getdata()
params.update({"app_ver": "11.4.7.0",
"play_ability": "274877906943",
"play_ability_v2": "1111111",
"pid": "52f8ca2b4982124b", })
play_ability_v2 = ["1111111111", "0111111111", 1111000000, 1101110000, 1101101000, 11101100100, 1101100010]
# "play_ability_v2": "1111111111", # 1:dolby_vision 2:hdr10 3:dtsc -5:dolby_atmos -4:dolby_around -3:dts -2:aac_hd3_51
#仅供测试，建议自行修改，减少请求次数，否则容易封，提示客户端无权播放
for v2 in play_ability_v2:
params["play_ability_v2"] = v2
getdata()
url = "https://ups.youku.com/ups/light_get.json"
params["ccode"] = "0103010280"
params["drm_type"] = 0
getdata()
streamss = sorted(streamss, key=lambda x: x["size"], reverse=True)
return streamss
def get(self, url):
t = str(int(time.time() * 1000))
user_info = self.utid()
userid = user_info["utid"]
page_info = self.page_parser(url)
emb = self.get_emb(page_info["videoId"])
steal_params = {
"ccode": "0502",
"utid": userid,
"version": "9.4.39",
"ckey": "DIl58SLFxFNndSV1GFNnMQVYkx1PP5tKe1siZu/86PR1u/Wh1Ptd+WOZsHHWxysSfAOhNJpdVWsdVJNsfJ8Sxd8WKVvNfAS8aS8fAOzYARzPyPc3JvtnPHjTdKfESTdnuTW6ZPvk2pNDh4uFzotgdMEFkzQ5wZVXl2Pf1/Y6hLK0OnCNxBj3+nb0v72gZ6b0td+WOZsHHWxysSo/0y9D2K42SaB8Y/+aD2K42SaB8Y/+ahU+WOZsHcrxysooUeND",
"client_ip": "192.168.1.1",
"client_ts": 1698373135
}
biz_params = {
"vid": page_info["vid"],
"h265": 1,
"preferClarity": 4,
"media_type": "standard,subtitle",
"app_ver": "9.4.39",
"extag": "EXT-X-PRIVINF",
"play_ability": 16782592,
"master_m3u8": 1,
"drm_type": 19,
"key_index": "web01",
"encryptR_client": self.R,
"skh": 1,
"last_clarity": 5,
"clarity_chg_ts": 1689341442,
"needad": 0,
}
ad_params = {
"vip": 1,
"needad":0,
}
params_data = {
"steal_params": json.dumps(steal_params),
"biz_params": json.dumps(biz_params),
"ad_params": json.dumps(ad_params),
}
params_data = json.dumps(params_data)
sign = self.youku_sign(t, params_data, user_info["token"])
return self.m3u8_url(t, params_data, sign, page_info["vid"])
def start(self, url=None):
url = input("请输入视频链接：") if url is None else url
url = self.redirect(url) if url.startswith("https://") else f"https://v.youku.com/v_show/id_{url}.html"
for i in range(3):
ret = self.get(url)
if ret:
continue
break
def save_m3u82(self, video_lists):
video_lists_a = [x for x in video_lists if "cmfv5hd" in x[5]]
if video_lists_a:
videoTypes = set()
audioTypes = []
langs = []
keys=""
m3u8data = "#EXTM3U\n"
for video in video_lists_a:
audioType = video[6]
lang = audioType.split("_")[-1]
m3u8_url = video[-2]
key=video[4]
if lang not in langs:
if ":" not in key:
uri = re.findall(r'(http.*)\n', m3u8_url)[0]
m3u8_text = requests.get(uri).text
keyid = re.findall(r'KEYID=0x(.*),IV', m3u8_text)[0].lower()
keys += " --key {}:{}".format(keyid, base64.b64decode(key).hex())
else:
keys += f" --key {key}"
langs.append(lang)
videoType = video[5].split("_")[1]
'''
if videoType not in videoTypes:
m3u8data += "\n".join(m3u8_url.split("\n")[2:4])
videoTypes.append(videoType)
elif audioType not in audioTypes:
m3u8data += m3u8_url.split("\n")[1]
audioTypes.append(audioType)
部分视频存在多个音频流,会出错
所以直接把所有的m3u8链接都写入m3u8文件，手动在下载时选择
'''
if videoType not in videoTypes or audioType not in audioTypes:
m3u8data += "\n".join(m3u8_url.split("\n")[1:-2])
videoTypes.add(videoType)
audioTypes.append(audioType)
m3u8data += "\n#EXT-X-ENDLIST"
video_lists_a[0][7] = m3u8data
video_lists_a[0][4] = keys
self.save_m3u8(video_lists_a[0])
else:
self.save_m3u8(video_lists[0])
if __name__ == '__main__':
cookie = ''
youku = YouKu(cookie)
youku.start("XNjE0OTU0NDU0NA==")

Write Preview
Loading…
Cancel
Save