bili-dl 1.0.0__py3-none-any.whl

modules/video_info.py

@@ -0,0 +1,315 @@
+import requests
+import json
+import time
+import hashlib
+import logging
+from typing import Dict, Any, Optional, List
+from urllib.parse import urlencode
+
+from config.config_manager import get_config
+from modules.login_manager import get_session
+
+class VideoInfoManager:
+    def __init__(self):
+        self.session = get_session()
+        self.logger = logging.getLogger(__name__)
+        self.wbi_salt = ""  # WBI签名盐值
+        
+    def get_video_info(self, bvid: str) -> Dict[str, Any]:
+        """获取视频基本信息"""
+        try:
+            url = f"https://api.bilibili.com/x/web-interface/view?bvid={bvid}"
+            response = self.session.get(url)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('code') == 0:
+                    return data['data']
+                else:
+                    raise Exception(f"获取视频信息失败: {data.get('message', '未知错误')}")
+            else:
+                raise Exception(f"HTTP请求失败: {response.status_code}")
+        except Exception as e:
+            self.logger.error(f"获取视频信息异常: {e}")
+            raise
+    
+    def get_wbi_salt(self) -> Optional[str]:
+        """获取WBI签名盐值"""
+        try:
+            url = "https://api.bilibili.com/x/web-interface/nav"
+            response = self.session.get(url)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('code') == 0:
+                    wbi_img = data['data']['wbi_img']
+                    # 从URL中提取盐值
+                    if 'key1' in wbi_img['img_url'] and 'key2' in wbi_img['sub_url']:
+                        key1 = wbi_img['img_url'].split('key1=')[1].split('&')[0]
+                        key2 = wbi_img['sub_url'].split('key2=')[1].split('&')[0]
+                        return key1 + key2
+            return None
+        except Exception as e:
+            self.logger.error(f"获取WBI盐值失败: {e}")
+            return None
+    
+    def wbi_sign(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """WBI签名算法"""
+        if not self.wbi_salt:
+            self.wbi_salt = self.get_wbi_salt() or ""
+        
+        # 添加时间戳
+        params['wts'] = int(time.time())
+        
+        # 参数排序并过滤
+        filtered_params = {k: v for k, v in params.items() if v is not None and v != ""}
+        sorted_params = dict(sorted(filtered_params.items()))
+        
+        # 生成签名
+        query_string = urlencode(sorted_params)
+        sign_string = query_string + self.wbi_salt
+        w_rid = hashlib.md5(sign_string.encode()).hexdigest()
+        
+        # 添加签名到参数
+        signed_params = sorted_params.copy()
+        signed_params['w_rid'] = w_rid
+        return signed_params
+    
+    def get_video_stream_url(self, bvid: str, cid: int, quality: int = 80, fnval: int = 4048) -> Dict[str, Any]:
+        """
+        获取视频流地址
+        quality: 清晰度代码
+        fnval: 视频格式标识 (4048 = 所有DASH格式)
+        """
+        try:
+            # 构建参数
+            params = {
+                'bvid': bvid,
+                'cid': cid,
+                'qn': quality,
+                'fnval': fnval,
+                'fnver': 0,
+                'fourk': 1,
+                'otype': 'json',
+                'platform': 'pc'
+            }
+            
+            # WBI签名
+            signed_params = self.wbi_sign(params)
+            
+            url = "https://api.bilibili.com/x/player/wbi/playurl"
+            response = self.session.get(url, params=signed_params)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('code') == 0:
+                    return data['data']
+                else:
+                    raise Exception(f"获取视频流失败: {data.get('message', '未知错误')}")
+            else:
+                raise Exception(f"HTTP请求失败: {response.status_code}")
+        except Exception as e:
+            self.logger.error(f"获取视频流异常: {e}")
+            raise
+    
+    def get_highest_quality_available(self, stream_data: Dict[str, Any]) -> int:
+        """根据账号权限获取可用的最高清晰度"""
+        try:
+            if 'accept_quality' in stream_data:
+                available_qualities = stream_data['accept_quality']
+                
+                # 清晰度优先级（从高到低）
+                quality_priority = [
+                    127,  # 8K超高清
+                    126,  # 杜比视界
+                    125,  # HDR真彩色
+                    120,  # 4K超清
+                    116,  # 1080P60高帧率
+                    112,  # 1080P+高码率
+                    100,  # 智能修复
+                    80,   # 1080P高清
+                    74,   # 720P60高帧率
+                    64,   # 720P高清
+                    32,   # 480P清晰
+                    16,   # 360P流畅
+                    6     # 240P极速
+                ]
+                
+                # 找到账号权限内可用的最高清晰度
+                for quality in quality_priority:
+                    if quality in available_qualities:
+                        return quality
+                
+                # 如果没有找到优先级的清晰度，返回列表中的最高清晰度
+                return max(available_qualities) if available_qualities else 64
+            
+            return 64  # 默认返回720P
+        except Exception as e:
+            self.logger.error(f"获取最高清晰度失败: {e}")
+            return 64
+    
+    def get_video_quality_list(self, bvid: str, cid: int) -> List[Dict[str, Any]]:
+        """获取视频可用的清晰度列表"""
+        try:
+            stream_data = self.get_video_stream_url(bvid, cid)
+            
+            if 'accept_description' in stream_data and 'accept_quality' in stream_data:
+                qualities = []
+                for desc, quality in zip(stream_data['accept_description'], stream_data['accept_quality']):
+                    qualities.append({
+                        'quality': quality,
+                        'description': desc,
+                        'selected': False
+                    })
+                return qualities
+            return []
+        except Exception as e:
+            self.logger.error(f"获取清晰度列表失败: {e}")
+            return []
+    
+    def get_video_download_info(self, bvid: str) -> Dict[str, Any]:
+        """获取视频下载信息（整合视频信息和流信息）"""
+        try:
+            # 获取视频基本信息
+            video_info = self.get_video_info(bvid)
+            title = video_info['title']
+            cid = video_info['cid']
+            
+            # 获取流信息
+            stream_data = self.get_video_stream_url(bvid, cid)
+            
+            # 获取最高清晰度
+            best_quality = self.get_highest_quality_available(stream_data)
+            
+            # 使用最高清晰度重新获取流信息
+            if best_quality != 80:
+                stream_data = self.get_video_stream_url(bvid, cid, quality=best_quality)
+            
+            return {
+                'video_info': video_info,
+                'stream_data': stream_data,
+                'best_quality': best_quality,
+                'title': title,
+                'cid': cid,
+                'bvid': bvid
+            }
+        except Exception as e:
+            self.logger.error(f"获取视频下载信息失败: {e}")
+            raise
+
+    def get_video_download_info_with_fallback(self, bvid: str, ignore_login: bool = False) -> Dict[str, Any]:
+        """
+        获取视频下载信息，支持登录状态降级
+        
+        Args:
+            bvid: 视频BV号
+            ignore_login: 是否忽略登录状态，强制使用访客模式
+            
+        Returns:
+            视频下载信息，包含降级后的清晰度信息
+        """
+        try:
+            # 获取视频基本信息（不需要登录）
+            video_info = self.get_video_info(bvid)
+            title = video_info['title']
+            cid = video_info['cid']
+            
+            # 清晰度降级策略（从高到低）
+            fallback_qualities = [
+                127,  # 8K超高清
+                126,  # 杜比视界
+                125,  # HDR真彩色
+                120,  # 4K超清
+                116,  # 1080P60高帧率
+                112,  # 1080P+高码率
+                100,  # 智能修复
+                80,   # 1080P高清
+                74,   # 720P60高帧率
+                64,   # 720P高清
+                32,   # 480P清晰
+                16,   # 360P流畅
+                6     # 240P极速
+            ]
+            
+            last_exception = None
+            used_quality = None
+            
+            # 尝试从最高清晰度开始降级
+            for quality in fallback_qualities:
+                try:
+                    # 获取流信息
+                    stream_data = self.get_video_stream_url(bvid, cid, quality=quality)
+                    
+                    # 检查是否成功获取到流信息
+                    if stream_data and 'dash' in stream_data or 'durl' in stream_data:
+                        used_quality = quality
+                        break
+                        
+                except Exception as e:
+                    last_exception = e
+                    self.logger.debug(f"清晰度 {quality} 获取失败: {e}")
+                    continue
+            
+            # 如果所有清晰度都失败，抛出最后一个异常
+            if used_quality is None and last_exception:
+                raise last_exception
+            
+            # 如果使用了降级后的清晰度，重新获取流信息确保一致性
+            if used_quality != 80:
+                stream_data = self.get_video_stream_url(bvid, cid, quality=used_quality)
+            
+            return {
+                'video_info': video_info,
+                'stream_data': stream_data,
+                'best_quality': used_quality or 64,  # 默认720P
+                'title': title,
+                'cid': cid,
+                'bvid': bvid,
+                'is_fallback': used_quality != self.get_highest_quality_available(stream_data) if used_quality else False
+            }
+            
+        except Exception as e:
+            self.logger.error(f"获取视频下载信息（降级模式）失败: {e}")
+            
+            # 如果忽略登录状态，尝试使用最低清晰度
+            if ignore_login:
+                try:
+                    # 使用最低清晰度（360P）作为最后手段
+                    stream_data = self.get_video_stream_url(bvid, cid, quality=16)
+                    return {
+                        'video_info': video_info,
+                        'stream_data': stream_data,
+                        'best_quality': 16,
+                        'title': title,
+                        'cid': cid,
+                        'bvid': bvid,
+                        'is_fallback': True
+                    }
+                except Exception:
+                    # 如果连最低清晰度都失败，抛出原始异常
+                    raise e
+            else:
+                raise
+
+# 全局视频信息管理器实例
+video_info_manager = VideoInfoManager()
+
+def get_video_info(bvid: str) -> Dict[str, Any]:
+    """获取视频信息"""
+    return video_info_manager.get_video_info(bvid)
+
+def get_video_stream_url(bvid: str, cid: int, quality: int = 80, fnval: int = 4048) -> Dict[str, Any]:
+    """获取视频流地址"""
+    return video_info_manager.get_video_stream_url(bvid, cid, quality, fnval)
+
+def get_highest_quality_available(stream_data: Dict[str, Any]) -> int:
+    """获取最高可用清晰度"""
+    return video_info_manager.get_highest_quality_available(stream_data)
+
+def get_video_download_info(bvid: str) -> Dict[str, Any]:
+    """获取视频下载信息"""
+    return video_info_manager.get_video_download_info(bvid)
+
+def get_video_download_info_with_fallback(bvid: str, ignore_login: bool = False) -> Dict[str, Any]:
+    """获取视频下载信息，支持登录状态降级"""
+    return video_info_manager.get_video_download_info_with_fallback(bvid, ignore_login)

utils/common_utils.py

@@ -0,0 +1,199 @@
+import os
+import re
+import logging
+import json
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+def setup_logging(level: str = "INFO", log_file: Optional[str] = None) -> None:
+    """设置日志配置"""
+    log_level = getattr(logging, level.upper(), logging.INFO)
+    
+    # 基础配置
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    # 文件日志（如果指定）
+    if log_file:
+        file_handler = logging.FileHandler(log_file, encoding='utf-8')
+        file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+        logging.getLogger().addHandler(file_handler)
+
+def sanitize_filename(filename: str, max_length: int = 100) -> str:
+    """清理文件名，移除非法字符"""
+    # 移除非法字符
+    sanitized = re.sub(r'[<>:"/\\|?*]', '_', filename)
+    # 移除连续的下划线
+    sanitized = re.sub(r'_+', '_', sanitized)
+    # 移除首尾的下划线和空格
+    sanitized = sanitized.strip(' _')
+    # 限制长度
+    if len(sanitized) > max_length:
+        sanitized = sanitized[:max_length].rstrip(' _')
+    # 确保不为空
+    if not sanitized:
+        sanitized = "unnamed"
+    return sanitized
+
+def truncate_title(title: str, max_words: int = 8) -> str:
+    """截断标题，保留前N个字，其余用省略号"""
+    if len(title) <= max_words:
+        return title
+    return title[:max_words] + "..."
+
+def get_bvid_directory(bvid: str, base_dir: str = "download") -> str:
+    """获取BV号对应的下载目录"""
+    return os.path.join(base_dir, bvid)
+
+def format_file_size(size_bytes: int) -> str:
+    """格式化文件大小"""
+    if size_bytes == 0:
+        return "0B"
+    
+    size_names = ["B", "KB", "MB", "GB", "TB"]
+    i = 0
+    size = float(size_bytes)
+    
+    while size >= 1024 and i < len(size_names) - 1:
+        size /= 1024
+        i += 1
+    
+    return f"{size:.2f} {size_names[i]}"
+
+def format_duration(seconds: int) -> str:
+    """格式化时间持续时间"""
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    seconds = seconds % 60
+    
+    if hours > 0:
+        return f"{hours}:{minutes:02d}:{seconds:02d}"
+    else:
+        return f"{minutes}:{seconds:02d}"
+
+def ensure_directory(directory: str) -> bool:
+    """确保目录存在"""
+    try:
+        Path(directory).mkdir(parents=True, exist_ok=True)
+        return True
+    except Exception as e:
+        logging.error(f"创建目录失败 {directory}: {e}")
+        return False
+
+def read_json_file(file_path: str) -> Optional[Dict[str, Any]]:
+    """读取JSON文件"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        logging.error(f"读取JSON文件失败 {file_path}: {e}")
+        return None
+
+def write_json_file(file_path: str, data: Dict[str, Any], indent: int = 2) -> bool:
+    """写入JSON文件"""
+    try:
+        ensure_directory(os.path.dirname(file_path))
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=indent, ensure_ascii=False)
+        return True
+    except Exception as e:
+        logging.error(f"写入JSON文件失败 {file_path}: {e}")
+        return False
+
+def parse_bvid(input_str: str) -> Optional[str]:
+    """解析BV号"""
+    # 匹配BV号格式
+    bv_match = re.search(r'(BV[0-9A-Za-z]{10})', input_str)
+    if bv_match:
+        return bv_match.group(1)
+    
+    # 匹配URL中的BV号
+    url_match = re.search(r'bilibili\.com/video/(BV[0-9A-Za-z]{10})', input_str)
+    if url_match:
+        return url_match.group(1)
+    
+    return None
+
+def parse_av_id(input_str: str) -> Optional[str]:
+    """解析AV号"""
+    # 匹配AV号格式
+    av_match = re.search(r'(av\d+)', input_str, re.IGNORECASE)
+    if av_match:
+        return av_match.group(1).lower()
+    
+    # 匹配URL中的AV号
+    url_match = re.search(r'bilibili\.com/video/(av\d+)', input_str, re.IGNORECASE)
+    if url_match:
+        return url_match.group(1).lower()
+    
+    return None
+
+def is_valid_url(url: str) -> bool:
+    """检查是否为有效的URL"""
+    url_pattern = re.compile(
+        r'^(https?://)?'  # http:// or https://
+        r'(([A-Z0-9][A-Z0-9_-]*(?:\.[A-Z0-9][A-Z0-9_-]*)+)|'  # domain...
+        r'localhost|'  # localhost...
+        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'  # ...or ip
+        r'(?::\d+)?'  # optional port
+        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+    
+    return bool(url_pattern.match(url))
+
+def human_readable_speed(speed_bytes_per_sec: float) -> str:
+    """格式化下载速度"""
+    if speed_bytes_per_sec <= 0:
+        return "0 B/s"
+    
+    units = ["B/s", "KB/s", "MB/s", "GB/s"]
+    speed = speed_bytes_per_sec
+    unit_index = 0
+    
+    while speed >= 1024 and unit_index < len(units) - 1:
+        speed /= 1024
+        unit_index += 1
+    
+    return f"{speed:.2f} {units[unit_index]}"
+
+def progress_bar(current: int, total: int, length: int = 50) -> str:
+    """生成进度条字符串"""
+    if total <= 0:
+        return "[{}] 0%".format(" " * length)
+    
+    percent = current / total
+    filled_length = int(length * percent)
+    bar = "█" * filled_length + " " * (length - filled_length)
+    return "[{}] {:.1f}%".format(bar, percent * 100)
+
+def get_file_extension(url: str) -> str:
+    """从URL获取文件扩展名"""
+    # 移除查询参数
+    clean_url = url.split('?')[0]
+    # 获取扩展名
+    ext = os.path.splitext(clean_url)[1].lower()
+    return ext if ext else '.bin'
+
+def chunked_download_info(total_size: int, chunk_size: int = 1024 * 1024) -> List[Dict[str, int]]:
+    """生成分块下载信息"""
+    chunks = []
+    start = 0
+    
+    while start < total_size:
+        end = min(start + chunk_size - 1, total_size - 1)
+        chunks.append({'start': start, 'end': end, 'size': end - start + 1})
+        start = end + 1
+    
+    return chunks
+
+def validate_cookies(cookies: Dict[str, str]) -> bool:
+    """验证Cookie是否有效"""
+    required_cookies = ['SESSDATA', 'bili_jct', 'DedeUserID']
+    return all(cookie in cookies and cookies[cookie] for cookie in required_cookies)
+
+def format_timestamp(timestamp: int) -> str:
+    """格式化时间戳"""
+    from datetime import datetime
+    return datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')