609 řádky
26 KiB
Python
609 řádky
26 KiB
Python
# -*- coding: utf-8 -*-
|
||
import re
|
||
import json
|
||
import hashlib
|
||
import base64
|
||
import time
|
||
from urllib.parse import quote
|
||
from base.spider import Spider
|
||
|
||
# ---------- 纯Python实现的RC4和AES（无需第三方库） ----------
|
||
def rc4_crypt(data, key):
|
||
S = list(range(256))
|
||
j = 0
|
||
for i in range(256):
|
||
j = (j + S[i] + key[i % len(key)]) % 256
|
||
S[i], S[j] = S[j], S[i]
|
||
i = j = 0
|
||
out = bytearray()
|
||
for ch in data:
|
||
i = (i + 1) % 256
|
||
j = (j + S[i]) % 256
|
||
S[i], S[j] = S[j], S[i]
|
||
out.append(ch ^ S[(S[i] + S[j]) % 256])
|
||
return out
|
||
|
||
def aes_cbc_decrypt(data, key, iv):
|
||
raise NotImplementedError("AES解密需要 pycryptodome 库")
|
||
|
||
# 尝试导入官方库
|
||
try:
|
||
from Crypto.Cipher import ARC4, AES
|
||
from Crypto.Util.Padding import unpad
|
||
def rc4_crypt(data, key):
|
||
cipher = ARC4.new(key)
|
||
return cipher.decrypt(data)
|
||
def aes_cbc_decrypt(data, key, iv):
|
||
cipher = AES.new(key.encode('utf-8'), AES.MODE_CBC, iv.encode('utf-8'))
|
||
decrypted = unpad(cipher.decrypt(base64.b64decode(data)), AES.block_size)
|
||
return decrypted.decode('utf-8')
|
||
CRYPTO_AVAILABLE = True
|
||
except ImportError:
|
||
CRYPTO_AVAILABLE = False
|
||
print("[歪比影视] 提示: pycryptodome未安装，播放解密可能失败")
|
||
|
||
class Spider(Spider):
|
||
BASE_URL = "https://wbbb1.com"
|
||
PARSE_DOMAIN = "xn--qvr2v.850088.xyz"
|
||
|
||
def_headers = {
|
||
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36",
|
||
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
|
||
"Accept-Language": "zh-CN,zh;q=0.9",
|
||
"Referer": BASE_URL + "/",
|
||
"Connection": "keep-alive",
|
||
}
|
||
|
||
play_headers = {
|
||
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
|
||
"Referer": BASE_URL + "/",
|
||
"Accept": "*/*",
|
||
}
|
||
|
||
CATEGORY_MAP = {"1": "1", "2": "2", "3": "3", "4": "4"}
|
||
CATEGORY_NAMES = {"1": "电影", "2": "剧集", "3": "动漫", "4": "综艺"}
|
||
|
||
_cookies = ""
|
||
|
||
# ---------- 加密工具 ----------
|
||
def _md5(self, s):
|
||
return hashlib.md5(s.encode('utf-8')).hexdigest()
|
||
|
||
def _rc4_encrypt(self, data, key):
|
||
key_bytes = key.encode('utf-8') if isinstance(key, str) else key
|
||
data_bytes = data.encode('utf-8') if isinstance(data, str) else data
|
||
encrypted = rc4_crypt(data_bytes, key_bytes)
|
||
return base64.b64encode(encrypted).decode('utf-8')
|
||
|
||
def _rc4_decrypt(self, data, key):
|
||
key_bytes = key.encode('utf-8') if isinstance(key, str) else key
|
||
data_bytes = base64.b64decode(data)
|
||
decrypted = rc4_crypt(data_bytes, key_bytes)
|
||
return decrypted.decode('utf-8')
|
||
|
||
def _aes_decrypt(self, data, key, iv):
|
||
if not CRYPTO_AVAILABLE:
|
||
raise Exception("AES解密需要 pycryptodome 库")
|
||
return aes_cbc_decrypt(data, key, iv)
|
||
|
||
# ---------- 页面请求 ----------
|
||
def _fetch_cookies(self):
|
||
try:
|
||
headers = {"User-Agent": self.def_headers["User-Agent"], "Accept": "text/html", "Referer": self.BASE_URL + "/"}
|
||
resp = self.fetch(self.BASE_URL, headers=headers)
|
||
cookie_list = []
|
||
# 尝试多种方式获取Set-Cookie
|
||
if hasattr(resp, 'cookies') and resp.cookies:
|
||
try:
|
||
for cookie in resp.cookies:
|
||
cookie_list.append(f"{cookie.name}={cookie.value}")
|
||
except:
|
||
pass
|
||
if not cookie_list:
|
||
if hasattr(resp.headers, "get_all"):
|
||
raw = resp.headers.get_all("Set-Cookie")
|
||
for c in raw:
|
||
cookie_list.append(c.split(";")[0])
|
||
elif "Set-Cookie" in resp.headers:
|
||
raw = resp.headers["Set-Cookie"]
|
||
if isinstance(raw, list):
|
||
for c in raw:
|
||
cookie_list.append(c.split(";")[0])
|
||
else:
|
||
cookie_list.append(raw.split(";")[0])
|
||
self._cookies = "; ".join(cookie_list)
|
||
if self._cookies:
|
||
print(f"[歪比影视] Cookie获取成功")
|
||
except Exception as e:
|
||
print(f"[歪比影视] Cookie获取失败: {e}")
|
||
self._cookies = ""
|
||
|
||
def _fetch_html(self, url):
|
||
headers = self.def_headers.copy()
|
||
if self._cookies:
|
||
headers["Cookie"] = self._cookies
|
||
try:
|
||
resp = self.fetch(url, headers=headers)
|
||
return resp.text
|
||
except Exception as e:
|
||
print(f"[歪比影视] 请求失败: {url}, {e}")
|
||
# 如果失败且没有cookie，尝试重新获取cookie后重试
|
||
if not self._cookies:
|
||
print("[歪比影视] 尝试重新获取Cookie...")
|
||
self._fetch_cookies()
|
||
if self._cookies:
|
||
headers["Cookie"] = self._cookies
|
||
try:
|
||
resp = self.fetch(url, headers=headers)
|
||
return resp.text
|
||
except Exception as e2:
|
||
print(f"[歪比影视] 重试失败: {e2}")
|
||
return ""
|
||
|
||
# ---------- 工具函数：清理HTML标签 ----------
|
||
def _clean_html(self, text):
|
||
if not text:
|
||
return ""
|
||
text = re.sub(r'<[^>]+>', '', text)
|
||
text = re.sub(r'\s+', ' ', text).strip()
|
||
return text
|
||
|
||
# ---------- 解析函数 ----------
|
||
def _parse_video_list(self, html):
|
||
"""通用解析（用于首页/分类页）"""
|
||
videos = []
|
||
# 使用更宽松的正则匹配，兼容class顺序变化
|
||
pattern = r'<a[^>]*href="/detail/(\d+\.html)"[^>]*class="[^"]*module-poster-item[^"]*"[^>]*>.*?<div[^>]*class="[^"]*module-item-note[^"]*"[^>]*>([^<]*)</div>.*?<img[^>]*data-original="([^"]+)"[^>]*>.*?<div[^>]*class="[^"]*module-poster-item-title[^"]*"[^>]*>([^<]*)</div>'
|
||
for match in re.finditer(pattern, html, re.DOTALL):
|
||
detail_url = match.group(1)
|
||
vod_id = detail_url.replace(".html", "")
|
||
vod_pic = match.group(3).strip()
|
||
# 处理协议相对URL
|
||
if vod_pic.startswith("//"):
|
||
vod_pic = "https:" + vod_pic
|
||
videos.append({
|
||
"vod_id": vod_id,
|
||
"vod_name": match.group(4).strip(),
|
||
"vod_pic": vod_pic,
|
||
"vod_remarks": match.group(2).strip(),
|
||
})
|
||
return videos
|
||
|
||
def _parse_search_list(self, html):
|
||
"""专门解析搜索页（参考JS选择器）"""
|
||
videos = []
|
||
# 使用更宽松的正则匹配
|
||
items = re.finditer(r'<div[^>]*class="[^"]*module-card-item[^"]*"[^>]*>(.*?)</div>\s*(?=<div[^>]*class="[^"]*module-card-item|$)', html, re.DOTALL)
|
||
for item in items:
|
||
block = item.group(1)
|
||
# 提取链接
|
||
link_match = re.search(r'<a[^>]*href="(/detail/[^"]+\.html)"', block)
|
||
if not link_match:
|
||
continue
|
||
vod_id = link_match.group(1).replace("/detail/", "").replace(".html", "")
|
||
# 提取标题
|
||
title_match = re.search(r'<div[^>]*class="[^"]*module-card-item-title[^"]*"[^>]*>.*?<strong>([^<]*)</strong>', block, re.DOTALL)
|
||
vod_name = title_match.group(1).strip() if title_match else "未知"
|
||
# 提取图片
|
||
pic_match = re.search(r'<img[^>]*data-original="([^"]+)"', block)
|
||
vod_pic = pic_match.group(1) if pic_match else ""
|
||
if vod_pic and vod_pic.startswith("//"):
|
||
vod_pic = "https:" + vod_pic
|
||
# 提取备注
|
||
note_match = re.search(r'<div[^>]*class="[^"]*module-item-note[^"]*"[^>]*>([^<]*)</div>', block)
|
||
vod_remarks = note_match.group(1).strip() if note_match else ""
|
||
videos.append({
|
||
"vod_id": vod_id,
|
||
"vod_name": vod_name,
|
||
"vod_pic": vod_pic,
|
||
"vod_remarks": vod_remarks,
|
||
})
|
||
return videos
|
||
|
||
def _parse_play_sources(self, html, vod_id):
|
||
"""
|
||
提取每个线路的集数，线路名称准确提取
|
||
"""
|
||
sources = []
|
||
|
||
# 1. 提取线路名称（按顺序）- 优先使用 data-dropdown-value
|
||
source_names = []
|
||
for m in re.finditer(r'data-dropdown-value="([^"]+)"', html):
|
||
name = m.group(1).strip()
|
||
if name and name not in source_names:
|
||
source_names.append(name)
|
||
if not source_names:
|
||
tab_box = re.search(r'<div[^>]*class="[^"]*module-tab-items-box[^"]*"[^>]*>(.*?)</div>', html, re.DOTALL)
|
||
if tab_box:
|
||
for m in re.finditer(r'<div[^>]*class="[^"]*tab-item[^"]*"[^>]*>.*?<span[^>]*>([^<]*)</span>', tab_box.group(1)):
|
||
name = m.group(1).strip()
|
||
if name and name not in source_names:
|
||
source_names.append(name)
|
||
if not source_names:
|
||
for m in re.finditer(r'<span[^>]*class="[^"]*module-tab-value"[^>]*>([^<]*)</span>', html):
|
||
name = m.group(1).strip()
|
||
if name and name not in source_names:
|
||
source_names.append(name)
|
||
if not source_names:
|
||
source_names = ["默认"]
|
||
|
||
# 2. 提取所有 module-list 块
|
||
list_blocks = []
|
||
start_tag = '<div class="module-list sort-list tab-list his-tab-list" id="panel1">'
|
||
pos = 0
|
||
while True:
|
||
start = html.find(start_tag, pos)
|
||
if start == -1:
|
||
break
|
||
start += len(start_tag)
|
||
depth = 0
|
||
end = None
|
||
i = start
|
||
while i < len(html):
|
||
if html[i:i+5] == '<div ':
|
||
depth += 1
|
||
i += 5
|
||
elif html[i:i+6] == '</div>':
|
||
if depth == 0:
|
||
end = i + 6
|
||
break
|
||
else:
|
||
depth -= 1
|
||
i += 6
|
||
else:
|
||
i += 1
|
||
if end is not None:
|
||
block_html = html[start:end]
|
||
if '/vplay/' in block_html:
|
||
list_blocks.append(block_html)
|
||
pos = end
|
||
else:
|
||
pos = start + 1
|
||
|
||
if not list_blocks:
|
||
blocks = []
|
||
start_tag2 = '<div class="module-play-list"'
|
||
pos = 0
|
||
while True:
|
||
start = html.find(start_tag2, pos)
|
||
if start == -1:
|
||
break
|
||
start += len(start_tag2)
|
||
depth = 0
|
||
end = None
|
||
i = start
|
||
while i < len(html):
|
||
if html[i:i+5] == '<div ':
|
||
depth += 1
|
||
i += 5
|
||
elif html[i:i+6] == '</div>':
|
||
if depth == 0:
|
||
end = i + 6
|
||
break
|
||
else:
|
||
depth -= 1
|
||
i += 6
|
||
else:
|
||
i += 1
|
||
if end is not None:
|
||
block_html = html[start:end]
|
||
if '/vplay/' in block_html:
|
||
list_blocks.append(block_html)
|
||
pos = end
|
||
else:
|
||
pos = start + 1
|
||
|
||
if not list_blocks:
|
||
simple = re.findall(r'<div class="module-play-list"[^>]*>(.*?)</div>', html, re.DOTALL)
|
||
for b in simple:
|
||
if '/vplay/' in b:
|
||
list_blocks.append(b)
|
||
|
||
# 3. 对齐名称与块数量
|
||
if len(source_names) > len(list_blocks):
|
||
source_names = source_names[:len(list_blocks)]
|
||
while len(source_names) < len(list_blocks):
|
||
source_names.append(f"源{len(source_names)+1}")
|
||
|
||
# 4. 解析每个块的集数
|
||
for idx, block in enumerate(list_blocks):
|
||
eps = []
|
||
for m in re.finditer(r'<a[^>]*href="(/vplay/(\d+)-(\d+)-(\d+)\.html)"[^>]*>.*?<span>([^<]*)</span>', block):
|
||
link = m.group(1)
|
||
id_ = m.group(2)
|
||
sid = m.group(3)
|
||
nid = m.group(4)
|
||
name = m.group(5).strip()
|
||
eps.append({"name": name, "link": f"{id_}-{sid}-{nid}"})
|
||
if eps:
|
||
sources.append({
|
||
"source_name": source_names[idx] if idx < len(source_names) else f"源{idx+1}",
|
||
"episodes": eps
|
||
})
|
||
|
||
if not sources:
|
||
eps = []
|
||
for m in re.finditer(r'<a[^>]*href="(/vplay/(\d+)-(\d+)-(\d+)\.html)"[^>]*>.*?<span>([^<]*)</span>', html):
|
||
link = m.group(1)
|
||
id_ = m.group(2)
|
||
sid = m.group(3)
|
||
nid = m.group(4)
|
||
name = m.group(5).strip()
|
||
eps.append({"name": name, "link": f"{id_}-{sid}-{nid}"})
|
||
if eps:
|
||
sources.append({"source_name": "默认", "episodes": eps})
|
||
|
||
return sources
|
||
|
||
# ---------- 播放地址获取 ----------
|
||
def _get_play_url(self, vod_id, sid, nid):
|
||
try:
|
||
play_page = f"{self.BASE_URL}/vplay/{vod_id}-{sid}-{nid}.html"
|
||
html = self._fetch_html(play_page)
|
||
if not html:
|
||
return None
|
||
|
||
# 检查iframe
|
||
iframe_match = re.search(r'<iframe[^>]*src="([^"]+)"', html)
|
||
if iframe_match:
|
||
iframe_url = iframe_match.group(1)
|
||
if iframe_url.startswith('//'):
|
||
iframe_url = 'https:' + iframe_url
|
||
elif iframe_url.startswith('/'):
|
||
iframe_url = self.BASE_URL + iframe_url
|
||
print(f"[歪比影视] 发现iframe: {iframe_url}")
|
||
return iframe_url
|
||
|
||
# 提取加密URL - 使用更安全的大括号匹配算法，支持嵌套JSON
|
||
enc_url = None
|
||
m1 = re.search(r'var\s+player_aaaa\s*=\s*', html)
|
||
if m1:
|
||
start = m1.end()
|
||
# 跳过空白字符
|
||
while start < len(html) and html[start] in ' \t\n\r':
|
||
start += 1
|
||
# 找到匹配的大括号
|
||
if start < len(html) and html[start] == '{':
|
||
depth = 1
|
||
i = start + 1
|
||
while i < len(html) and depth > 0:
|
||
if html[i] == '{':
|
||
depth += 1
|
||
elif html[i] == '}':
|
||
depth -= 1
|
||
i += 1
|
||
if depth == 0:
|
||
json_str = html[start:i]
|
||
try:
|
||
player_data = json.loads(json_str)
|
||
enc_url = player_data.get("url", "")
|
||
print(f"[歪比影视] 提取到player_aaaa.url: {enc_url[:50]}...")
|
||
except Exception as e:
|
||
print(f"[歪比影视] player_aaaa JSON解析失败: {e}")
|
||
|
||
# 兜底：直接搜索url字段
|
||
if not enc_url:
|
||
m2 = re.search(r'"url"\s*:\s*"([^"]+)"', html)
|
||
if m2:
|
||
enc_url = m2.group(1)
|
||
print(f"[歪比影视] 兜底提取到url: {enc_url[:50]}...")
|
||
|
||
if not enc_url:
|
||
print("[歪比影视] 未能提取到加密URL")
|
||
return None
|
||
|
||
# 如果无加密库，返回解析页面
|
||
if not CRYPTO_AVAILABLE:
|
||
fallback_url = f"https://{self.PARSE_DOMAIN}/player/?url={enc_url}&next=//&title="
|
||
print(f"[歪比影视] 无加密库，使用解析页面: {fallback_url}")
|
||
return fallback_url
|
||
|
||
try:
|
||
domain = self.PARSE_DOMAIN
|
||
l = (self._md5(enc_url) + " P")[-22:]
|
||
key = l.encode('utf-8')
|
||
h = self._rc4_encrypt(self._md5(enc_url + "stray"), key)
|
||
timestamp = str(int(time.time()))
|
||
u = self._rc4_encrypt(timestamp + self._md5(key.decode('utf-8') + "stray"), key)
|
||
y = self._rc4_encrypt(self._md5(domain + "stray"), key)
|
||
|
||
api_url = f"https://{domain}/player/api.php"
|
||
headers = {
|
||
"User-Agent": self.play_headers["User-Agent"],
|
||
"Accept": "application/json, text/javascript, */*; q=0.01",
|
||
"Origin": f"https://{domain}",
|
||
"Referer": f"https://{domain}/player/?url={enc_url}",
|
||
"X-Requested-With": "XMLHttpRequest",
|
||
"Content-Type": "application/x-www-form-urlencoded"
|
||
}
|
||
if self._cookies:
|
||
headers["Cookie"] = self._cookies
|
||
|
||
post_data = {"url": enc_url, "key": h, "vkey": u, "ckey": y}
|
||
print(f"[歪比影视] 请求API: {api_url}")
|
||
resp = self.post(api_url, data=post_data, headers=headers)
|
||
result = json.loads(resp.text)
|
||
print(f"[歪比影视] API返回: code={result.get('code')}")
|
||
|
||
if result.get("code") == 200:
|
||
aes_key = self._rc4_decrypt(result["aes_key"], key)
|
||
aes_iv = self._rc4_decrypt(result["aes_iv"], key)
|
||
enc_play = result["url"]
|
||
play_url = self._aes_decrypt(enc_play, aes_key, aes_iv)
|
||
print(f"[歪比影视] 解密成功: {play_url[:80]}...")
|
||
return play_url
|
||
else:
|
||
fallback_url = f"https://{domain}/player/?url={enc_url}&next=//&title="
|
||
print(f"[歪比影视] API返回非200，使用解析页面: {fallback_url}")
|
||
return fallback_url
|
||
except Exception as e:
|
||
print(f"[歪比影视] 解密异常: {e}")
|
||
fallback_url = f"https://{self.PARSE_DOMAIN}/player/?url={enc_url}&next=//&title="
|
||
return fallback_url
|
||
except Exception as e:
|
||
print(f"[歪比影视] 获取播放地址异常: {e}")
|
||
return None
|
||
|
||
# ---------- TVBox接口 ----------
|
||
def init(self, extend=''):
|
||
self._fetch_cookies()
|
||
print("[歪比影视] 初始化完成")
|
||
|
||
def homeContent(self, filter):
|
||
return {"class": [{"type_id": tid, "type_name": name} for tid, name in self.CATEGORY_NAMES.items()]}
|
||
|
||
def homeVideoContent(self):
|
||
try:
|
||
html = self._fetch_html(self.BASE_URL)
|
||
if not html:
|
||
return {"list": []}
|
||
# 尝试匹配"正在热映"
|
||
block = re.search(r'<div class="module">.*?<h2[^>]*class="[^"]*module-title[^"]*"[^>]*>正在热映.*?</div>(.*?)</div>\s*<div class="module">', html, re.DOTALL)
|
||
if not block:
|
||
# 兜底：尝试匹配第一个module块
|
||
block = re.search(r'<div class="module">(.*?)</div>\s*<div class="module">', html, re.DOTALL)
|
||
if not block:
|
||
return {"list": []}
|
||
videos = self._parse_video_list(block.group(1))
|
||
return {"list": videos[:20]}
|
||
except Exception as e:
|
||
print(f"[歪比影视] homeVideoContent 异常: {e}")
|
||
return {"list": []}
|
||
|
||
def categoryContent(self, tid, pg, filter, extend):
|
||
try:
|
||
pg = int(pg)
|
||
if tid not in self.CATEGORY_MAP:
|
||
return {"list": [], "pagecount": 1, "page": pg}
|
||
if pg == 1:
|
||
url = f"{self.BASE_URL}/show/{tid}-----------.html"
|
||
else:
|
||
url = f"{self.BASE_URL}/show/{tid}--------{pg}---.html"
|
||
print(f"[歪比影视] 分类请求: {url}")
|
||
html = self._fetch_html(url)
|
||
if not html:
|
||
return {"list": [], "pagecount": 1, "page": pg}
|
||
videos = self._parse_video_list(html)
|
||
last = re.search(r'<a[^>]*href="/show/\d+--------(\d+)---\.html"[^>]*>尾页</a>', html)
|
||
pagecount = int(last.group(1)) if last else 1
|
||
return {"list": videos, "pagecount": pagecount, "page": pg}
|
||
except Exception as e:
|
||
print(f"[歪比影视] categoryContent 异常: {e}")
|
||
return {"list": [], "pagecount": 1, "page": pg}
|
||
|
||
def searchContent(self, key, quick, pg='1'):
|
||
try:
|
||
pg = int(pg)
|
||
# 对搜索关键词进行URL编码，修复中文搜索失败
|
||
encoded_key = quote(key)
|
||
url = f"{self.BASE_URL}/search/{encoded_key}-------------.html"
|
||
print(f"[歪比影视] 搜索请求: {url}")
|
||
html = self._fetch_html(url)
|
||
if not html:
|
||
return {"list": [], "page": pg}
|
||
videos = self._parse_search_list(html)
|
||
return {"list": videos, "page": pg}
|
||
except Exception as e:
|
||
print(f"[歪比影视] searchContent 异常: {e}")
|
||
return {"list": [], "page": pg}
|
||
|
||
def detailContent(self, ids):
|
||
try:
|
||
vod_id = ids[0]
|
||
url = f"{self.BASE_URL}/detail/{vod_id}.html"
|
||
print(f"[歪比影视] 详情请求: {url}")
|
||
html = self._fetch_html(url)
|
||
if not html:
|
||
return {"list": []}
|
||
|
||
title = re.search(r'<h1>([^<]*)</h1>', html)
|
||
vod_name = title.group(1).strip() if title else "未知"
|
||
|
||
# 更宽松的图片匹配，兼容class变化
|
||
pic = re.search(r'<div[^>]*class="[^"]*module-item-pic[^"]*"[^>]*>.*?<img[^>]*data-original="([^"]+)"', html, re.DOTALL)
|
||
vod_pic = pic.group(1) if pic else ""
|
||
if vod_pic.startswith("//"):
|
||
vod_pic = "https:" + vod_pic
|
||
|
||
desc = re.search(r'<div[^>]*class="[^"]*module-info-introduction-content[^"]*"[^>]*>(.*?)</div>', html, re.DOTALL)
|
||
vod_content = self._clean_html(desc.group(1)) if desc else ""
|
||
|
||
actor = re.search(r'主演：</span>.*?<div[^>]*class="[^"]*module-info-item-content[^"]*"[^>]*>(.*?)</div>', html, re.DOTALL)
|
||
vod_actor = self._clean_html(actor.group(1)) if actor else ""
|
||
|
||
director = re.search(r'导演：</span>.*?<div[^>]*class="[^"]*module-info-item-content[^"]*"[^>]*>(.*?)</div>', html, re.DOTALL)
|
||
vod_director = self._clean_html(director.group(1)) if director else ""
|
||
|
||
year = re.search(r'<a[^>]*title="(\d{4})"', html)
|
||
vod_year = year.group(1) if year else ""
|
||
|
||
sources = self._parse_play_sources(html, vod_id)
|
||
if not sources:
|
||
print(f"[歪比影视] 未能解析到播放源")
|
||
return {"list": []}
|
||
|
||
from_list = []
|
||
url_list = []
|
||
for src in sources:
|
||
from_list.append(src["source_name"])
|
||
eps_str = "#".join([f"{ep['name']}${ep['link']}" for ep in src["episodes"]])
|
||
url_list.append(eps_str)
|
||
|
||
vod_play_from = "$$$".join(from_list)
|
||
vod_play_url = "$$$".join(url_list)
|
||
|
||
video = {
|
||
"vod_id": vod_id,
|
||
"vod_name": vod_name,
|
||
"vod_pic": vod_pic,
|
||
"vod_year": vod_year,
|
||
"vod_area": "",
|
||
"vod_actor": vod_actor,
|
||
"vod_director": vod_director,
|
||
"vod_content": vod_content,
|
||
"vod_play_from": vod_play_from,
|
||
"vod_play_url": vod_play_url,
|
||
}
|
||
print(f"[歪比影视] 详情解析成功: {vod_name}, 线路: {vod_play_from}")
|
||
return {"list": [video]}
|
||
except Exception as e:
|
||
print(f"[歪比影视] detailContent 异常: {e}")
|
||
return {"list": []}
|
||
|
||
def playerContent(self, flag, vid, vip_flags):
|
||
try:
|
||
parts = vid.split("-")
|
||
if len(parts) != 3:
|
||
return {"jx": 0, "parse": 0, "url": "", "header": ""}
|
||
vod_id, sid, nid = parts
|
||
play_url = self._get_play_url(vod_id, sid, nid)
|
||
if play_url:
|
||
# 判断URL类型，决定parse标志
|
||
# 如果是直接的视频文件或m3u8，parse=0；否则parse=1（需要TVBox嗅探/解析）
|
||
is_direct = any(ext in play_url.lower() for ext in ['.m3u8', '.mp4', '.flv', '.ts', '.mkv', '.avi', '.mov', '.wmv'])
|
||
is_direct = is_direct or 'm3u8' in play_url.lower() or 'mp4' in play_url.lower()
|
||
parse_flag = 0 if is_direct else 1
|
||
# header必须是JSON字符串
|
||
header_str = json.dumps(self.play_headers)
|
||
print(f"[歪比影视] 播放URL: {play_url[:80]}..., parse={parse_flag}")
|
||
return {"jx": 0, "parse": parse_flag, "url": play_url, "header": header_str}
|
||
return {"jx": 0, "parse": 0, "url": "", "header": ""}
|
||
except Exception as e:
|
||
print(f"[歪比影视] playerContent 异常: {e}")
|
||
return {"jx": 0, "parse": 0, "url": "", "header": ""}
|
||
|
||
def getName(self):
|
||
return "歪比影视"
|
||
|
||
def isVideoFormat(self, url):
|
||
pass
|
||
|
||
def manualVideoCheck(self):
|
||
pass
|
||
|
||
def destroy(self):
|
||
pass
|
||
|
||
def localProxy(self, param):
|
||
pass
|