463 lines
15 KiB
Python
463 lines
15 KiB
Python
import time
|
||
import shutil
|
||
import requests
|
||
import json
|
||
import re
|
||
import sys
|
||
import os
|
||
import html
|
||
import tempfile
|
||
import asyncio
|
||
from pathlib import Path
|
||
from typing import Optional
|
||
import hashlib
|
||
from nonebot import on_message, logger
|
||
from nonebot.rule import to_me
|
||
from nonebot.adapters import Event
|
||
|
||
from yt_dlp import YoutubeDL
|
||
from httpx import AsyncClient
|
||
import msgspec
|
||
|
||
from .minio import upload_to_s3
|
||
|
||
# 匹配链接的正则
|
||
URL_PATTERN = re.compile(r"(https?://[^\s]+)")
|
||
pattern = r"QQ小程序(?:]|]|\])"
|
||
|
||
# 保留原有平台识别，同时加入抖音相关域名
|
||
VALID_HOSTS = [
|
||
"b23.tv",
|
||
"bilibili.com",
|
||
"youtube.com",
|
||
"youtu.be",
|
||
# douyin
|
||
"douyin.com",
|
||
"v.douyin.com",
|
||
"iesdouyin.com",
|
||
"m.douyin.com",
|
||
"jingxuan.douyin.com",
|
||
]
|
||
|
||
# 抖音短链识别
|
||
SHORT_LINK_PATTERN = re.compile(r"(v\.douyin\.com/[A-Za-z0-9_\-]+)")
|
||
# 从 HTML 提取路由数据
|
||
DOUYIN_ROUTER_PATTERN = re.compile(r"window\._ROUTER_DATA\s*=\s*(.*?)</script>", re.DOTALL)
|
||
|
||
video_handler = on_message(priority=10, block=False, rule=to_me())
|
||
|
||
|
||
@video_handler.handle()
|
||
async def handle_video_download(event: Event):
|
||
msg = str(event.get_message()).strip()
|
||
logger.info(f"获取到的消息：{msg}")
|
||
target_url: Optional[str] = None
|
||
|
||
# 提取 URL
|
||
if not re.search(pattern, msg):
|
||
urls = URL_PATTERN.findall(msg)
|
||
for u in urls:
|
||
logger.info(f"链接：{u}")
|
||
|
||
# 优先处理抖音（单独解析以获取直链）
|
||
if "douyin.com" in u or "v.douyin.com" in u or "iesdouyin.com" in u:
|
||
await video_handler.send("检测到链接，正在尝试下载视频，请稍候...")
|
||
try:
|
||
parsed_path = await parse_douyin(u)
|
||
if parsed_path:
|
||
# 抖音直接获取直链并且合并文件后返回文件地址后直接上传s3
|
||
logger.info(f"文件路径：{parsed_path}")
|
||
# 构建path对象
|
||
await video_handler.send(f"视频：{parsed_path.name} 已缓存\n正在生成下载链接，请耐心等待!")
|
||
s3_url = upload_to_s3(parsed_path)
|
||
await video_handler.send(f"{s3_url}")
|
||
break
|
||
else:
|
||
await video_handler.send(f"抖音解析失败或未找到直链：{u}")
|
||
logger.warning(f"抖音解析失败或未找到直链：{u}")
|
||
# 如果解析失败，继续尝试其他链接
|
||
continue
|
||
except Exception as e:
|
||
await video_handler.send(f"解析抖音链接时出错：{e}")
|
||
logger.exception(f"解析抖音链接时出错：{e}")
|
||
continue
|
||
|
||
# 非抖音走原逻辑
|
||
if any(domain in u for domain in VALID_HOSTS):
|
||
target_url = u
|
||
break
|
||
|
||
if not target_url:
|
||
return # 不处理无效链接
|
||
|
||
await video_handler.send("检测到链接，正在尝试下载视频，请稍候...")
|
||
else:
|
||
target_url = None
|
||
logger.info("检测到小程序")
|
||
url = await proc_xcx(msg)
|
||
logger.info(f"链接：{url}")
|
||
if url and any(domain in url for domain in VALID_HOSTS):
|
||
target_url = url
|
||
|
||
if not target_url:
|
||
return # 不处理无效链接
|
||
await video_handler.send("检测到视频，正在尝试下载视频，请稍候...")
|
||
|
||
try:
|
||
video_file = await download_video(target_url)
|
||
if not video_file:
|
||
await video_handler.send("视频下载失败。")
|
||
return
|
||
|
||
await video_handler.send(f"视频已缓存：{video_file.name}\n正在生成下载链接，请耐心等待!")
|
||
logger.info(f"文件路径：{video_file}")
|
||
s3_url = upload_to_s3(video_file)
|
||
logger.info(f"文件上传完成，返回链接：{s3_url}")
|
||
await video_handler.send(f"{s3_url}")
|
||
except Exception as e:
|
||
logger.exception(e)
|
||
await video_handler.send("下载过程中出现错误。")
|
||
|
||
|
||
async def download_video(url: str) -> Optional[Path]:
|
||
"""
|
||
如果 url 看起来是直接的媒体直链（如 mp4），则使用 httpx 直接下载；
|
||
否则回退到 yt-dlp 下载（兼容多平台），并支持：
|
||
1) Firefox cookies
|
||
2) cookies.txt 兜底
|
||
"""
|
||
|
||
# ---------- 1. 直链探测 ----------
|
||
direct_media_ext = re.search(r"\.(mp4|m3u8|ts|webm|mov|flv)(?:$|\?)", url, re.IGNORECASE)
|
||
is_direct = bool(direct_media_ext)
|
||
|
||
if not is_direct:
|
||
try:
|
||
async with AsyncClient(follow_redirects=True, timeout=30) as client:
|
||
head = await client.head(url, follow_redirects=True)
|
||
ctype = head.headers.get("content-type", "")
|
||
if ctype.startswith("video/") or "application/octet-stream" in ctype:
|
||
is_direct = True
|
||
except Exception:
|
||
is_direct = False
|
||
|
||
if is_direct:
|
||
temp_dir = tempfile.mkdtemp(prefix="direct_ytcache_")
|
||
ext = "mp4"
|
||
m = re.search(r"\.([a-zA-Z0-9]{2,5})(?:$|\?)", url)
|
||
if m and len(m.group(1)) <= 5:
|
||
ext = m.group(1)
|
||
|
||
filename = os.path.join(temp_dir, f"downloaded_video.{ext}")
|
||
|
||
try:
|
||
async with AsyncClient(follow_redirects=True, timeout=120) as client:
|
||
async with client.stream("GET", url) as resp:
|
||
resp.raise_for_status()
|
||
with open(filename, "wb") as fh:
|
||
async for chunk in resp.aiter_bytes(chunk_size=8192):
|
||
fh.write(chunk)
|
||
|
||
p = Path(filename)
|
||
new_path = p.with_name(clean_filename(p.name))
|
||
p.rename(new_path)
|
||
logger.info(f"直接下载完成: {new_path}")
|
||
return new_path
|
||
|
||
except Exception:
|
||
logger.exception("直接下载失败，回退 yt-dlp")
|
||
try:
|
||
if os.path.exists(filename):
|
||
os.remove(filename)
|
||
except Exception:
|
||
pass
|
||
|
||
# ---------- 2. yt-dlp 下载 ----------
|
||
temp_dir = tempfile.mkdtemp(prefix="ytcache_")
|
||
output_path = os.path.join(temp_dir, "%(title).80s.%(ext)s")
|
||
|
||
base_opts = {
|
||
"outtmpl": output_path,
|
||
"format": "bestvideo+bestaudio/best",
|
||
"noplaylist": True,
|
||
"quiet": True,
|
||
"ffmpeg_location": get_ffmpeg_path(),
|
||
"extractor_args": {
|
||
"youtube": {
|
||
"player_client": ["android"]
|
||
}
|
||
},
|
||
}
|
||
|
||
loop = asyncio.get_event_loop()
|
||
|
||
def _run_yt(opts: dict):
|
||
with YoutubeDL(opts) as ydl:
|
||
ydl.download([url])
|
||
|
||
# ---------- 2.1 优先：Firefox cookies ----------
|
||
try:
|
||
opts = dict(base_opts)
|
||
opts["cookiesfrombrowser"] = ("firefox",)
|
||
logger.info("尝试使用 Firefox cookies 下载")
|
||
await loop.run_in_executor(None, _run_yt, opts)
|
||
|
||
except Exception as e:
|
||
logger.warning(f"Firefox cookies 下载失败，尝试 cookies.txt：{e}")
|
||
|
||
# ---------- 2.2 回退：cookies.txt ----------
|
||
cookie_path = Path(__file__).resolve().parent / "cookies.txt"
|
||
if cookie_path.exists():
|
||
opts = dict(base_opts)
|
||
opts["cookiefile"] = str(cookie_path)
|
||
logger.info(f"使用 cookies 文件: {cookie_path}")
|
||
await loop.run_in_executor(None, _run_yt, opts)
|
||
else:
|
||
logger.error("未找到 cookies.txt，无法通过登录验证")
|
||
raise
|
||
|
||
# ---------- 3. 结果处理 ----------
|
||
files = list(Path(temp_dir).glob("*.*"))
|
||
if not files:
|
||
return None
|
||
|
||
original_file = files[0]
|
||
new_path = original_file.with_name(clean_filename(original_file.name))
|
||
original_file.rename(new_path)
|
||
logger.info(f"下载完成并重命名: {new_path}")
|
||
|
||
return new_path
|
||
|
||
|
||
def get_ffmpeg_path() -> str:
|
||
scripts_dir = os.path.dirname(sys.executable)
|
||
ffmpeg_path = os.path.join(scripts_dir, "ffmpeg.exe")
|
||
if os.path.exists(ffmpeg_path):
|
||
return ffmpeg_path
|
||
return "ffmpeg"
|
||
|
||
|
||
def clean_filename(filename: str) -> str:
|
||
return (
|
||
filename.replace(" ", "_")
|
||
.replace("&", "_")
|
||
.replace("#", "_")
|
||
.replace("'", "")
|
||
.replace('"', "")
|
||
.replace("?", "")
|
||
.replace(":", "_")
|
||
.replace("|", "_")
|
||
.replace("/", "_")
|
||
.replace("\\", "_")
|
||
.replace("*", "_")
|
||
.replace("<", "_")
|
||
.replace(">", "_")
|
||
.replace("【", "")
|
||
.replace("】", "")
|
||
.replace("：", "")
|
||
.replace("。", "")
|
||
.replace("，", "_")
|
||
.replace("《", "")
|
||
.replace("》", "")
|
||
.replace("？", "_")
|
||
.replace("｜", "")
|
||
)
|
||
|
||
|
||
async def proc_xcx(msg):
|
||
p_pattern = r'"qqdocurl":"(.*?)"'
|
||
match = re.search(p_pattern, msg)
|
||
|
||
if match:
|
||
raw_url = match.group(1)
|
||
unescaped = html.unescape(raw_url)
|
||
cleaned_url = unescaped.replace(r"\\/", "/")
|
||
base_url = cleaned_url.split("?")[0]
|
||
print("最终提取链接:", base_url)
|
||
return base_url
|
||
else:
|
||
print("未找到 qqdocurl 字段")
|
||
return None
|
||
|
||
|
||
# ----------------- Douyin parsing helpers -----------------
|
||
|
||
async def parse_douyin(url: str) -> Optional[str]:
|
||
"""
|
||
解析抖音链接，返回可直接下载的媒体直链（优先）或 None。
|
||
支持短链(v.douyin.com)、长链、iesdouyin、m.douyin 等。
|
||
"""
|
||
# 处理短链
|
||
short = SHORT_LINK_PATTERN.search(url)
|
||
if short:
|
||
short_url = "https://" + short.group(1)
|
||
try:
|
||
cookies_path = os.path.dirname(__file__).replace("\\", "/") + "/cookies.txt"
|
||
file_path = await fetch_douyin_mp4(short_url, cookies_path, 10)
|
||
return file_path
|
||
except Exception:
|
||
logger.exception("获取直链失败")
|
||
# 仍然尝试原始 url
|
||
|
||
# 现在尝试从页面抓取 router data
|
||
try:
|
||
logger.info(f"获取到的信息:{url}")
|
||
except Exception:
|
||
logger.exception("抖音页面解析失败")
|
||
return None
|
||
|
||
|
||
import asyncio
|
||
import tempfile
|
||
import aiohttp
|
||
import os
|
||
from typing import List, Dict, Optional
|
||
|
||
from playwright.async_api import async_playwright
|
||
import ffmpeg
|
||
|
||
|
||
class DouyinFetchError(Exception):
|
||
pass
|
||
|
||
|
||
def parse_netscape_cookies(cookies_txt_path: str) -> List[Dict]:
|
||
"""
|
||
解析 Netscape HTTP Cookie File -> Playwright cookies
|
||
"""
|
||
cookies: List[Dict] = []
|
||
|
||
with open(cookies_txt_path, "r", encoding="utf-8") as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
if not line or line.startswith("#"):
|
||
continue
|
||
|
||
parts = line.split("\t")
|
||
if len(parts) != 7:
|
||
continue
|
||
|
||
domain, include_sub, path, secure, expiry, name, value = parts
|
||
|
||
cookie = {
|
||
"name": name,
|
||
"value": value,
|
||
"domain": domain,
|
||
"path": path,
|
||
"secure": secure.upper() == "TRUE",
|
||
"httpOnly": False,
|
||
}
|
||
|
||
if expiry.isdigit() and int(expiry) > 0:
|
||
cookie["expires"] = int(expiry)
|
||
|
||
cookies.append(cookie)
|
||
|
||
return cookies
|
||
|
||
|
||
async def download_url(url: str, filepath: str, headers: Optional[Dict] = None):
|
||
headers = headers or {}
|
||
timeout = aiohttp.ClientTimeout(total=300)
|
||
|
||
async with aiohttp.ClientSession(timeout=timeout) as session:
|
||
async with session.get(url, headers=headers) as resp:
|
||
if resp.status != 200:
|
||
raise DouyinFetchError(f"下载失败 {resp.status}: {url}")
|
||
|
||
with open(filepath, "wb") as f:
|
||
async for chunk in resp.content.iter_chunked(1024 * 64):
|
||
f.write(chunk)
|
||
|
||
|
||
async def fetch_douyin_mp4(
|
||
douyin_url: str,
|
||
cookies_txt: str,
|
||
wait_seconds: int = 15,
|
||
) -> str:
|
||
"""
|
||
输入抖音 URL
|
||
输出：合并后的 MP4 临时文件路径
|
||
"""
|
||
|
||
cookies = parse_netscape_cookies(cookies_txt)
|
||
if not cookies:
|
||
raise DouyinFetchError("cookies.txt 解析失败或为空")
|
||
|
||
video_url: Optional[str] = None
|
||
audio_url: Optional[str] = None
|
||
|
||
async with async_playwright() as p:
|
||
browser = await p.chromium.launch(
|
||
executable_path="C:/Program Files/Google/Chrome/Application/chrome.exe",
|
||
headless=False,
|
||
args=[
|
||
"--autoplay-policy=no-user-gesture-required",
|
||
"--disable-features=AutoplayDisableSuppression",
|
||
"--use-fake-ui-for-media-stream",
|
||
]
|
||
)
|
||
|
||
context = await browser.new_context(
|
||
viewport={"width": 640, "height": 320},
|
||
user_agent=(
|
||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
|
||
"AppleWebKit/537.36 (KHTML, like Gecko) "
|
||
"Chrome/122.0.0.0 Safari/537.36"
|
||
),
|
||
)
|
||
|
||
await context.add_cookies(cookies)
|
||
page = await context.new_page()
|
||
|
||
def handle_response(response):
|
||
nonlocal video_url, audio_url
|
||
url = response.url
|
||
# 分轨视频
|
||
if video_url is None and ("video" in url and "mime_type=video_mp4" in url):
|
||
video_url = url
|
||
elif audio_url is None and ("audio" in url and "mime_type=audio" in url):
|
||
audio_url = url
|
||
|
||
page.on("response", handle_response)
|
||
|
||
await page.goto(douyin_url, wait_until="domcontentloaded")
|
||
await page.wait_for_timeout(wait_seconds * 1000)
|
||
await browser.close()
|
||
|
||
if not video_url:
|
||
raise DouyinFetchError("未捕获视频流 URL")
|
||
|
||
# -----------------------------
|
||
# 下载到临时文件
|
||
# -----------------------------
|
||
tmp_dir = Path(tempfile.gettempdir())
|
||
timestamp = int(time.time() * 1000)
|
||
|
||
tmp_video = tmp_dir / f"douyin/{timestamp}_video.mp4"
|
||
tmp_out = tmp_dir / f"douyin/{timestamp}_out.mp4"
|
||
|
||
# 下载视频
|
||
await download_url(video_url, tmp_video)
|
||
|
||
if audio_url:
|
||
tmp_audio = tmp_dir / f"{timestamp}_audio.m4a"
|
||
try:
|
||
await download_url(audio_url, tmp_audio)
|
||
(
|
||
ffmpeg
|
||
.input(tmp_video)
|
||
.output(tmp_audio, tmp_out, vcodec="copy", acodec="aac", movflags="faststart")
|
||
.overwrite_output()
|
||
.run(quiet=True)
|
||
)
|
||
finally:
|
||
tmp_video.unlink(missing_ok=True)
|
||
tmp_audio.unlink(missing_ok=True)
|
||
else:
|
||
# 视频自带音频，直接拷贝到输出
|
||
shutil.copy(tmp_video, tmp_out)
|
||
tmp_video.unlink(missing_ok=True)
|
||
|
||
return tmp_out
|