podflow 2025.1.26__py3-none-any.whl

Podflow/download/dl_aideo_video.py

@@ -0,0 +1,307 @@
+# Podflow/download/dl_aideo_video.py
+# coding: utf-8
+
+import os
+from datetime import datetime
+import ffmpeg
+import yt_dlp
+from Podflow import gVar
+from Podflow.basic.write_log import write_log
+from Podflow.basic.get_duration import get_duration
+from Podflow.download.show_progress import show_progress
+from Podflow.message.fail_message_initialize import fail_message_initialize
+
+
+# 下载视频模块
+def download_video(
+    video_url,
+    output_dir,
+    output_format,
+    format_id,
+    video_website,
+    video_write_log,
+    sesuffix="",
+    cookies=None,
+    playlist_num=None,
+):
+    class MyLogger:
+        def debug(self, msg):
+            pass
+
+        def warning(self, msg):
+            pass
+
+        def info(self, msg):
+            pass
+
+        def error(self, msg):
+            msg = fail_message_initialize(msg, video_url).ljust(45)
+            print(msg)
+
+    outtmpl = f"channel_audiovisual/{output_dir}/{video_url}{sesuffix}.{output_format}"
+    ydl_opts = {
+        "outtmpl": outtmpl,  # 输出文件路径和名称
+        "format": f"{format_id}",  # 指定下载的最佳音频和视频格式
+        "noprogress": True,
+        "quiet": True,
+        "progress_hooks": [show_progress],
+        "logger": MyLogger(),
+        "throttled_rate": "70K",  # 设置最小下载速率为:字节/秒
+    }
+    if cookies:
+        if "www.bilibili.com" in video_website:
+            ydl_opts["http_headers"] = {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+                "Referer": "https://www.bilibili.com/",
+            }
+        elif "www.youtube.com" in video_website:
+            ydl_opts["http_headers"] = {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+                "Referer": "https://www.youtube.com/",
+            }
+        ydl_opts["cookiefile"] = cookies  # cookies 是你的 cookies 文件名
+    if playlist_num:  # 播放列表的第n个视频
+        ydl_opts["playliststart"] = playlist_num
+        ydl_opts["playlistend"] = playlist_num
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([f"{video_website}"])  # 下载指定视频链接的视频
+        return None, None
+    except Exception as download_video_error:
+        fail_info = fail_message_initialize(download_video_error, video_url).replace("\n","")
+        remove_info = ""
+        if fail_info in [
+            "",
+            "\033[31m请求拒绝\033[0m",
+            "\033[31m数据不完整\033[0m",
+            "\033[31m传输中断\033[0m",
+            "\033[31m请求超时\033[0m",
+            "\033[31m响应超时\033[0m",
+        ] and "www.youtube.com" in video_website:
+            if os.path.isfile(outtmpl):
+                os.remove(outtmpl)
+                remove_info = "|已删除失败文件"
+            elif os.path.isfile(outtmpl + ".part"):
+                os.remove(outtmpl + ".part")
+                remove_info = "|已删除部分失败文件"
+        write_log(
+            f"{video_write_log} \033[31m下载失败\033[0m",
+            None,
+            True,
+            True,
+            f"错误信息: {fail_info}{remove_info}",
+        )  # 写入下载失败的日志信息
+        return video_url, fail_info
+
+
+# 视频完整下载模块
+def dl_full_video(
+    video_url,
+    output_dir,
+    output_format,
+    format_id,
+    id_duration,
+    video_website,
+    video_write_log,
+    sesuffix="",
+    cookies=None,
+    playlist_num=None,
+):
+    video_id_failed, fail_info = download_video(
+        video_url,
+        output_dir,
+        output_format,
+        format_id,
+        video_website,
+        video_write_log,
+        sesuffix,
+        cookies,
+        playlist_num,
+    )
+    if video_id_failed:
+        return video_url, fail_info
+    duration_video = get_duration(
+        f"channel_audiovisual/{output_dir}/{video_url}{sesuffix}.{output_format}"
+    )  # 获取已下载视频的实际时长
+    if abs(id_duration - duration_video) <= 1:  # 检查实际时长与预计时长是否一致
+        return None, None
+    if duration_video:
+        fail_info = f"不完整({id_duration}|{duration_video}"
+        write_log(
+            f"{video_write_log} \033[31m下载失败\033[0m\n错误信息: {fail_info})"
+        )
+        os.remove(
+            f"channel_audiovisual/{output_dir}/{video_url}{sesuffix}.{output_format}"
+        )  # 删除不完整的视频
+    return video_url, fail_info
+
+
+# 视频重试下载模块
+def dl_retry_video(
+    video_url,
+    output_dir,
+    output_format,
+    format_id,
+    id_duration,
+    retry_count,
+    video_website,
+    video_write_log,
+    sesuffix="",
+    cookies=None,
+    playlist_num=None,
+):
+    video_id_failed, _ = dl_full_video(
+        video_url,
+        output_dir,
+        output_format,
+        format_id,
+        id_duration,
+        video_website,
+        video_write_log,
+        sesuffix,
+        cookies,
+        playlist_num,
+    )
+    # 下载失败后重复尝试下载视频
+    video_id_count = 0
+    while video_id_count < retry_count and video_id_failed:
+        if (
+            cookies is None
+            and "www.youtube.com" in video_website
+            and gVar.youtube_cookie
+        ):
+            cookies = "channel_data/yt_dlp_youtube.txt"
+        video_id_count += 1
+        if cookies:
+            write_log(f"{video_write_log} 第\033[34m{video_id_count}\033[0m次重新下载 🍪")
+        else:
+            write_log(f"{video_write_log} 第\033[34m{video_id_count}\033[0m次重新下载")
+        video_id_failed = dl_full_video(
+            video_url,
+            output_dir,
+            output_format,
+            format_id,
+            id_duration,
+            video_website,
+            video_write_log,
+            sesuffix,
+            cookies,
+            playlist_num,
+        )
+    return video_id_failed
+
+
+# 音视频总下载模块
+def dl_aideo_video(
+    video_url,
+    output_dir,
+    output_format,
+    video_format,
+    retry_count,
+    video_website,
+    output_dir_name="",
+    cookies=None,
+    playlist_num=None,
+    display_color="\033[95m",
+):
+    if output_dir_name:
+        video_write_log = f"{display_color}{output_dir_name}\033[0m|{video_url}"
+    else:
+        video_write_log = video_url
+    id_duration = video_format[0]
+    print_message = (
+        "\033[34m开始下载\033[0m 🍪" if cookies else "\033[34m开始下载\033[0m"
+    )
+    print(
+        f"{datetime.now().strftime('%H:%M:%S')}|{video_write_log} {print_message}",
+        end="",
+    )
+    if output_format == "m4a":
+        if video_format[1] in ["140", "30280"]:
+            print("")
+        else:
+            print(f" \033[97m{video_format[1]}\033[0m")
+        video_id_failed = dl_retry_video(
+            video_url,
+            output_dir,
+            "m4a",
+            video_format[1],
+            id_duration,
+            retry_count,
+            video_website,
+            video_write_log,
+            "",
+            cookies,
+            playlist_num,
+        )
+    else:
+        print(
+            f"\n{datetime.now().strftime('%H:%M:%S')}|\033[34m视频部分开始下载\033[0m \033[97m{video_format[2]}\033[0m"
+        )
+        video_id_failed = dl_retry_video(
+            video_url,
+            output_dir,
+            "mp4",
+            video_format[2],
+            id_duration,
+            retry_count,
+            video_website,
+            video_write_log,
+            ".part",
+            cookies,
+            playlist_num,
+        )
+        if video_id_failed is None:
+            print(
+                f"{datetime.now().strftime('%H:%M:%S')}|\033[34m音频部分开始下载\033[0m \033[97m{video_format[1]}\033[0m"
+            )
+            video_id_failed = dl_retry_video(
+                video_url,
+                output_dir,
+                "m4a",
+                video_format[1],
+                id_duration,
+                retry_count,
+                video_website,
+                video_write_log,
+                ".part",
+                cookies,
+                playlist_num,
+            )
+        if video_id_failed is None:
+            print(
+                f"{datetime.now().strftime('%H:%M:%S')}|\033[34m开始合成...\033[0m",
+                end="",
+            )
+            # 指定视频文件和音频文件的路径
+            video_file = f"channel_audiovisual/{output_dir}/{video_url}.part.mp4"
+            audio_file = f"channel_audiovisual/{output_dir}/{video_url}.part.m4a"
+            output_file = f"channel_audiovisual/{output_dir}/{video_url}.mp4"
+            try:
+                # 使用 ffmpeg-python 合并视频和音频
+                video = ffmpeg.input(video_file)
+                audio = ffmpeg.input(audio_file)
+                stream = ffmpeg.output(
+                    audio, video, output_file, vcodec="copy", acodec="copy"
+                )
+                ffmpeg.run(stream, quiet=True)
+                print(" \033[32m合成成功\033[0m")
+                # 删除临时文件
+                os.remove(f"channel_audiovisual/{output_dir}/{video_url}.part.mp4")
+                os.remove(f"channel_audiovisual/{output_dir}/{video_url}.part.m4a")
+            except ffmpeg.Error as dl_aideo_video_error:
+                video_id_failed = video_url
+                write_log(
+                    f"\n{video_write_log} \033[31m下载失败\033[0m\n错误信息: 合成失败:{dl_aideo_video_error}"
+                )
+    if video_id_failed is None:
+        if output_format == "m4a":
+            only_log = f" {video_format[1]}"
+        else:
+            only_log = f" {video_format[1]}+{video_format[2]}"
+        if cookies:
+            only_log += " Cookies"
+        write_log(
+            f"{video_write_log} \033[32m下载成功\033[0m", None, True, True, only_log
+        )  # 写入下载成功的日志信息
+    return video_id_failed

Podflow/download/show_progress.py

@@ -0,0 +1,46 @@
+# Podflow/download/show_progress.py
+# coding: utf-8
+
+from Podflow.basic.time_format import time_format
+from Podflow.download.convert_bytes import convert_bytes
+
+
+# 下载显示模块
+def show_progress(stream):
+    stream = dict(stream)
+    if "downloaded_bytes" in stream:
+        downloaded_bytes = convert_bytes(stream["downloaded_bytes"]).rjust(9)
+    else:
+        downloaded_bytes = " Unknow B"
+    if "total_bytes" in stream:
+        total_bytes = convert_bytes(stream["total_bytes"])
+    else:
+        total_bytes = "Unknow B"
+    if stream["speed"] is None:
+        speed = " Unknow B"
+    else:
+        speed = convert_bytes(stream["speed"], [" B", "KiB", "MiB", "GiB"], 1000).rjust(
+            9
+        )
+    if stream["status"] in ["downloading", "error"]:
+        if "total_bytes" in stream:
+            percent = stream["downloaded_bytes"] / stream["total_bytes"] * 100
+        else:
+            percent = 0
+        percent = f"{percent:.1f}" if percent == 100 else f"{percent:.2f}"
+        percent = percent.rjust(5)
+        eta = time_format(stream["eta"]).ljust(8)
+        print(
+            (
+                f"\r\033[94m{percent}%\033[0m|{downloaded_bytes}/{total_bytes}|\033[32m{speed}/s\033[0m|\033[93m{eta}\033[0m"
+            ),
+            end="",
+        )
+    if stream["status"] == "finished":
+        if "elapsed" in stream:
+            elapsed = time_format(stream["elapsed"]).ljust(8)
+        else:
+            elapsed = "Unknown "
+        print(
+            f"\r100.0%|{downloaded_bytes}/{total_bytes}|\033[32m{speed}/s\033[0m|\033[97m{elapsed}\033[0m"
+        )

Podflow/download/wait_animation.py

@@ -0,0 +1,34 @@
+# Podflow/download/wait_animation.py
+# coding: utf-8
+
+import time
+from datetime import datetime
+
+
+# 等待动画模块
+def wait_animation(stop_flag, wait_animation_display_info):
+    animation = "."
+    i = 1
+    prepare_youtube_print = datetime.now().strftime("%H:%M:%S")
+    while True:
+        if stop_flag[0] == "keep":
+            print(
+                f"\r{prepare_youtube_print}|{wait_animation_display_info}\033[34m准备中{animation.ljust(5)}\033[0m",
+                end="",
+            )
+        elif stop_flag[0] == "error":
+            print(
+                f"\r{prepare_youtube_print}|{wait_animation_display_info}\033[34m准备中{animation} \033[31m失败:\033[0m"
+            )
+            break
+        elif stop_flag[0] == "end":
+            print(
+                f"\r{prepare_youtube_print}|{wait_animation_display_info}\033[34m准备中{animation} 已完成\033[0m"
+            )
+            break
+        if i % 5 == 0:
+            animation = "."
+        else:
+            animation += "."
+        i += 1
+        time.sleep(0.5)

Podflow/download/youtube_and_bilibili_download.py

@@ -0,0 +1,30 @@
+# Podflow/download/youtube_and_bilibili_download.py
+# coding: utf-8
+
+from Podflow import gVar
+from Podflow.basic.write_log import write_log
+from Podflow.download.dl_aideo_video import dl_aideo_video
+
+
+# 下载YouTube和哔哩哔哩视频
+def youtube_and_bilibili_download():
+    for video_id, format_value in gVar.video_id_update_format.items():
+        if isinstance(format_value, dict) and format_value["main"] not in gVar.video_id_failed:
+            output_dir_name = format_value["name"]
+            display_color = "\033[35m" if format_value["backward_update"] else "\033[95m"
+            if dl_aideo_video(
+                video_id,
+                format_value["id"],
+                format_value["media"],
+                format_value["format"],
+                gVar.config["retry_count"],
+                format_value["download"]["url"],
+                output_dir_name,
+                format_value["cookie"],
+                format_value["download"]["num"],
+                display_color
+            ):
+                gVar.video_id_failed.append(format_value["main"])
+                write_log(
+                    f"{display_color}{output_dir_name}\033[0m|{video_id} \033[31m无法下载\033[0m"
+                )

Podflow/ffmpeg_judge.py

@@ -0,0 +1,45 @@
+# Podflow/ffmpeg_judge.py
+# coding: utf-8
+
+import sys
+import subprocess
+import shutil
+from Podflow.basic.write_log import write_log
+
+
+def error_ffmpeg_judge(ffmpeg_worry):
+    write_log("FFmpeg 未安装, 请安装后重试")
+    print(ffmpeg_worry)
+    sys.exit(0)
+
+
+def ffmpeg_judge():
+    ffmpeg_worry = """\033[0mFFmpeg安装方法:
+    Ubuntu:
+    \033[32msudo apt update
+    sudo apt install ffmpeg\033[0m
+    CentOS:
+    \033[32msudo yum update
+    sudo yum install ffmpeg\033[0m
+    Debian:
+    \033[32msudo apt-get update
+    sudo apt-get install ffmpeg\033[0m
+    Arch Linux、Fedora:
+    \033[32msudo pacman -S ffmpeg
+    sudo dnf install ffmpeg\033[0m
+    检查FFmpeg版本:
+    \033[32mffmpeg -version\033[0m"""
+
+    # 使用 shutil.which 检查 ffmpeg 是否安装
+    if shutil.which("ffmpeg") is None:
+        error_ffmpeg_judge(ffmpeg_worry)
+
+    try:
+        # 执行 ffmpeg 命令获取版本信息
+        result = subprocess.run(["ffmpeg", "-version"], capture_output=True, text=True, check=True)
+        output = result.stdout.lower()
+        # 检查输出中是否包含 ffmpeg 版本信息
+        if "ffmpeg version" not in output:
+            error_ffmpeg_judge(ffmpeg_worry)
+    except FileNotFoundError:
+        error_ffmpeg_judge(ffmpeg_worry)

Podflow/httpfs/__init__.py

@@ -0,0 +1,2 @@
+# Podflow/httpfs/__init__.py
+# coding: utf-8

Podflow/httpfs/app_bottle.py

@@ -0,0 +1,212 @@
+# Podflow/httpfs/app_bottle.py
+# coding: utf-8
+
+import os
+import hashlib
+from datetime import datetime
+import cherrypy
+from bottle import Bottle, abort, redirect, request, static_file
+from Podflow import gVar
+from Podflow.basic.write_log import write_log
+
+
+class bottle_app:
+    # Bottle和Cherrypy初始化模块
+    def __init__(self):
+        self.app_bottle = Bottle()  # 创建 Bottle 应用
+        self.bottle_print = []  # 存储打印日志
+        self.setup_routes()
+
+    def setup_routes(self):
+        self.app_bottle.route("/", callback=self.home)
+        self.app_bottle.route("/shutdown", callback=self.shutdown)
+        self.app_bottle.route("/favicon.ico", callback=self.favicon)
+        self.app_bottle.route("/<filename:path>", callback=self.serve_static)
+
+    # 判断token是否正确的验证模块
+    def token_judgment(self, token, VALID_TOKEN="", filename="", foldername=""):
+        if foldername != "channel_audiovisual/":
+            # 对于其他文件夹, 采用常规的 Token 验证
+            return VALID_TOKEN == "" or token == VALID_TOKEN
+        if (
+            VALID_TOKEN == ""
+            and token == hashlib.sha256(f"{filename}".encode()).hexdigest()
+        ):  # 如果没有配置 Token, 则使用文件名的哈希值
+            return True
+        elif (
+            token == hashlib.sha256(f"{VALID_TOKEN}/{filename}".encode()).hexdigest()
+        ):  # 使用验证 Token 和文件名的哈希值
+            return True
+        else:
+            return False
+
+    # 添加至bottle_print模块
+    def add_bottle_print(self, client_ip, filename, status):
+        # 后缀
+        suffixs = [".mp4", ".m4a", ".xml", ".ico"]
+        # 设置状态码对应的颜色
+        status_colors = {
+            200: "\033[32m",  # 绿色 (成功)
+            401: "\033[31m",  # 红色 (未经授权)
+            404: "\033[35m",  # 紫色 (未找到)
+            303: "\033[33m",  # 黄色 (重定向)
+            206: "\033[36m",  # 青色 (部分内容)
+        }
+        # 默认颜色
+        color = status_colors.get(status, "\033[0m")
+        status = f"{color}{status}\033[0m"
+        now_time = datetime.now().strftime("%H:%M:%S")
+        client_ip = f"\033[34m{client_ip}\033[0m"
+        if gVar.config["httpfs"]:
+            write_log(
+                f"{client_ip} {filename} {status}",
+                None,
+                False,
+                True,
+                None,
+                "httpfs.log",
+            )
+        for suffix in suffixs:
+            filename = filename.replace(suffix, "")
+        self.bottle_print.append(f"{now_time}|{client_ip} {filename} {status}")
+
+    # CherryPy 服务器打印模块
+    def cherry_print(self, flag_judgment=True):
+        if flag_judgment:
+            gVar.server_process_print_flag[0] = "keep"
+        if (
+            gVar.server_process_print_flag[0] == "keep" and self.bottle_print
+        ):  # 如果设置为保持输出, 则打印日志
+            print("\n".join(self.bottle_print))
+            self.bottle_print.clear()
+
+    # 主路由处理根路径请求
+    def home(self):
+        VALID_TOKEN = gVar.config["token"]  # 从配置中读取主验证 Token
+
+        # 输出请求日志的函数
+        def print_out(status):
+            client_ip = request.remote_addr  # 获取客户端 IP 地址
+            client_port = request.environ.get("REMOTE_PORT")  # 获取客户端端口
+            if client_port:
+                client_ip = f"{client_ip}:{client_port}"  # 如果有端口信息, 则包括端口
+            self.add_bottle_print(client_ip, "/", status)  # 添加日志信息
+            self.cherry_print(False)
+
+        token = request.query.get("token")  # 获取请求中的 Token
+        if self.token_judgment(token, VALID_TOKEN):  # 验证 Token
+            print_out(303)  # 如果验证成功, 输出 200 状态
+            return redirect("https://github.com/gruel-zxz/podflow")  # 返回正常响应
+        else:
+            print_out(401)  # 如果验证失败, 输出 401 状态
+            abort(401, "Unauthorized: Invalid Token")  # 返回未经授权错误
+
+    # 路由处理关闭服务器的请求
+    def shutdown(self):
+        Shutdown_VALID_TOKEN = "shutdown"
+        Shutdown_VALID_TOKEN += datetime.now().strftime("%Y%m%d%H%M%S")
+        Shutdown_VALID_TOKEN += os.urandom(32).hex()
+        Shutdown_VALID_TOKEN = hashlib.sha256(
+            Shutdown_VALID_TOKEN.encode()
+        ).hexdigest()  # 用于服务器关闭的验证 Token
+
+        # 输出关闭请求日志的函数
+        def print_out(status):
+            client_ip = request.remote_addr
+            client_port = request.environ.get("REMOTE_PORT")
+            if client_port:
+                client_ip = f"{client_ip}:{client_port}"
+            self.add_bottle_print(client_ip, "shutdown", status)
+            self.cherry_print(False)
+
+        token = request.query.get("token")  # 获取请求中的 Token
+        if self.token_judgment(
+            token, Shutdown_VALID_TOKEN
+        ):  # 验证 Token 是否为关闭用的 Token
+            print_out(200)  # 如果验证成功, 输出 200 状态
+            cherrypy.engine.exit()  # 使用 CherryPy 提供的停止功能来关闭服务器
+            return "Shutting down..."  # 返回关机响应
+        else:
+            print_out(401)  # 如果验证失败, 输出 401 状态
+            abort(401, "Unauthorized: Invalid Token")  # 返回未经授权错误
+
+    # 路由处理 favicon 请求
+    def favicon(self):
+        client_ip = request.remote_addr
+        if client_port := request.environ.get("REMOTE_PORT"):
+            client_ip = f"{client_ip}:{client_port}"
+        self.add_bottle_print(client_ip, "favicon.ico", 303)  # 输出访问 favicon 的日志
+        self.cherry_print(False)
+        return redirect(
+            "https://raw.githubusercontent.com/gruel-zxz/podflow/main/Podflow.png"
+        )  # 重定向到图标 URL
+
+    # 路由处理静态文件请求
+    def serve_static(self, filename):
+        VALID_TOKEN = gVar.config["token"]  # 从配置中读取主验证 Token
+        # 定义要共享的文件路径
+        bottle_filename = gVar.config["filename"]  # 从配置中读取文件名
+        shared_files = {
+            bottle_filename.lower(): f"{bottle_filename}.xml",  # 文件路径映射, 支持大小写不敏感的文件名
+            f"{bottle_filename.lower()}.xml": f"{bottle_filename}.xml",  # 同上, 支持带 .xml 后缀
+        }
+        bottle_channelid = (
+            gVar.channelid_youtube_ids_original
+            | gVar.channelid_bilibili_ids_original
+            | {"channel_audiovisual/": "", "channel_rss/": ""}
+        )  # 合并多个频道 ID
+        token = request.query.get("token")  # 获取请求中的 Token
+
+        # 输出文件请求日志的函数
+        def print_out(filename, status):
+            client_ip = request.remote_addr
+            client_port = request.environ.get("REMOTE_PORT")
+            if client_port:
+                client_ip = f"{client_ip}:{client_port}"
+            for (
+                bottle_channelid_key,
+                bottle_channelid_value,
+            ) in bottle_channelid.items():
+                filename = filename.replace(
+                    bottle_channelid_key, bottle_channelid_value
+                )  # 替换频道路径
+                if status == 200 and request.headers.get(
+                    "Range"
+                ):  # 如果是部分请求, 则返回 206 状态
+                    status = 206
+            self.add_bottle_print(client_ip, filename, status)  # 输出日志
+            self.cherry_print(False)
+
+        # 文件是否存在检查的函数
+        def file_exist(token, VALID_TOKEN, filename, foldername=""):
+            if self.token_judgment(
+                token, VALID_TOKEN, filename, foldername
+            ):  # 验证 Token
+                if os.path.exists(filename):  # 如果文件存在, 返回文件
+                    print_out(filename, 200)
+                    return static_file(filename, root=".")
+                else:  # 如果文件不存在, 返回 404 错误
+                    print_out(filename, 404)
+                    abort(404, "File not found")
+            else:  # 如果 Token 验证失败, 返回 401 错误
+                print_out(filename, 401)
+                abort(401, "Unauthorized: Invalid Token")
+
+        # 处理不同的文件路径
+        if filename in ["channel_audiovisual/", "channel_rss/"]:
+            print_out(filename, 404)
+            abort(404, "File not found")
+        elif filename.startswith("channel_audiovisual/"):
+            return file_exist(token, VALID_TOKEN, filename, "channel_audiovisual/")
+        elif filename.startswith("channel_rss/") and filename.endswith(".xml"):
+            return file_exist(token, VALID_TOKEN, filename)
+        elif filename.startswith("channel_rss/"):
+            return file_exist(token, VALID_TOKEN, f"{filename}.xml")
+        elif filename.lower() in shared_files:
+            return file_exist(token, VALID_TOKEN, shared_files[filename.lower()])
+        else:
+            print_out(filename, 404)  # 如果文件路径未匹配, 返回 404 错误
+            abort(404, "File not found")
+
+
+bottle_app_instance = bottle_app()