podflow 20250317__tar.gz → 20250323__tar.gz

{podflow-20250317 → podflow-20250323}/PKG-INFO

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

{podflow-20250317 → podflow-20250323}/Podflow/__init__.py

@@ -132,6 +132,7 @@ class Application_parse:
         self.period = 1
         self.file = ""
         self.httpfs = False
+        self.index = False
 
 
 # 创建 Application 类的实例

{podflow-20250317 → podflow-20250323}/Podflow/basic/file_save.py

@@ -15,7 +15,9 @@ def file_save(content, file_name, folder=None):
         file_path = os.path.join(os.getcwd(), file_name)
     # 保存文件
     with open(file_path, "w", encoding="utf-8") as file:
+        # 如果文件名中包含"."且文件类型为json，则将内容以json格式保存
         if "." in file_name and file_name.split(".")[-1] == "json":
             json.dump(content, file, ensure_ascii=False, indent=4)
         else:
+            # 否则将内容以文本格式保存
             file.write(content)

{podflow-20250317 → podflow-20250323}/Podflow/download/dl_aideo_video.py

@@ -123,7 +123,10 @@ def dl_full_video(
     duration_video = get_duration(
         f"channel_audiovisual/{output_dir}/{video_url}{sesuffix}.{output_format}"
     )  # 获取已下载视频的实际时长
-    if abs(id_duration - duration_video) <= 1:  # 检查实际时长与预计时长是否一致
+    if (
+        duration_video is not None 
+        and abs(id_duration - duration_video) <= 1
+    ):  # 检查实际时长与预计时长是否一致
         return None, None
     if duration_video:
         fail_info = f"不完整({id_duration}|{duration_video}"

{podflow-20250317 → podflow-20250323}/Podflow/httpfs/app_bottle.py

@@ -5,11 +5,15 @@ import os
 import hashlib
 from datetime import datetime
 import cherrypy
-from bottle import Bottle, abort, redirect, request, static_file, response
+from bottle import Bottle, abort, redirect, request, static_file, response, template
 from Podflow import gVar
 from Podflow.upload.login import create
+from Podflow.httpfs.html import html_index
+from Podflow.basic.file_save import file_save
 from Podflow.basic.write_log import write_log
+from Podflow.upload.build_hash import build_hash
 from Podflow.upload.time_key import check_time_key
+from Podflow.httpfs.get_channelid import get_channelid
 
 
 class bottle_app:
@@ -31,8 +35,10 @@ class bottle_app:
         if upload:
             self.app_bottle.route("/newuser", callback=self.new_user)
             self.app_bottle.route("/login", callback=self.login)
+            self.app_bottle.route("/upload", method="POST", callback=self.upload)
         else:
             # 设置其他路由，回调函数为serve_static
+            self.app_bottle.route("/index", method=["GET", "POST"], callback=self.index)
             self.app_bottle.route("/<filename:path>", callback=self.serve_static)
 
     # 设置日志文件名及写入判断
@@ -106,8 +112,7 @@ class bottle_app:
     # 输出请求日志的函数
     def print_out(self, filename, status):
         client_ip = request.remote_addr
-        client_port = request.environ.get("REMOTE_PORT")
-        if client_port:
+        if client_port := request.environ.get("REMOTE_PORT"):
             client_ip = f"{client_ip}:{client_port}"
         if filename not in [
             "favicon.ico",
@@ -120,7 +125,7 @@ class bottle_app:
                 gVar.channelid_youtube_ids_original
                 | gVar.channelid_bilibili_ids_original
                 | {"channel_audiovisual/": "", "channel_rss/": ""}
-            )  # 合并多个频道 ID        
+            )  # 合并多个频道 ID
             for (
                 bottle_channelid_key,
                 bottle_channelid_value,
@@ -139,7 +144,7 @@ class bottle_app:
     def home(self):
         VALID_TOKEN = gVar.config["token"]  # 从配置中读取主验证 Token
         token = request.query.get("token")  # 获取请求中的 Token
-        
+
         if self.token_judgment(token, VALID_TOKEN):  # 验证 Token
             self.print_out("/", 303)  # 如果验证成功, 输出 200 状态
             return redirect("https://github.com/gruel-zxz/podflow")  # 返回正常响应
@@ -156,7 +161,7 @@ class bottle_app:
             Shutdown_VALID_TOKEN.encode()
         ).hexdigest()  # 用于服务器关闭的验证 Token
         token = request.query.get("token")  # 获取请求中的 Token
-        
+
         if self.token_judgment(
             token, Shutdown_VALID_TOKEN
         ):  # 验证 Token 是否为关闭用的 Token
@@ -220,16 +225,17 @@ class bottle_app:
 
     # 路由获取账号密码请求
     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'
-        
+        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",
+                "code": 0,
+                "message": "Get New Username And Password Success",
                 "data": {
                     "username": username,
                     "password": password,
@@ -238,35 +244,149 @@ class bottle_app:
         else:
             self.print_out("newuser", 401)
             return {
-                "code":-1,
-                "message":"Unauthorized: Invalid Token",
+                "code": -1,
+                "message": "Unauthorized: Invalid Token",
             }
 
+    # 获取Channel-ID请求
+    def index(self): 
+        if request.method == "POST":
+            user_input = request.forms.get("inputOutput")  # 获取用户输入
+            processed_input = get_channelid(user_input)
+            self.print_out("channelid", 200)
+            return template(html_index, processed_input=processed_input)  # 直接回显到输入框
+        else:
+            self.print_out("index", 200)
+            return template(html_index, processed_input="")  # 默认输入框为空
+
     # 路由处理登陆请求
     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",
+                    "code": 0,
+                    "message": "Login Success",
                 }
             else:
+                # 打印密码错误
                 self.print_out("login", 401)
+                # 返回密码错误的信息
                 return {
-                    "code":-3,
-                    "message":"Password Error",
+                    "code": -3,
+                    "message": "Password Error",
                 }
         else:
+            # 打印用户名错误
+            self.print_out("login", 401)
+            # 返回用户名错误的信息
+            return {
+                "code": -2,
+                "message": "Username Error",
+            }
+
+    # 文件上传处理请求
+    def upload(self):
+        # 获取上传数据配置(存储用户名和密码)
+        upload_data = gVar.upload_data
+        # 从请求参数中获取用户名，默认为空字符串
+        username = request.query.get("username", "")
+        # 从请求参数中获取密码，默认为空字符串
+        password = request.query.get("password", "")
+        upload_hash = request.query.get("hash", "")
+        channelid = request.query.get("channel_id", "")
+
+        # 验证用户是否存在
+        if username not in upload_data:
+            self.print_out("login", 401)
+            return {
+                "code": -2,
+                "message": "Username Error",
+            }
+        # 验证密码是否正确
+        if upload_data[username] != password:
             self.print_out("login", 401)
             return {
-                "code":-2,
-                "message":"Username Error",
+                "code": -3,
+                "message": "Password Error",
+            }
+        # 从请求中获取上传的文件对象
+        upload_file = request.files.get("file")
+        # 检查是否有文件被上传
+        if not upload_file:
+            # 打印错误信息并返回错误码
+            self.print_out("upload", 404)
+            return {
+                "code": -4,
+                "message": "No File Provided",
+            }
+        # 判断文件是否完整
+        if upload_hash != build_hash(upload_file):
+            self.print_out("upload", 401)
+            return {
+                "code": -5,
+                "message": "Incomplete File",
+            }
+        if not channelid:
+            # 打印错误信息并返回错误码
+            self.print_out("upload", 404)
+            return {
+                "code": -6,
+                "message": "ChannelId Does Not Exist",
             }
+        # 获取上传文件的原始文件名
+        filename = upload_file.filename
+        name = filename.split(".")[0]
+        suffix = filename.split(".")[1]
+        if suffix in ["mp4", "m4a"]:
+            self.print_out("upload", 404)
+            return {
+                "code": -6,
+                "message": "File Format Error",
+            }
+        address = f"/channel_audiovisual/{channelid}"
+        if os.path.exists(address):
+            file_list = os.listdir(address)
+        else:
+            file_list = []
+        num = 0
+        while True:
+            if num != 0:
+                filename = f"{name}.{num}.{suffix}"
+            if filename in file_list:
+                with open(f"{address}/{filename}", "rb") as original_file:
+                    if upload_hash == build_hash(original_file):
+                        self.print_out("upload", 200)
+                        return {
+                            "code": 1,
+                            "message": "The Same File Exists",
+                            "data": {
+                                "filename": filename,
+                            },
+                        }
+                    else:
+                        num += 1
+            else:
+                file_save(upload_file, filename, address)
+                # 打印成功信息并返回成功码
+                self.print_out("upload", 200)
+                return {
+                    "code": 0,
+                    "message": "Upload Success",
+                    "data": {
+                        "filename": filename,
+                    },
+                }
 
 
 bottle_app_instance = bottle_app()

podflow-20250323/Podflow/httpfs/browser.py

@@ -0,0 +1,9 @@
+# Podflow/httpfs/browser.py
+# coding: utf-8
+
+import os
+
+
+def open_url(url):
+    browser = os.getenv("BROWSER", "internalbrowser")
+    os.system(f"{browser} {url} &")  # 在后台运行，避免阻塞

podflow-20250323/Podflow/httpfs/get_channelid.py

@@ -0,0 +1,81 @@
+# Podflow/httpfs/get_channelid.py
+# coding: utf-8
+
+import re
+from Podflow.basic.http_client import http_client
+
+
+def get_response(
+    text,
+    name,
+    re_ucid,
+    mod_ucid,
+    re_title,
+):
+    if response := http_client(
+        url=text,
+        name=name,
+        headers_possess=True
+    ):
+        if mod_ucid == "text":
+            ucid = re.search(re_ucid, response.text)
+        elif mod_ucid == "url":
+            ucid = re.search(re_ucid, response.url)
+        else:
+            ucid = ""
+        title = re.search(re_title, response.text)
+        if ucid and title :
+            ucid = ucid.group(0)
+            title = title.group(0)
+            return f'''"{title}": "{ucid}"
+
+"{title}": {{
+            "id": "{ucid}",
+            "quality": "1080",
+            "media": "mp4",
+            "InmainRSS": false,
+            "update_size": 2
+        }}'''
+        else:
+            return "Network Error"
+    else:
+        return "Network Error"
+
+
+def get_channelid(text):
+    if text in [None, ""]:
+        return ""
+    url_pattern = re.compile(r'https?://[^\s<>"]+|www\.[^\s<>"]+')
+    text_match = url_pattern.search(text)  # 使用 search() 而不是 match()
+    if text_match:
+        text = text_match.group(0)
+        if "youtube" in text:
+            return get_response(
+                text,
+                "youtube",
+                r"(?<=https://www.youtube.com/channel/)UC.{22}",
+                "text",
+                r'(?<=<link itemprop="name" content=").+?(?=")',
+            )
+        elif "bilibili" in text or "b23.tv" in text:
+            return get_response(
+                text,
+                "bilibili",
+                r'(?<=https://space\.bilibili\.com/)([0-9]+)',
+                "url",
+                r'(?<=<title>).+(?=的个人空间-)',
+            )
+    else:
+        text_match = re.search(r'(?<=UID:)([0-9]+)', text, re.IGNORECASE)
+        if text_match:
+            text = f"https://space.bilibili.com/{text_match.group(0)}"
+            return get_response(
+                text,
+                "bilibili",
+                r'(?<=https://space\.bilibili\.com/)([0-9]+)',
+                "url",
+                r'(?<=<title>).+(?=的个人空间-)',
+            )
+        else:
+            return "Network Error"
+    return "Network Error"

podflow-20250323/Podflow/httpfs/html.py

@@ -0,0 +1,145 @@
+# Podflow/httpfs/html.py
+# coding: utf-8
+
+
+html_index = '''<!DOCTYPE html>
+<html lang="zh">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>输入输出示例</title>
+    <style>
+        /* 基本样式 */
+        body {
+            font-family: Arial, sans-serif;
+            text-align: center;
+            padding: 20px;
+            background-color: #f8f9fa;
+        }
+
+        h2 {
+            color: #333;
+        }
+
+        /* 响应式输入框 */
+        textarea { 
+            width: 90%; 
+            max-width: 600px; 
+            height: 250px; /* 增加默认高度 */
+            font-size: 16px; 
+            padding: 10px; 
+            border: 1px solid #ccc; 
+            border-radius: 8px; 
+            resize: vertical; /* 允许手动调整高度 */
+            overflow-y: auto; /* 始终显示垂直滚动条（如需自动出现滚动条，可用 `overflow-y: auto;`） */
+        }
+
+        /* 按钮样式 */
+        .button-container {
+            margin-top: 10px;
+        }
+
+        button {
+            background-color: #007bff;
+            color: white;
+            border: none;
+            padding: 12px 18px;
+            font-size: 16px;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: 0.3s;
+            box-shadow: 2px 2px 8px rgba(0, 0, 0, 0.2);
+            margin: 5px;
+        }
+
+        button:hover {
+            background-color: #0056b3;
+        }
+
+        /* 手机端优化 */
+        @media (max-width: 600px) {
+            textarea {
+                font-size: 18px;
+                height: 180px;
+            }
+
+            button {
+                width: 90%;
+                font-size: 18px;
+                padding: 14px;
+            }
+        }
+
+        /* 提示信息 */
+        .hint {
+            font-size: 14px;
+            color: #666;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+<body>
+    <h2>获取Channel-ID</h2>
+    <form id="inputForm" method="post">
+        <label for="inputOutput">请输入：</label><br>
+        <textarea name="inputOutput" id="inputOutput">{{ processed_input }}</textarea><br>
+        <div class="button-container">
+            <button type="button" onclick="pasteFromClipboard()">📋 粘贴</button>
+            <button type="submit">✅ 提交</button>
+            //<button type="button" onclick="copyText()">📄 拷贝</button>
+            <button type="button" onclick="clearInput()">🗑️ 清空</button>
+        </div>
+        <p class="hint">📌 如果粘贴按钮无效，请长按输入框手动粘贴。</p>
+    </form>
+    <script>
+        function pasteFromClipboard() {
+            let inputOutput = document.getElementById('inputOutput');
+
+            if (navigator.clipboard && navigator.clipboard.readText) {
+                navigator.clipboard.readText().then(text => {
+                    inputOutput.value = text;
+                    inputOutput.focus(); // 聚焦输入框
+                    //alert("✅ 已成功粘贴！");
+                }).catch(err => {
+                    console.warn("❌ 剪贴板读取失败:", err);
+                    alert("❌ 无法读取剪贴板，请手动粘贴！");
+                });
+            } else {
+                // 兼容旧版浏览器
+                try {
+                    inputOutput.focus();
+                    document.execCommand('paste'); // 仅部分浏览器支持
+                    //alert("✅ 尝试使用旧版粘贴方法！");
+                } catch (err) {
+                    console.warn("❌ execCommand 粘贴失败:", err);
+                    alert("❌ 您的浏览器不支持自动粘贴，请手动操作！");
+                }
+            }
+        }
+        function copyText() {
+            let inputOutput = document.getElementById('inputOutput');
+            if (navigator.clipboard && navigator.clipboard.writeText) {
+                navigator.clipboard.writeText(inputOutput.value).then(() => {
+                    //alert("✅ 已拷贝到剪贴板！");
+                }).catch(err => {
+                    console.warn("拷贝失败:", err);
+                    alert("❌ 无法拷贝，请手动选择文本后按 Ctrl+C 复制！");
+                });
+            } else {
+                // 兼容旧版浏览器
+                try {
+                    inputOutput.select();
+                    document.execCommand('copy');
+                    //alert("✅ 已拷贝到剪贴板！");
+                } catch (err) {
+                    console.warn("execCommand 复制失败:", err);
+                    alert("❌ 您的浏览器不支持拷贝，请手动操作！");
+                }
+            }
+        }
+        function clearInput() {
+            document.getElementById('inputOutput').value = '';
+        }
+    </script>
+</body>
+</html>'''

{podflow-20250317 → podflow-20250323}/Podflow/main_podcast.py

@@ -15,6 +15,7 @@ from Podflow.basic.split_dict import split_dict
 from Podflow.basic.time_print import time_print
 
 # 网络和 HTTP 模块
+from Podflow.httpfs.browser import open_url
 from Podflow.httpfs.port_judge import port_judge
 from Podflow.httpfs.app_bottle import bottle_app_instance
 
@@ -53,6 +54,7 @@ from Podflow.remove.remove_dir import remove_dir
 from Podflow.youtube.build import print_fail_youtube
 
 # 长期媒体进行上传模块
+from Podflow.upload.login import login_upload
 from Podflow.upload.add_upload import add_upload
 from Podflow.upload.update_upload import update_upload
 from Podflow.upload.linked_client import connect_upload_server
@@ -93,6 +95,8 @@ def main_podcast():
         )
         cherrypy.engine.start()  # 启动 CherryPy 服务器
         time_print(f"HTTP服务器启动, 端口: \033[32m{port}\033[0m")
+        if parse.index:
+            open_url(f"{gVar.config['address']}/index")
         if parse.httpfs:  # HttpFS参数判断, 是否继续运行
             cherrypy.engine.block()  # 阻止程序退出, 保持HTTP服务运行
             sys.exit(0)
@@ -116,10 +120,17 @@ def main_podcast():
         gVar.xmls_original, gVar.hash_rss_original, gVar.xmls_original_fail = (
             get_original_rss()
         )
+        # 连接上传服务器
+        upload_url = connect_upload_server()
+        # 登陆上传服务器
+        if upload_url:
+            upload_json = login_upload(upload_url)
+            if upload_json:
+                gVar.config["upload"] = False
+        else:
+            gVar.config["upload"] = False
         # 初始化原始上传信息
         get_upload_original()
-        # 连接上传服务器
-        connect_upload_server()
         # 更新Youtube和哔哩哔哩频道xml
         update_youtube_bilibili_rss()
         # 判断是否有更新内容

{podflow-20250317 → podflow-20250323}/Podflow/parse_arguments.py

@@ -58,6 +58,11 @@ def parse_arguments():
         metavar="URL",
         help="Only shortcuts can be work",
     )
+    parser.add_argument(
+        "--index",
+        action="store_true",
+        help="Only shortcuts can be work",
+    )
     parser.add_argument(
         "--httpfs",
         action="store_true",
@@ -77,6 +82,7 @@ def parse_arguments():
     parse.file = args.file
     parse.httpfs = args.httpfs
     parse.upload = args.upload
+    parse.index = args.index
     # 检查并处理参数的状态
     if args.times is not None:
         parse.update_num = int(args.times[0])

podflow-20250323/Podflow/upload/build_hash.py

@@ -0,0 +1,16 @@
+# Podflow/upload/build_hash.py
+# coding: utf-8
+
+import hashlib
+
+
+# 定义一个函数，用于计算文件的哈希值
+def build_hash(file):
+    # 获取hashlib模块中的sha256函数
+    hash_func = getattr(hashlib, "sha256")()
+    # 循环读取文件内容，每次读取4096字节
+    for chunk in iter(lambda: file.read(4096), b''):
+        # 更新哈希值
+        hash_func.update(chunk)
+    # 返回哈希值的十六进制表示
+    return hash_func.hexdigest()

{podflow-20250317 → podflow-20250323}/Podflow/upload/linked_client.py

@@ -86,7 +86,4 @@ def connect_upload_server():
             # 选择第一个找到的服务器
             server_ip, server_port = servers[0]
             time_print(f"正在连接到{server_ip}:{server_port}...", True)
-            return {
-                "ip": server_ip,
-                "port": server_port
-            }
+            return f"http://{server_ip}:{server_port}"

{podflow-20250317 → podflow-20250323}/Podflow/upload/linked_server.py

@@ -2,6 +2,7 @@
 # coding: utf-8
 
 import socket
+from Podflow.basic.write_log import write_log
 from Podflow.basic.time_print import time_print
 from Podflow.httpfs.port_judge import port_judge
 from Podflow.upload.time_key import check_time_key
@@ -45,11 +46,11 @@ def handle_discovery(broadcast_port, service_port):
             # 检查消息是否包含时间关键字
             if check_time_key(data ,"PODFLOW_DISCOVER_SERVER_REQUEST"):
                 # 打印接收到的发现请求成功
-                time_print(f"来自{addr[0]}的发现请求\033[32m成功\033[0m")
+                write_log(f"来自{addr[0]}的发现请求\033[32m成功\033[0m")
                 # 构造响应消息
                 response = f"PODFLOW_SERVER_INFO|{service_port}".encode()
                 # 发送响应消息
                 sock.sendto(response, addr)
             else:
                 # 打印接收到的发现请求失败
-                time_print(f"来自{addr[0]}的发现请求\033[31m失败\033[0m")
+                write_log(f"来自{addr[0]}的发现请求\033[31m失败\033[0m")

podflow-20250323/Podflow/upload/login.py

@@ -0,0 +1,119 @@
+# Podflow/upload/login.py
+# coding: utf-8
+
+import os
+import json
+import uuid
+import hashlib
+from Podflow import gVar
+from Podflow.upload.time_key import time_key
+from Podflow.basic.file_save import file_save
+from Podflow.basic.write_log import write_log
+from Podflow.basic.time_print import time_print
+from Podflow.basic.http_client import http_client
+
+
+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
+
+
+def get_account(url):
+    url = f"{url}/newuser"
+    token = time_key(
+        "We need to generate an account password for uploading non one-time items that need to be saved."
+    )
+    data = {"token": token}
+    if response := http_client(
+        url=url,
+        name="获取上传服务账号密码",
+        data=data,
+    ):
+        return response.json()
+
+
+def login(url, username, password):
+    url = f"{url}/login"
+    data = {
+        "username": username,
+        "password": password,
+    }
+    if response := http_client(
+        url=url,
+        name="登陆上传服务",
+        data=data,
+    ):
+        return response.json()
+
+
+def login_upload(url):
+    try:
+        # 尝试打开并读取 JSON 文件
+        with open("channel_data/upload_data.json", "r") as file:
+            upload_json = file.read()
+        upload_json = json.loads(
+            upload_json
+        )
+    except Exception:
+        upload_json = {}
+    if "username" not in upload_json:
+        write_log("上传服务账号密码不存在")
+        time_print("获取上传服务账号密码...")
+        account_data = get_account(url)
+        if "code" in account_data:
+            if account_data["code"] == 0:
+                write_log("账号密码获取\033[32m成功\033[0m")
+                username = account_data["data"]["username"]
+                password = account_data["data"]["password"]
+                upload_json = {
+                    "username": username,
+                    "password": password,
+                }
+                file_save(upload_json, "upload_data.json", "channel_data")
+                return upload_json
+            elif account_data["code"] == -1:
+                write_log("账号密码获取\033[31m失败\033[0m: 认证失败")
+                return
+            else:
+                write_log("账号密码获取\033[31m失败\033[0m")
+                return
+        else:
+            write_log("账号密码获取\033[31m失败\033[0m: 无法连接")
+            return
+    else:
+        username = upload_json["username"]
+        password = upload_json.get("password", "")
+        login_data = login(url, username, password)
+        if "code" in login_data:
+            if login_data["code"] == 0:
+                time_print("登陆上传服务\033[32m成功\033[0m")
+                return upload_json
+            elif login_data["code"] == -1:
+                write_log("登陆上传服务\033[31m失败\033[0m: 认证失败")
+                return
+            elif login_data["code"] == -2:
+                write_log("登陆上传服务\033[31m失败\033[0m: 账号错误")
+                return
+            elif login_data["code"] == -3:
+                write_log("登陆上传服务\033[31m失败\033[0m: 密码错误")
+                return
+            else:
+                write_log("登陆上传服务\033[31m失败\033[0m")
+                return
+        else:
+            write_log("登陆上传服务\033[31m失败\033[0m: 无法连接")
+            return

{podflow-20250317 → podflow-20250323}/podflow.egg-info/PKG-INFO

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

{podflow-20250317 → podflow-20250323}/podflow.egg-info/SOURCES.txt

@@ -43,6 +43,9 @@ Podflow/download/wait_animation.py
 Podflow/download/youtube_and_bilibili_download.py
 Podflow/httpfs/__init__.py
 Podflow/httpfs/app_bottle.py
+Podflow/httpfs/browser.py
+Podflow/httpfs/get_channelid.py
+Podflow/httpfs/html.py
 Podflow/httpfs/port_judge.py
 Podflow/makeup/__init__.py
 Podflow/makeup/del_makeup_format_fail.py
@@ -81,6 +84,7 @@ Podflow/repair/__init__.py
 Podflow/repair/reverse_log.py
 Podflow/upload/__init__.py
 Podflow/upload/add_upload.py
+Podflow/upload/build_hash.py
 Podflow/upload/get_upload_original.py
 Podflow/upload/linked_client.py
 Podflow/upload/linked_server.py

{podflow-20250317 → podflow-20250323}/podflow.egg-info/requires.txt

@@ -1,6 +1,6 @@
 astral>=3.2
 bottle>=0.13.2
-yt-dlp>=2025.2.19
+yt-dlp>=2025.3.21
 chardet>=5.2.0
 cherrypy>=18.10.0
 pyqrcode>=1.2.1

{podflow-20250317 → podflow-20250323}/setup.py

@@ -5,7 +5,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="podflow",
-    version="20250317",
+    version="20250323",
     author="gruel_zxz",
     author_email="zhuxizhouzxz@gmail.com",
     description="A podcast server that includes YouTube and BiliBili",
@@ -30,7 +30,7 @@ setup(
     install_requires=[
         "astral>=3.2", 
         "bottle>=0.13.2",
-        "yt-dlp>=2025.2.19",
+        "yt-dlp>=2025.3.21",
         "chardet>=5.2.0",
         "cherrypy>=18.10.0",
         "pyqrcode>=1.2.1",

podflow-20250317/Podflow/upload/login.py

@@ -1,28 +0,0 @@
-# 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