bili-dl 1.0.0__py3-none-any.whl

modules/ffmpeg_integration.py

@@ -0,0 +1,229 @@
+import os
+import subprocess
+import logging
+import shutil
+from typing import Dict, Optional, Tuple
+from config.config_manager import get_config
+
+class FFmpegIntegration:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.ffmpeg_config = get_config('ffmpeg', {})
+        self.ffmpeg_path = self._find_ffmpeg()
+        
+    def _find_ffmpeg(self) -> Optional[str]:
+        """查找ffmpeg可执行文件路径"""
+        # 首先检查配置中的路径
+        config_path = self.ffmpeg_config.get('path', 'auto')
+        if config_path != 'auto' and os.path.exists(config_path):
+            return config_path
+        
+        # 检查系统PATH中的ffmpeg
+        ffmpeg_executable = 'ffmpeg.exe' if os.name == 'nt' else 'ffmpeg'
+        ffmpeg_path = shutil.which(ffmpeg_executable)
+        
+        if ffmpeg_path:
+            return ffmpeg_path
+        
+        # 检查常见安装路径（Windows）
+        if os.name == 'nt':
+            common_paths = [
+                r'C:\Program Files\ffmpeg\bin\ffmpeg.exe',
+                r'C:\ffmpeg\bin\ffmpeg.exe',
+                r'D:\Program Files\ffmpeg\bin\ffmpeg.exe',
+            ]
+            for path in common_paths:
+                if os.path.exists(path):
+                    return path
+        
+        self.logger.warning("未找到ffmpeg，请安装ffmpeg并添加到PATH环境变量")
+        return None
+    
+    def check_ffmpeg_available(self) -> bool:
+        """检查ffmpeg是否可用"""
+        if not self.ffmpeg_path:
+            return False
+        
+        try:
+            result = subprocess.run(
+                [self.ffmpeg_path, '-version'],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.SubprocessError):
+            return False
+    
+    def merge_video_audio(self, video_path: str, audio_path: str, output_path: str) -> Tuple[bool, str]:
+        """合并视频和音频文件"""
+        if not self.check_ffmpeg_available():
+            return False, "ffmpeg不可用"
+        
+        if not os.path.exists(video_path) or not os.path.exists(audio_path):
+            return False, "输入文件不存在"
+        
+        try:
+            # 构建ffmpeg命令
+            cmd = [
+                self.ffmpeg_path,
+                '-i', video_path,    # 输入视频文件
+                '-i', audio_path,    # 输入音频文件
+                '-c', 'copy',        # 直接复制流，不重新编码
+                '-y',                # 覆盖输出文件
+                output_path          # 输出文件
+            ]
+            
+            self.logger.info(f"执行ffmpeg命令: {' '.join(cmd)}")
+            
+            # 执行ffmpeg命令
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            # 实时输出进度信息
+            while True:
+                output = process.stderr.readline()
+                if output == b'' and process.poll() is not None:
+                    break
+                if output:
+                    try:
+                        # 解码输出，尝试utf-8，如果失败则使用系统默认编码
+                        output_str = output.decode('utf-8', errors='ignore')
+                        # 解析进度信息（如果有）
+                        if 'time=' in output_str:
+                            time_info = output_str.split('time=')[1].split(' ')[0]
+                            print(f"\r合并进度: {time_info}", end='')
+                    except UnicodeDecodeError:
+                        # 如果utf-8解码失败，尝试其他编码
+                        try:
+                            output_str = output.decode('gbk', errors='ignore')
+                            if 'time=' in output_str:
+                                time_info = output_str.split('time=')[1].split(' ')[0]
+                                print(f"\r合并进度: {time_info}", end='')
+                        except:
+                            pass
+            
+            returncode = process.poll()
+            
+            if returncode == 0:
+                print("\n音视频合并完成！")
+                
+                # 检查是否需要删除临时文件
+                if self.ffmpeg_config.get('delete_temp_files', True):
+                    try:
+                        os.remove(video_path)
+                        os.remove(audio_path)
+                        self.logger.info("已删除临时文件")
+                    except Exception as e:
+                        self.logger.warning(f"删除临时文件失败: {e}")
+                
+                return True, "合并成功"
+            else:
+                try:
+                    error_output = process.stderr.read().decode('utf-8', errors='ignore')
+                except:
+                    error_output = process.stderr.read().decode('gbk', errors='ignore')
+                return False, f"ffmpeg执行失败: {error_output}"
+                
+        except Exception as e:
+            return False, f"合并过程异常: {str(e)}"
+    
+    def convert_to_mp4(self, input_path: str, output_path: str) -> Tuple[bool, str]:
+        """转换视频格式到MP4"""
+        if not self.check_ffmpeg_available():
+            return False, "ffmpeg不可用"
+        
+        if not os.path.exists(input_path):
+            return False, "输入文件不存在"
+        
+        try:
+            cmd = [
+                self.ffmpeg_path,
+                '-i', input_path,
+                '-c', 'copy',  # 直接复制，不重新编码
+                '-y',
+                output_path
+            ]
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=300  # 5分钟超时
+            )
+            
+            if result.returncode == 0:
+                return True, "转换成功"
+            else:
+                return False, f"转换失败: {result.stderr}"
+                
+        except subprocess.TimeoutExpired:
+            return False, "转换超时"
+        except Exception as e:
+            return False, f"转换过程异常: {str(e)}"
+    
+    def get_video_info(self, video_path: str) -> Optional[Dict]:
+        """获取视频文件信息"""
+        if not self.check_ffmpeg_available():
+            return None
+        
+        try:
+            cmd = [
+                self.ffmpeg_path,
+                '-i', video_path,
+                '-hide_banner'
+            ]
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            # 解析ffmpeg输出获取视频信息
+            info = {}
+            stderr = result.stderr
+            
+            # 解析时长
+            if 'Duration:' in stderr:
+                duration_line = stderr.split('Duration:')[1].split(',')[0].strip()
+                info['duration'] = duration_line
+            
+            # 解析视频流信息
+            if 'Video:' in stderr:
+                video_line = stderr.split('Video:')[1].split('\n')[0].strip()
+                info['video'] = video_line
+            
+            # 解析音频流信息
+            if 'Audio:' in stderr:
+                audio_line = stderr.split('Audio:')[1].split('\n')[0].strip()
+                info['audio'] = audio_line
+            
+            return info if info else None
+            
+        except Exception as e:
+            self.logger.error(f"获取视频信息失败: {e}")
+            return None
+
+# 全局ffmpeg集成实例
+ffmpeg_integration = FFmpegIntegration()
+
+def check_ffmpeg_available() -> bool:
+    """检查ffmpeg是否可用"""
+    return ffmpeg_integration.check_ffmpeg_available()
+
+def merge_video_audio(video_path: str, audio_path: str, output_path: str) -> Tuple[bool, str]:
+    """合并视频和音频文件"""
+    return ffmpeg_integration.merge_video_audio(video_path, audio_path, output_path)
+
+def convert_to_mp4(input_path: str, output_path: str) -> Tuple[bool, str]:
+    """转换视频格式到MP4"""
+    return ffmpeg_integration.convert_to_mp4(input_path, output_path)
+
+def get_video_info(video_path: str) -> Optional[Dict]:
+    """获取视频文件信息"""
+    return ffmpeg_integration.get_video_info(video_path)

modules/login_manager.py

@@ -0,0 +1,261 @@
+import requests
+import json
+import time
+import logging
+import qrcode
+import io
+import base64
+import os
+import sys
+import subprocess
+from typing import Dict, Optional, Tuple
+from urllib.parse import urlencode
+
+from config.config_manager import get_config, update_user_cookies, get_user_cookies
+
+class LoginManager:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': get_config('network.user_agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'),
+            'Referer': 'https://www.bilibili.com',
+            'Origin': 'https://www.bilibili.com'
+        })
+        self.logger = logging.getLogger(__name__)
+        
+        # 设置代理
+        proxy = get_config('network.proxy')
+        if proxy:
+            self.session.proxies = {'http': proxy, 'https': proxy}
+    
+    def check_login_status(self) -> bool:
+        """检查当前登录状态"""
+        try:
+            url = "https://api.bilibili.com/x/web-interface/nav"
+            response = self.session.get(url)
+            
+            if response.status_code == 200:
+                data = response.json()
+                return data.get('code') == 0 and data.get('data', {}).get('isLogin', False)
+            return False
+        except Exception as e:
+            self.logger.error(f"检查登录状态失败: {e}")
+            return False
+
+    def verify_cookie_availability(self) -> Tuple[bool, Optional[str]]:
+        """
+        验证Cookie可用性并返回状态和消息
+        
+        Returns:
+            Tuple[bool, Optional[str]]: (是否可用, 状态消息)
+        """
+        try:
+            # 测试获取用户信息（需要登录的API）
+            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:
+                    user_data = data.get('data', {})
+                    if user_data.get('isLogin', False):
+                        username = user_data.get('uname', '未知用户')
+                        return True, f"Cookie有效 - 已登录用户: {username}"
+                    else:
+                        return False, "Cookie已失效，需要重新登录"
+                else:
+                    return False, f"Cookie验证失败: {data.get('message', '未知错误')}"
+            else:
+                return False, f"HTTP请求失败: {response.status_code}"
+                
+        except Exception as e:
+            self.logger.error(f"Cookie验证异常: {e}")
+            return False, f"Cookie验证异常: {str(e)}"
+    
+    def get_qrcode_login_url(self) -> Tuple[Optional[str], Optional[str]]:
+        """获取二维码登录URL和oauthKey"""
+        try:
+            url = "https://passport.bilibili.com/x/passport-login/web/qrcode/generate"
+            response = self.session.get(url)
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('code') == 0:
+                    qrcode_url = data['data']['url']
+                    oauth_key = data['data']['qrcode_key']
+                    return qrcode_url, oauth_key
+            return None, None
+        except Exception as e:
+            self.logger.error(f"获取二维码登录URL失败: {e}")
+            return None, None
+    
+    def generate_qrcode_image(self, qrcode_url: str) -> Optional[str]:
+        """生成二维码图片文件并返回文件路径"""
+        try:
+            qr = qrcode.QRCode(
+                version=1,
+                error_correction=qrcode.constants.ERROR_CORRECT_L,
+                box_size=10,
+                border=4,
+            )
+            qr.add_data(qrcode_url)
+            qr.make(fit=True)
+            
+            img = qr.make_image(fill_color="black", back_color="white")
+            
+            # 保存为文件
+            qrcode_file = "qrcode.png"
+            img.save(qrcode_file)
+            
+            # 尝试自动打开图片
+            try:
+                if os.name == 'nt':  # Windows
+                    os.startfile(qrcode_file)
+                elif os.name == 'posix':  # macOS or Linux
+                    if sys.platform == 'darwin':  # macOS
+                        subprocess.run(['open', qrcode_file])
+                    else:  # Linux
+                        subprocess.run(['xdg-open', qrcode_file])
+            except Exception:
+                self.logger.warning("无法自动打开二维码图片，请手动查看")
+            
+            return qrcode_file
+        except Exception as e:
+            self.logger.error(f"生成二维码失败: {e}")
+            return None
+    
+    def check_qrcode_status(self, oauth_key: str) -> Tuple[bool, Optional[Dict]]:
+        """检查二维码扫描状态"""
+        try:
+            url = "https://passport.bilibili.com/x/passport-login/web/qrcode/poll"
+            params = {'qrcode_key': oauth_key}
+            response = self.session.get(url, params=params)
+            
+            if response.status_code == 200:
+                data = response.json()
+                code = data.get('code')
+                
+                if code == 0:  # 登录成功
+                    # 提取Cookie
+                    cookies = self._extract_cookies_from_response(response)
+                    if cookies:
+                        update_user_cookies(cookies)
+                        return True, data
+                elif code == 86101:  # 二维码未扫描
+                    return False, None
+                elif code == 86090:  # 二维码已扫描，等待确认
+                    return False, None
+                elif code == 86038:  # 二维码已过期
+                    return False, {'expired': True}
+            
+            return False, None
+        except Exception as e:
+            self.logger.error(f"检查二维码状态失败: {e}")
+            return False, None
+    
+    def password_login(self, username: str, password: str) -> bool:
+        """账号密码登录（需要验证码处理，这里简化实现）"""
+        # 注意：B站密码登录需要处理验证码，这里只提供框架
+        self.logger.warning("密码登录功能需要处理验证码，建议使用二维码登录")
+        return False
+    
+    def _extract_cookies_from_response(self, response: requests.Response) -> Dict[str, str]:
+        """从响应中提取Cookie"""
+        cookies = {}
+        for cookie in response.cookies:
+            if cookie.name in ['SESSDATA', 'bili_jct', 'DedeUserID', 'buvid3']:
+                cookies[cookie.name] = cookie.value
+        return cookies
+    
+    def set_cookies(self, cookies: Dict[str, str]) -> bool:
+        """设置Cookie到session"""
+        try:
+            self.session.cookies.update(cookies)
+            # 同时更新配置中的Cookie
+            return update_user_cookies(cookies)
+        except Exception as e:
+            self.logger.error(f"设置Cookie失败: {e}")
+            return False
+    
+    def get_session(self) -> requests.Session:
+        """获取当前session"""
+        return self.session
+    
+    def qrcode_login(self, timeout: int = 120) -> bool:
+        """二维码登录流程"""
+        print("开始二维码登录...")
+        
+        # 获取二维码
+        qrcode_url, oauth_key = self.get_qrcode_login_url()
+        if not qrcode_url or not oauth_key:
+            print("获取二维码失败")
+            return False
+        
+        # 生成并显示二维码
+        qrcode_image = self.generate_qrcode_image(qrcode_url)
+        if qrcode_image:
+            print("请使用B站APP扫描二维码登录")
+            print(f"二维码数据: {qrcode_image[:100]}...")  # 简化显示
+        else:
+            print(f"请手动打开链接: {qrcode_url}")
+        
+        # 轮询登录状态
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            success, status_data = self.check_qrcode_status(oauth_key)
+            
+            if success:
+                print("登录成功！")
+                return True
+            elif status_data and status_data.get('expired'):
+                print("二维码已过期，重新生成...")
+                return self.qrcode_login(timeout)
+            
+            print("等待扫描..." if not status_data else "已扫描，等待确认...")
+            time.sleep(3)
+        
+        print("登录超时")
+        return False
+
+# 全局登录管理器实例
+login_manager = LoginManager()
+
+def init_login() -> bool:
+    """初始化登录状态"""
+    # 首先尝试使用配置中的Cookie
+    cookies = get_user_cookies()
+    if cookies:
+        login_manager.set_cookies(cookies)
+        if login_manager.check_login_status():
+            print("使用保存的Cookie登录成功")
+            return True
+        else:
+            print("保存的Cookie已失效")
+    
+    # 如果需要自动登录
+    login_method = get_config('user.login_method', 'qrcode')
+    if login_method == 'qrcode':
+        success = login_manager.qrcode_login()
+        if success:
+            # 登录成功后，确保session包含最新的Cookie
+            cookies = get_user_cookies()
+            if cookies:
+                login_manager.set_cookies(cookies)
+        return success
+    elif login_method == 'password':
+        username = get_config('user.username')
+        password = get_config('user.password')
+        if username and password:
+            success = login_manager.password_login(username, password)
+            if success:
+                # 登录成功后，确保session包含最新的Cookie
+                cookies = get_user_cookies()
+                if cookies:
+                    login_manager.set_cookies(cookies)
+            return success
+    
+    return False
+
+def get_session() -> requests.Session:
+    """获取登录session"""
+    return login_manager.get_session()

modules/stream_downloader.py

@@ -0,0 +1,207 @@
+import requests
+import os
+import time
+import threading
+import logging
+from typing import Dict, Any, Optional, Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from config.config_manager import get_config
+from modules.login_manager import get_session
+
+class StreamDownloader:
+    def __init__(self):
+        self.session = get_session()
+        self.logger = logging.getLogger(__name__)
+        self.download_config = get_config('download', {})
+        
+    def download_file(self, url: str, filename: str, 
+                     chunk_size: int = 8192, 
+                     progress_callback: Optional[Callable] = None) -> bool:
+        """下载单个文件"""
+        try:
+            # 检查文件是否已存在（支持断点续传）
+            file_size = 0
+            if os.path.exists(filename):
+                file_size = os.path.getsize(filename)
+                self.logger.info(f"文件已存在，尝试断点续传: {filename} ({file_size} bytes)")
+            
+            headers = {}
+            if file_size > 0:
+                headers['Range'] = f'bytes={file_size}-'
+            
+            response = self.session.get(url, headers=headers, stream=True, timeout=self.download_config.get('timeout', 30))
+            
+            if response.status_code in [200, 206]:  # 200 OK or 206 Partial Content
+                total_size = int(response.headers.get('content-length', 0)) + file_size
+                downloaded_size = file_size
+                
+                mode = 'ab' if file_size > 0 else 'wb'
+                with open(filename, mode) as f:
+                    for chunk in response.iter_content(chunk_size=chunk_size):
+                        if chunk:
+                            f.write(chunk)
+                            downloaded_size += len(chunk)
+                            
+                            # 调用进度回调
+                            if progress_callback:
+                                progress_callback(downloaded_size, total_size, filename)
+                
+                self.logger.info(f"下载完成: {filename}")
+                return True
+            else:
+                self.logger.error(f"下载失败: HTTP {response.status_code}")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"下载文件异常 {filename}: {e}")
+            return False
+    
+    def download_with_retry(self, url: str, filename: str, 
+                           max_retries: int = 3,
+                           progress_callback: Optional[Callable] = None) -> bool:
+        """带重试机制的下载"""
+        retries = 0
+        while retries < max_retries:
+            try:
+                if self.download_file(url, filename, progress_callback=progress_callback):
+                    return True
+            except Exception as e:
+                self.logger.warning(f"下载尝试 {retries + 1} 失败: {e}")
+            
+            retries += 1
+            if retries < max_retries:
+                wait_time = 2 ** retries  # 指数退避
+                self.logger.info(f"等待 {wait_time} 秒后重试...")
+                time.sleep(wait_time)
+        
+        self.logger.error(f"下载失败，已达到最大重试次数: {max_retries}")
+        return False
+    
+    def download_multiple_files(self, file_list: list, max_workers: int = 4) -> Dict[str, bool]:
+        """多线程下载多个文件"""
+        results = {}
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # 提交所有下载任务
+            future_to_file = {
+                executor.submit(
+                    self.download_with_retry, 
+                    file_info['url'], 
+                    file_info['filename'],
+                    self.download_config.get('retry_times', 3)
+                ): file_info['filename']
+                for file_info in file_list
+            }
+            
+            # 收集结果
+            for future in as_completed(future_to_file):
+                filename = future_to_file[future]
+                try:
+                    results[filename] = future.result()
+                except Exception as e:
+                    self.logger.error(f"下载任务异常 {filename}: {e}")
+                    results[filename] = False
+        
+        return results
+    
+    def download_video_stream(self, stream_data: Dict[str, Any], title: str, 
+                            bvid: str, output_base_dir: str = 'download') -> Dict[str, str]:
+        """下载视频流（支持DASH和MP4格式）"""
+        try:
+            # 创建BV号子目录
+            from utils.common_utils import truncate_title, get_bvid_directory, ensure_directory
+            output_dir = get_bvid_directory(bvid, output_base_dir)
+            ensure_directory(output_dir)
+            
+            # 截断标题
+            truncated_title = truncate_title(title)
+            downloaded_files = {}
+            
+            if 'dash' in stream_data:
+                # DASH格式：分别下载视频和音频
+                dash_data = stream_data['dash']
+                
+                # 下载视频流
+                video_url = dash_data['video'][0]['baseUrl']
+                video_filename = os.path.join(output_dir, f"{truncated_title}_video.m4s")
+                downloaded_files['video'] = video_filename
+                
+                print(f"下载视频流: {video_filename}")
+                if not self.download_with_retry(video_url, video_filename):
+                    raise Exception("视频流下载失败")
+                
+                # 下载音频流
+                audio_url = dash_data['audio'][0]['baseUrl']
+                audio_filename = os.path.join(output_dir, f"{truncated_title}_audio.m4s")
+                downloaded_files['audio'] = audio_filename
+                
+                print(f"下载音频流: {audio_filename}")
+                if not self.download_with_retry(audio_url, audio_filename):
+                    raise Exception("音频流下载失败")
+                    
+            elif 'durl' in stream_data:
+                # MP4格式：直接下载完整文件
+                durl = stream_data['durl'][0]
+                video_url = durl['url']
+                final_filename = os.path.join(output_dir, f"{truncated_title}.mp4")
+                downloaded_files['video'] = final_filename
+                
+                print(f"下载MP4视频: {final_filename}")
+                if not self.download_with_retry(video_url, final_filename):
+                    raise Exception("MP4视频下载失败")
+            
+            else:
+                raise Exception("未知的视频流格式")
+            
+            return downloaded_files
+            
+        except Exception as e:
+            self.logger.error(f"下载视频流失败: {e}")
+            # 清理可能已下载的部分文件
+            for filename in downloaded_files.values():
+                if os.path.exists(filename):
+                    try:
+                        os.remove(filename)
+                    except:
+                        pass
+            raise
+    
+    def create_progress_callback(self, total_files: int = 1) -> Callable:
+        """创建进度回调函数"""
+        lock = threading.Lock()
+        completed_files = 0
+        
+        def progress_callback(downloaded: int, total: int, filename: str):
+            nonlocal completed_files
+            with lock:
+                if total > 0:
+                    percentage = (downloaded / total) * 100
+                    print(f"\r{filename}: {percentage:.1f}% ({downloaded}/{total} bytes)", end='')
+                    
+                    if downloaded >= total:
+                        completed_files += 1
+                        print(f"\n文件下载完成 ({completed_files}/{total_files})")
+        
+        return progress_callback
+
+# 全局下载器实例
+stream_downloader = StreamDownloader()
+
+def download_file(url: str, filename: str, progress_callback: Optional[Callable] = None) -> bool:
+    """下载单个文件"""
+    return stream_downloader.download_file(url, filename, progress_callback=progress_callback)
+
+def download_with_retry(url: str, filename: str, max_retries: int = 3, 
+                       progress_callback: Optional[Callable] = None) -> bool:
+    """带重试机制的下载"""
+    return stream_downloader.download_with_retry(url, filename, max_retries, progress_callback)
+
+def download_video_stream(stream_data: Dict[str, Any], title: str, bvid: str,
+                         output_base_dir: str = 'download') -> Dict[str, str]:
+    """下载视频流"""
+    return stream_downloader.download_video_stream(stream_data, title, bvid, output_base_dir)
+
+def create_progress_callback(total_files: int = 1) -> Callable:
+    """创建进度回调函数"""
+    return stream_downloader.create_progress_callback(total_files)