podflow 20250307__py3-none-any.whl → 20250315__py3-none-any.whl

Podflow/__init__.py

@@ -114,8 +114,9 @@ class Application_gVar:
         self.overall_rss = ""  # 更新后的rss文本
         self.make_up_file_format = {}  # 补全缺失媒体字典
         self.make_up_file_format_fail = {}  # 补全缺失媒体失败字典
-        
+
         self.upload_original = []  # 原始上传信息字典
+        self.upload_data = {}  # 上传用户账号密码字典
 
         self.shortcuts_url = {}  # 输出至shortcut的url字典
 

Podflow/basic/write_log.py

@@ -3,7 +3,6 @@
 
 import re
 from datetime import datetime
-from Podflow.basic.file_save import file_save
 
 
 # 日志模块
@@ -19,23 +18,18 @@ def write_log(
     current_time = datetime.now()
     # 格式化输出, 只保留年月日时分秒
     formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S")
-    # 打开文件, 并读取原有内容
-    try:
-        with open(file_name, "r", encoding="utf-8") as file:
-            contents = file.read()
-    except FileNotFoundError:
-        contents = ""
     # 将新的日志内容添加在原有内容之前
     log_in = re.sub(r"\033\[[0-9;]+m", "", log)
     log_in = re.sub(r"\n", "", log_in)
-    only_log = re.sub(r"\033\[[0-9;]+m", "", str(only_log))
+    only_log = re.sub(r"\033\[[0-9;]+m", "", str(only_log)) if only_log else ""
     new_contents = (
-        f"{formatted_time} {log_in}{only_log}\n{contents}"
+        f"{formatted_time} {log_in}{only_log}\n"
         if only_log
-        else f"{formatted_time} {log_in}\n{contents}"
+        else f"{formatted_time} {log_in}\n"
     )
     # 将新的日志内容写入文件
-    file_save(new_contents, file_name)
+    with open(file_name, "a", encoding="utf-8") as file:
+        file.write(new_contents)
     if display:
         formatted_time_mini = current_time.strftime("%H:%M:%S")
         log_print = f"{formatted_time_mini}|{log}" if time_display else f"{log}"

Podflow/httpfs/app_bottle.py

@@ -5,9 +5,11 @@ import os
 import hashlib
 from datetime import datetime
 import cherrypy
-from bottle import Bottle, abort, redirect, request, static_file
+from bottle import Bottle, abort, redirect, request, static_file, response
 from Podflow import gVar
+from Podflow.upload.login import create
 from Podflow.basic.write_log import write_log
+from Podflow.upload.time_key import check_time_key
 
 
 class bottle_app:
@@ -15,16 +17,32 @@ class bottle_app:
     def __init__(self):
         self.app_bottle = Bottle()  # 创建 Bottle 应用
         self.bottle_print = []  # 存储打印日志
-        self.setup_routes()
+        self.setup_routes()  # 设置路由
+        self.logname = "httpfs.log"  # 默认日志文件名
+        self.http_fs = False
 
-    def setup_routes(self):
+    def setup_routes(self, upload=False):
+        # 设置/favicon.ico路由，回调函数为favicon
+        self.app_bottle.route("/favicon.ico", callback=self.favicon)
+        # 设置根路由，回调函数为home
         self.app_bottle.route("/", callback=self.home)
+        # 设置/shutdown路由，回调函数为shutdown
         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)
+        if upload:
+            self.app_bottle.route("/newuser", callback=self.new_user)
+            self.app_bottle.route("/login", callback=self.login)
+        else:
+            # 设置其他路由，回调函数为serve_static
+            self.app_bottle.route("/<filename:path>", callback=self.serve_static)
+
+    # 设置日志文件名及写入判断
+    def set_logname(self, logname="httpfs.log", http_fs=False):
+        self.logname = logname
+        self.http_fs = http_fs
 
     # 判断token是否正确的验证模块
     def token_judgment(self, token, VALID_TOKEN="", filename="", foldername=""):
+        # 判断 token 是否有效
         if foldername != "channel_audiovisual/":
             # 对于其他文件夹, 采用常规的 Token 验证
             return VALID_TOKEN == "" or token == VALID_TOKEN
@@ -57,14 +75,14 @@ class bottle_app:
         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"]:
+        if self.http_fs:
             write_log(
                 f"{client_ip} {filename} {status}",
                 None,
                 False,
                 True,
                 None,
-                "httpfs.log",
+                self.logname,
             )
         for suffix in suffixs:
             filename = filename.replace(suffix, "")
@@ -72,35 +90,61 @@ class bottle_app:
 
     # CherryPy 服务器打印模块
     def cherry_print(self, flag_judgment=True):
+        # 如果flag_judgment为True，则将gVar.server_process_print_flag[0]设置为"keep"
         if flag_judgment:
             gVar.server_process_print_flag[0] = "keep"
+        # 如果gVar.server_process_print_flag[0]为"keep"且self.bottle_print不为空，则打印日志
         if (
-            gVar.server_process_print_flag[0] == "keep"
-            and self.bottle_print
+            gVar.server_process_print_flag[0] == "keep" and self.bottle_print
         ):  # 如果设置为保持输出, 则打印日志
+            # 遍历self.bottle_print中的每个元素，并打印
             for info_print in self.bottle_print:
                 print(info_print)
+            # 清空self.bottle_print
             self.bottle_print.clear()
 
+    # 输出请求日志的函数
+    def print_out(self, filename, status):
+        client_ip = request.remote_addr
+        client_port = request.environ.get("REMOTE_PORT")
+        if client_port:
+            client_ip = f"{client_ip}:{client_port}"
+        if filename not in [
+            "favicon.ico",
+            "/",
+            "shutdown",
+            "newuser",
+            "login",
+        ]:
+            bottle_channelid = (
+                gVar.channelid_youtube_ids_original
+                | gVar.channelid_bilibili_ids_original
+                | {"channel_audiovisual/": "", "channel_rss/": ""}
+            )  # 合并多个频道 ID        
+            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 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 状态
+            self.print_out("/", 303)  # 如果验证成功, 输出 200 状态
             return redirect("https://github.com/gruel-zxz/podflow")  # 返回正常响应
         else:
-            print_out(401)  # 如果验证失败, 输出 401 状态
+            self.print_out("/", 401)  # 如果验证失败, 输出 401 状态
             abort(401, "Unauthorized: Invalid Token")  # 返回未经授权错误
 
     # 路由处理关闭服务器的请求
@@ -111,34 +155,21 @@ class bottle_app:
         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 状态
+            self.print_out("shutdown", 200)  # 如果验证成功, 输出 200 状态
             cherrypy.engine.exit()  # 使用 CherryPy 提供的停止功能来关闭服务器
             return "Shutting down..."  # 返回关机响应
         else:
-            print_out(401)  # 如果验证失败, 输出 401 状态
+            self.print_out("shutdown", 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)
+        self.print_out("favicon.ico", 303)  # 输出访问 favicon 的日志
         return redirect(
             "https://raw.githubusercontent.com/gruel-zxz/podflow/main/Podflow.png"
         )  # 重定向到图标 URL
@@ -152,51 +183,28 @@ class bottle_app:
             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=""):
+            # 验证 Token
             if self.token_judgment(
                 token, VALID_TOKEN, filename, foldername
             ):  # 验证 Token
+                # 如果文件存在, 返回文件
                 if os.path.exists(filename):  # 如果文件存在, 返回文件
-                    print_out(filename, 200)
+                    self.print_out(filename, 200)
                     return static_file(filename, root=".")
                 else:  # 如果文件不存在, 返回 404 错误
-                    print_out(filename, 404)
+                    self.print_out(filename, 404)
                     abort(404, "File not found")
             else:  # 如果 Token 验证失败, 返回 401 错误
-                print_out(filename, 401)
+                self.print_out(filename, 401)
                 abort(401, "Unauthorized: Invalid Token")
 
         # 处理不同的文件路径
         if filename in ["channel_audiovisual/", "channel_rss/"]:
-            print_out(filename, 404)
+            self.print_out(filename, 404)
             abort(404, "File not found")
         elif filename.startswith("channel_audiovisual/"):
             return file_exist(token, VALID_TOKEN, filename, "channel_audiovisual/")
@@ -207,8 +215,58 @@ class bottle_app:
         elif filename.lower() in shared_files:
             return file_exist(token, VALID_TOKEN, shared_files[filename.lower()])
         else:
-            print_out(filename, 404)  # 如果文件路径未匹配, 返回 404 错误
+            self.print_out(filename, 404)  # 如果文件路径未匹配, 返回 404 错误
             abort(404, "File not found")
 
+    # 路由获取账号密码请求
+    def new_user(self):
+        seed = "We need to generate an account password for uploading non one-time items that need to be saved."
+        token = request.query.get("token")  # 获取请求中的 Token
+        response.content_type = 'application/json'
+        
+        if check_time_key(token, seed):  # 验证 Token
+            username, password = create()  # 生成用户名和密码
+            self.print_out("newuser", 200)
+            return {
+                "code":0,
+                "message":"Get New Username And Password Success",
+                "data": {
+                    "username": username,
+                    "password": password,
+                },
+            }
+        else:
+            self.print_out("newuser", 401)
+            return {
+                "code":-1,
+                "message":"Unauthorized: Invalid Token",
+            }
+
+    # 路由处理登陆请求
+    def login(self):
+        upload_data = gVar.upload_data
+        username = request.query.get("username")
+        password = request.query.get("password")
+        
+        if username in upload_data:
+            if upload_data[username] == password:
+                self.print_out("login", 200)
+                return {
+                    "code":0,
+                    "message":"Login Success",
+                }
+            else:
+                self.print_out("login", 401)
+                return {
+                    "code":-3,
+                    "message":"Password Error",
+                }
+        else:
+            self.print_out("login", 401)
+            return {
+                "code":-2,
+                "message":"Username Error",
+            }
+
 
 bottle_app_instance = bottle_app()

Podflow/httpfs/port_judge.py

@@ -4,11 +4,18 @@
 import socket
 
 
+# 定义一个函数，用于判断指定IP地址和端口号是否可用
 def port_judge(hostip, port):
+    # 尝试创建一个socket对象
     try:
+        # 创建一个socket对象，指定地址族为IPv4，类型为TCP
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            # 设置socket选项，允许地址重用
             sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            # 绑定socket对象到指定的IP地址和端口号
             sock.bind((hostip, port))
+            # 如果绑定成功，返回True
             return True
+    # 如果绑定失败，捕获OSError异常，并返回False
     except OSError:
         return False

Podflow/main.py

@@ -1,33 +1,26 @@
 # coding: utf-8
 
-import signal
-import sys
-from datetime import datetime
 from importlib.metadata import version
 from Podflow import parse
 from Podflow.main_upload import main_upload
 from Podflow.main_podcast import main_podcast
 from Podflow.basic.time_print import time_print
+from Podflow.repair.reverse_log import reverse_log
 from Podflow.parse_arguments import parse_arguments
 
 
-def signal_handler(sig, frame):
-    time_print("Podflow被中断, 正在退出...")
-    sys.exit(0)
-
-
 def main():
-    # 注册SIGINT信号处理器（Ctrl+C）
-    signal.signal(signal.SIGINT, signal_handler)
-
     # 获取传入的参数
     parse_arguments()
     # 开始运行
     if parse.upload:
-        time_print("Podflow|接收服务开始运行.....")
+        time_print("Podflow|接收服务开始运行...")
+        reverse_log("upload")
         main_upload()
     else:
-        time_print(f"Podflow|{version('Podflow')}开始运行.....")
+        time_print(f"Podflow|{version('Podflow')} 开始运行...")
+        reverse_log("Podflow")
+        reverse_log("httpfs")
         main_podcast()
 
 

Podflow/main_podcast.py

@@ -6,13 +6,13 @@ import json
 import time
 import urllib
 import subprocess
-from datetime import datetime
 
 import cherrypy
 
 # 基本功能模块
 from Podflow import gVar, parse
 from Podflow.basic.split_dict import split_dict
+from Podflow.basic.time_print import time_print
 
 # 网络和 HTTP 模块
 from Podflow.httpfs.port_judge import port_judge
@@ -68,6 +68,13 @@ def main_podcast():
     port = gVar.config["port"]
     hostip = "0.0.0.0"
     if port_judge(hostip, port):
+        # 设置路由
+        bottle_app_instance.setup_routes(upload=False)
+        # 设置logname
+        bottle_app_instance.set_logname(
+            logname="httpfs.log",
+            http_fs=gVar.config["httpfs"],
+        )
         # 启动 CherryPy 服务器
         cherrypy.tree.graft(
             bottle_app_instance.app_bottle
@@ -85,16 +92,12 @@ def main_podcast():
             }
         )
         cherrypy.engine.start()  # 启动 CherryPy 服务器
-        print(
-            f"{datetime.now().strftime('%H:%M:%S')}|HTTP服务器启动, 端口: \033[32m{port}\033[0m"
-        )
+        time_print(f"HTTP服务器启动, 端口: \033[32m{port}\033[0m")
         if parse.httpfs:  # HttpFS参数判断, 是否继续运行
             cherrypy.engine.block()  # 阻止程序退出, 保持HTTP服务运行
             sys.exit(0)
     else:
-        print(
-            f"{datetime.now().strftime('%H:%M:%S')}|HTTP服务器端口: \033[32m{port}\033[0m, \033[31m被占用\033[0m"
-        )
+        time_print(f"HTTP服务器端口: \033[32m{port}\033[0m, \033[31m被占用\033[0m")
         if parse.httpfs:
             sys.exit(0)
     # 主流程
@@ -191,7 +194,7 @@ def main_podcast():
             # 更新并保存上传列表
             update_upload()
         else:
-            print(f"{datetime.now().strftime('%H:%M:%S')}|频道无更新内容")
+            time_print("频道无更新内容")
 
         # 将需要更新转为否
         gVar.update_generate_rss = False
@@ -215,4 +218,4 @@ def main_podcast():
             time.sleep(parse.time_delay)
     # 关闭CherryPy服务器
     cherrypy.engine.exit()
-    print(f"{datetime.now().strftime('%H:%M:%S')}|Podflow运行结束")
+    time_print("Podflow运行结束")

Podflow/main_upload.py

@@ -2,24 +2,56 @@
 # coding: utf-8
 
 import sys
-import threading
+import cherrypy
+from Podflow.upload.login import get_login
 from Podflow.basic.time_print import time_print
+from Podflow.basic.folder_build import folder_build
+from Podflow.httpfs.app_bottle import bottle_app_instance
 from Podflow.upload.linked_server import handle_discovery, usable_port
 
 
 def main_upload():
+    # 构建文件夹channel_audiovisual
+    folder_build("channel_audiovisual")
+    # 构建文件夹channel_data
+    folder_build("channel_data")
+    # 获取账号密码
+    get_login()
     # 服务发现相关配置
     broadcast_port = 37001  # 服务发现用端口
     service_port = 5000  # 实际服务端口
+    hostip = "0.0.0.0"
 
     broadcast_port = usable_port(broadcast_port, 37010)
     service_port = usable_port(service_port, 5010)
+
     if broadcast_port and service_port:
-        discovery_thread = threading.Thread(
-            target=handle_discovery,
-            args=(broadcast_port, service_port),
+        # 设置路由
+        bottle_app_instance.setup_routes(upload=True)
+        # 设置logname
+        bottle_app_instance.set_logname(
+            logname="upload.log",
+            http_fs=True,
+        )
+        # 启动 CherryPy 服务器
+        cherrypy.tree.graft(
+            bottle_app_instance.app_bottle
+        )  # 将 Bottle 应用嵌入到 CherryPy 中
+        cherrypy.config.update(
+            {
+                "global": {
+                    "tools.sessions.on": True,  # 启用会话支持
+                    "server.socket_host": hostip,  # 监听所有 IP 地址
+                    "server.socket_port": service_port,  # 设置监听端口
+                    "log.screen": False,  # 禁用屏幕日志输出
+                    "log.access_file": "",  # 关闭访问日志
+                    "log.error_file": "",  # 关闭错误日志
+                }
+            }
         )
-        #discovery_thread.start()
+        cherrypy.engine.start()  # 启动 CherryPy 服务器
+        time_print(f"上传服务已启动|端口: \033[32m{service_port}\033[0m")
+        # 服务发现
         handle_discovery(broadcast_port, service_port)
     else:
         if not broadcast_port:

Podflow/repair/__init__.py

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

Podflow/repair/reverse_log.py

@@ -0,0 +1,31 @@
+# Podflow/repair/reverse_log.py
+# coding: utf-8
+
+import re
+from Podflow.basic.time_print import time_print
+
+
+def reverse_log(filename):
+    try:
+        with open(f"{filename}.log", "r", encoding="utf-8") as file:
+            lines = file.readlines()
+    except Exception:
+        return
+    num = 0
+    end_num = len(lines) - 1
+
+    def date_time(num):
+        pattern = r"^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])\s(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"
+        date_str = lines[num][:19]
+        return re.match(pattern, date_str)
+
+    while not date_time(num):
+        num += 1
+    while not date_time(end_num):
+        end_num -= 1
+    if end_num > num and lines[num][:19] > lines[end_num][:19]:
+        # 反转行的顺序
+        reversed_lines = lines[::-1]
+        with open(f"{filename}.log", "w", encoding="utf-8") as file:
+            file.writelines(reversed_lines)
+            time_print(f"{filename}.log反转成功")

Podflow/upload/linked_client.py

@@ -10,7 +10,7 @@ from Podflow.upload.time_key import time_key
 from Podflow.basic.time_print import time_print
 
 
-BROADCAST_PORT = 37000
+BROADCAST_PORT = 37001
 TIMEOUT = 1  # 搜索超时时间（秒）
 MAX_BROADCAST_PORT = 37010  # 尝试广播的最大端口
 

Podflow/upload/linked_server.py

@@ -33,9 +33,9 @@ def handle_discovery(broadcast_port, service_port):
         # 设置套接字选项，允许广播
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
         # 绑定套接字到广播端口
-        sock.bind(("", broadcast_port))
+        sock.bind(("0.0.0.0", broadcast_port))
         # 打印发现服务已启动
-        time_print("发现服务已启动...")
+        time_print(f"发现服务已启动|端口: \033[32m{broadcast_port}\033[0m")
         # 无限循环，等待接收广播消息
         while True:
             # 接收广播消息
@@ -45,11 +45,11 @@ def handle_discovery(broadcast_port, service_port):
             # 检查消息是否包含时间关键字
             if check_time_key(data ,"PODFLOW_DISCOVER_SERVER_REQUEST"):
                 # 打印接收到的发现请求成功
-                time_print(f"来自{addr}的发现请求\033[32m成功\033[0m")
+                time_print(f"来自{addr[0]}的发现请求\033[32m成功\033[0m")
                 # 构造响应消息
                 response = f"PODFLOW_SERVER_INFO|{service_port}".encode()
                 # 发送响应消息
                 sock.sendto(response, addr)
             else:
                 # 打印接收到的发现请求失败
-                time_print(f"来自{addr}的发现请求\033[31m失败\033[0m")
+                time_print(f"来自{addr[0]}的发现请求\033[31m失败\033[0m")

Podflow/upload/login.py

@@ -0,0 +1,28 @@
+# Podflow/upload/login.py
+# coding: utf-8
+
+import os
+import json
+import uuid
+import hashlib
+from Podflow import gVar
+from Podflow.basic.file_save import file_save
+
+
+def get_login():
+    try:
+        with open("channel_data/upload_login.json", "r") as file:
+            upload_data = file.read()
+        gVar.upload_data = json.loads(upload_data)
+    except Exception:
+        file_save(gVar.upload_data, "upload_login.json", "channel_data")
+
+
+def create():
+    new_username = str(uuid.uuid4())
+    while new_username in gVar.upload_data:
+        new_username = str(uuid.uuid4())
+    new_password = hashlib.sha256(os.urandom(64)).hexdigest()
+    gVar.upload_data[new_username] = new_password
+    file_save(gVar.upload_data, "upload_login.json", "channel_data")
+    return new_username, new_password

{podflow-20250307.dist-info → podflow-20250315.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: podflow
-Version: 20250307
+Version: 20250315
 Summary: A podcast server that includes YouTube and BiliBili
 Home-page: https://github.com/gruel-zxz/podflow
 Author: gruel_zxz

{podflow-20250307.dist-info → podflow-20250315.dist-info}/RECORD

@@ -1,9 +1,9 @@
-Podflow/__init__.py,sha256=fRgwxrydKSb9rK_ZsZsb2XhbGEgxxTYKmLB4f88fg0M,6908
+Podflow/__init__.py,sha256=-TdRoLAAMAPVNx2S2qSWR2vN-ZRD8wsEjZR4X1-7U1Q,6964
 Podflow/download_and_build.py,sha256=LeLjLHnF5N9vdrroDsB-mT4UKY2OwPSL3APUAkhTuwc,671
 Podflow/ffmpeg_judge.py,sha256=krttVs1PDot_0CDq5rmtUIpchiaiqtAkPYFQRLG6OQM,1275
-Podflow/main.py,sha256=Cn-7MQRcWU4o-gJLk1pAw9TcW4IJXhu1G6Ua49xh2No,853
-Podflow/main_podcast.py,sha256=ibiLtMG2Og07A-sAjS4a9jbrkz0qP9B33pemq-N85KE,8385
-Podflow/main_upload.py,sha256=nOM8sm5xHg0Qqqq5mKVS7CdmgY8vZ96wunSeTJ9CHeE,1029
+Podflow/main.py,sha256=tevbRqCDPuIrKuViI1Zm2lfdfjushYd7Nai6xZCGF4k,739
+Podflow/main_podcast.py,sha256=6p-JrDfLVOYic_X_wsVrtjOZKH1SbMRWOEe7KO2vsZQ,8455
+Podflow/main_upload.py,sha256=9FoIEO7kRwGwyyF-KKKEz5vRO9vE9_ab2VE6xTMroeM,2296
 Podflow/parse_arguments.py,sha256=H2OXiOIHUuEUKOD0fk3zt_m1VsorGkL0eTcvx4N_C3Y,2441
 Podflow/basic/__init__.py,sha256=SyFA_F_0-zn1VejCL83IPeZx1k2HCiqNY-0l0bp1N88,44
 Podflow/basic/file_save.py,sha256=mstWM6njYtCpq2sa28JD_neClvVLcjJOrGlCXBjUnZs,696
@@ -19,7 +19,7 @@ Podflow/basic/time_format.py,sha256=Rddq-5wQgo6IrgiMlcMgDA52vQnMvWZvZC8g1Bj3BaQ,
 Podflow/basic/time_print.py,sha256=2M22bcHRNEkaTZ1lvbHEILUYXEQImJJmOzHa9kamDR8,323
 Podflow/basic/time_stamp.py,sha256=vf0p6FIK2-ZN2p2sotbpf4dewQMy-Vior-aREYfT0Zc,1888
 Podflow/basic/vary_replace.py,sha256=aecFDuAOvQjTpgtoSW5uDu8Tx_YTs4bCFF9imVFkfVY,211
-Podflow/basic/write_log.py,sha256=X5WuJSxW8r4aespwhDUsSdByMfMi87ihjF6P86uhZbI,1363
+Podflow/basic/write_log.py,sha256=3S7afoJvVHAGRa8SV9y71YL2_P_QvQ4QXn6LQUTTmlM,1169
 Podflow/bilibili/__init__.py,sha256=ekvpCzR4bg6ar73Gq0YWQcPXND4TEqP46pb9iLyke9g,47
 Podflow/bilibili/build.py,sha256=Oeh6Cqb61F5zQWe8ohDP0QKwykAa4_I2fa-Yl6ZxkCw,7957
 Podflow/bilibili/get.py,sha256=PXPh_H8B_zP9dhqe6sA_QCeJcdnriBCpbF7mPq46xMw,20337
@@ -40,8 +40,8 @@ Podflow/download/show_progress.py,sha256=7oGzhj_frO2A1o5JeGuHn7bHtma5oPpD_IWcctI
 Podflow/download/wait_animation.py,sha256=E2V3cm-10e5Iif40oU722OfzDe7YiLMbDqsjZ6dshBE,1056
 Podflow/download/youtube_and_bilibili_download.py,sha256=0uuEO2ybyLlg9uOButjqFvmIkCfq6xiQ7QLV2_u4c_M,1294
 Podflow/httpfs/__init__.py,sha256=agnAtd2Xe0qfOrElKgoBattAVqUBdj79wU2e2UOpcJM,45
-Podflow/httpfs/app_bottle.py,sha256=B5rGSxSNFbrjZfmtH7GVYdHCNDZ0T_7Jxrh4_oM8-FU,9333
-Podflow/httpfs/port_judge.py,sha256=KozmaCGlMVh3E0ONekxSUstJWthhwdLK4WoJ84u1c5Q,349
+Podflow/httpfs/app_bottle.py,sha256=ZkCRXYrBJFUEatboUEB6Og35JoguWGnnuxImFLflsVA,11424
+Podflow/httpfs/port_judge.py,sha256=RrBTxD6lXHbkfiDMu69-EUv0kbflfu1HpPfpB5Wz3MU,764
 Podflow/makeup/__init__.py,sha256=HaBchKbUjRqqXSGCkMfEqLOyx3tlqB2htXvTDs59owI,45
 Podflow/makeup/del_makeup_format_fail.py,sha256=rUSJD5lXMBM5pCde1amrtF6s93MMHp66-NHCXZy56AI,642
 Podflow/makeup/make_up_file.py,sha256=6r5Mf_zK9snLS2hByD-HyKyuKWTccqqDJXh39GKhq28,2222
@@ -75,19 +75,22 @@ Podflow/netscape/get_cookie_dict.py,sha256=ptT2H8ZwFseK8EmpH0jn-lhzh-KCciOOPwpAJ
 Podflow/remove/__init__.py,sha256=kns-jfTXH8lXh9OQ5E5-llsrAPlET5rl6RYpjoZKav8,45
 Podflow/remove/remove_dir.py,sha256=tah3LCD0bCcf5dDg3NrHuseaje3-31C5NLNupMg15TU,1099
 Podflow/remove/remove_file.py,sha256=ACO2iK8RAZKGJ08uABbzGwu5-B0RLklQ-EOOkSuPFiU,982
+Podflow/repair/__init__.py,sha256=sfrjrUGdBuCri8x51oassbkHJMDqmEp0MMZHodMxYNM,45
+Podflow/repair/reverse_log.py,sha256=nGVM4DOcnPz-VXJG6aHoKc1E461edYlaYoQYx7i6atQ,957
 Podflow/upload/__init__.py,sha256=9uOIL8vr_vP_XYrhfZ4IDZmfSGyCf0_MpLOc-KnbpSY,45
 Podflow/upload/add_upload.py,sha256=8kxHDLFa225WFze3oTPNtOWbcECF--bQXuALfsRJLoo,1432
 Podflow/upload/get_upload_original.py,sha256=h2aoutZ-po40N8auRDbKvse14261Y5H7vHgfAN23vV0,4358
-Podflow/upload/linked_client.py,sha256=SW2DA5kBsbyf3j6fCzzEWIGs6SsXjv3z712ytsnYwsw,3242
-Podflow/upload/linked_server.py,sha256=JgNKC08Xqpe7IBQIY140u-YWthbzo1BlWHLpvD9aFLw,2213
+Podflow/upload/linked_client.py,sha256=ODaS95VNKcAUpfcnMxZBM4nHlZ6S9jBDFpDEmapzT5I,3242
+Podflow/upload/linked_server.py,sha256=Tf3ANSryGuqjHsH1EqCrCA_pxo_dDuoYfCBzSgVVTrI,2264
+Podflow/upload/login.py,sha256=ovQKdtrddsoea_4s-SpnMHTVstH1pWoo0dFx1dpU_sU,798
 Podflow/upload/time_key.py,sha256=aR6xVe9x7ry8dKSHKoFLSUIfor2CoCuv8N9NRmsnUVo,967
 Podflow/upload/update_upload.py,sha256=4B5HyWwfmc_4Z5ZS_Wt2VcL6sgQFvq3JEl0Qubh7TwE,3183
 Podflow/youtube/__init__.py,sha256=-bdMyuw-wxoz2miVkp284amS4Qg0k7VN0JPuGF-cXlM,46
 Podflow/youtube/build.py,sha256=o6gld4qMph7UKq9pdO2E4dmtOA8brCK4sa_-vKEtYMM,12006
 Podflow/youtube/get.py,sha256=dFLyiHttygqdJltwC29jD_v8wwoLynE5NUdow_0wERI,16970
 Podflow/youtube/login.py,sha256=DlS_ZG4g6CKWqS5ojE4UwFJSCSZDsXbeuDVgHtQAa4A,1380
-podflow-20250307.dist-info/METADATA,sha256=4WuQxTaqKhH6uHEad1NnLv07QB6tXLe-eJQNYV1MC7U,14030
-podflow-20250307.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-podflow-20250307.dist-info/entry_points.txt,sha256=44nj8jJB7bo1JLNrKQZmwMGEA1OalrALJ0tF_G0yXLY,131
-podflow-20250307.dist-info/top_level.txt,sha256=KcvRCiz_DRWWc9i-PgpARvFB0J4CKmpZOZgPqOdG-Lk,8
-podflow-20250307.dist-info/RECORD,,
+podflow-20250315.dist-info/METADATA,sha256=sWLPHwYRGI7rcDccvaXhU_KSsgq30adtNg2lgiN_Yjo,14030
+podflow-20250315.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+podflow-20250315.dist-info/entry_points.txt,sha256=44nj8jJB7bo1JLNrKQZmwMGEA1OalrALJ0tF_G0yXLY,131
+podflow-20250315.dist-info/top_level.txt,sha256=KcvRCiz_DRWWc9i-PgpARvFB0J4CKmpZOZgPqOdG-Lk,8
+podflow-20250315.dist-info/RECORD,,