podflow 20250212__py3-none-any.whl → 20250301__py3-none-any.whl

Podflow/makeup/make_up_file_format_mod.py

@@ -8,7 +8,7 @@ from Podflow.basic.write_log import write_log
 from Podflow.message.media_format import media_format
 
 
-def makeup_yt_format(video_id, makeup_yt_format_lock):
+def makeup_format(video_id, makeup_format_lock):
     id_value = gVar.make_up_file_format[video_id]
     makeup_id_format = media_format(
         id_value["url"],
@@ -62,7 +62,7 @@ def makeup_yt_format(video_id, makeup_yt_format_lock):
                 }
             del gVar.make_up_file_format[video_id]
     else:
-        with makeup_yt_format_lock:
+        with makeup_format_lock:
             write_log(f"{id_value['name']}|{video_id}|{makeup_id_format}")
             gVar.make_up_file_format_fail[video_id] = id_value[
                 "id"
@@ -78,19 +78,19 @@ def make_up_file_format_mod():
             f"{datetime.now().strftime('%H:%M:%S')}|补全缺失媒体 \033[34m下载准备中...\033[0m"
         )
     # 创建线程锁
-    makeup_yt_format_lock = threading.Lock()
+    makeup_format_lock = threading.Lock()
     # 创建线程列表
-    makeup_yt_format_threads = []
+    makeup_format_threads = []
     for video_id in gVar.make_up_file_format:
         thread = threading.Thread(
-            target=makeup_yt_format,
+            target=makeup_format,
             args=(
                 video_id,
-                makeup_yt_format_lock,
+                makeup_format_lock,
             ),
         )
-        makeup_yt_format_threads.append(thread)
+        makeup_format_threads.append(thread)
         thread.start()
     # 等待所有线程完成
-    for thread in makeup_yt_format_threads:
+    for thread in makeup_format_threads:
         thread.join()

Podflow/message/create_main_rss.py

@@ -1,44 +1,69 @@
 # Podflow/message/create_main_rss.py
 # coding: utf-8
 
-import re
+import time
 from Podflow import gVar
 from Podflow.youtube.build import youtube_xml_items
 from Podflow.bilibili.build import bilibili_xml_items
-from Podflow.message.display_qrcode_and_url import display_qrcode_and_url
+from Podflow.message.get_media_name import get_media_name
+
+
+def update_output_dir():
+    output_dirs = []
+    for format_value in gVar.video_id_update_format.values():
+        if (
+            isinstance(format_value, dict)
+            and format_value["main"] not in gVar.video_id_failed
+        ):
+            output_dirs.append(format_value["id"])
+    return output_dirs
 
 
 # 生成主rss模块
 def create_main_rss():
     channelid_youtube_ids = gVar.channelid_youtube_ids
-    for output_dir, output_dir_youtube in channelid_youtube_ids.items():
-        channelid_youtube_value = gVar.channelid_youtube[output_dir_youtube]
-        items = youtube_xml_items(output_dir)
-        display_qrcode_and_url(
-            output_dir,
-            channelid_youtube_value,
-            output_dir_youtube,
-            gVar.channelid_youtube_ids_update,
-        )
-        if channelid_youtube_value["InmainRSS"]:
-            gVar.all_items.append(items)
-        gVar.all_youtube_content_ytid[output_dir] = re.findall(
-            r"(?:/UC.{22}/)(.{11}\.m4a|.{11}\.mp4)(?=\"|\?)",
-            items,
-        )
     channelid_bilibili_ids = gVar.channelid_bilibili_ids
-    for output_dir, output_dir_bilibili in channelid_bilibili_ids.items():
-        channelid_bilibili_value = gVar.channelid_bilibili[output_dir_bilibili]
-        items = bilibili_xml_items(output_dir)
-        display_qrcode_and_url(
-            output_dir,
-            channelid_bilibili_value,
-            output_dir_bilibili,
-            gVar.channelid_bilibili_ids_update,
-        )
-        if channelid_bilibili_value["InmainRSS"]:
-            gVar.all_items.append(items)
-        gVar.all_bilibili_content_bvid[output_dir] = re.findall(
-            r"(?:/[0-9]+/)(BV.{10}\.m4a|BV.{10}\.mp4|BV.{10}_p[0-9]+\.m4a|BV.{10}_p[0-9]+\.mp4|BV.{10}_[0-9]{9}\.m4a|BV.{10}_[0-9]{9}\.mp4)(?=\"|\?)",
-            items,
-        )
+    gVar.all_items = {
+        key: {} for key in channelid_youtube_ids | channelid_bilibili_ids
+    }
+    all_channelid = list(gVar.all_items.keys())
+
+    while all_channelid:
+        for index, output_dir in enumerate(all_channelid):
+            if output_dir in update_output_dir():
+                time.sleep(1)
+            else:
+                if output_dir in channelid_youtube_ids:
+                    output_dir_youtube = channelid_youtube_ids[output_dir]
+                    channelid_youtube_value = gVar.channelid_youtube[output_dir_youtube]
+                    items = youtube_xml_items(output_dir)
+                    items["DisplayRSSaddress"] = channelid_youtube_value[
+                        "DisplayRSSaddress"
+                    ]
+                    items["QRcode"] = channelid_youtube_value["QRcode"]
+                    items["ID_Name"] = output_dir_youtube
+                    items["InmainRSS"] = channelid_youtube_value["InmainRSS"]
+                    items["type"] = "youtube"
+                    gVar.all_youtube_content_ytid[output_dir] = get_media_name(
+                        "youtube", items["items"]
+                    )
+                    gVar.all_items[output_dir] = items
+                elif output_dir in channelid_bilibili_ids:
+                    output_dir_bilibili = channelid_bilibili_ids[output_dir]
+                    channelid_bilibili_value = gVar.channelid_bilibili[
+                        output_dir_bilibili
+                    ]
+                    items = bilibili_xml_items(output_dir)
+                    items["DisplayRSSaddress"] = channelid_bilibili_value[
+                        "DisplayRSSaddress"
+                    ]
+                    items["QRcode"] = channelid_bilibili_value["QRcode"]
+                    items["ID_Name"] = output_dir_bilibili
+                    items["InmainRSS"] = channelid_bilibili_value["InmainRSS"]
+                    items["type"] = "bilibili"
+                    gVar.all_bilibili_content_bvid[output_dir] = get_media_name(
+                        "bilibili", items["items"]
+                    )
+                    gVar.all_items[output_dir] = items
+                del all_channelid[index]
+                break

Podflow/message/display_qrcode_and_url.py

@@ -9,9 +9,10 @@ from Podflow.basic.qr_code import qr_code
 # 显示网址及二维码模块
 def display_qrcode_and_url(
     output_dir,
-    channelid_video,
-    channelid_video_name,
-    channelid_video_ids_update,
+    display_rss_address,
+    qrcode,
+    name,
+    ids_update,
 ):
     address = gVar.config["address"]
     if token := gVar.config["token"]:
@@ -19,17 +20,14 @@ def display_qrcode_and_url(
     else:
         xml_url = f"{address}/channel_rss/{output_dir}.xml"
 
-    if channelid_video["DisplayRSSaddress"] or output_dir in channelid_video_ids_update:
-        update_text = "已更新" if output_dir in channelid_video_ids_update else "无更新"
+    if display_rss_address or output_dir in ids_update:
+        update_text = "已更新" if output_dir in ids_update else "无更新"
         print(
-            f"{datetime.now().strftime('%H:%M:%S')}|{channelid_video_name} 播客{update_text}|地址:\n\033[34m{xml_url}\033[0m"
+            f"{datetime.now().strftime('%H:%M:%S')}|{name} 播客{update_text}|地址:\n\033[34m{xml_url}\033[0m"
         )
     if (
-        (
-            channelid_video["DisplayRSSaddress"]
-            or output_dir in channelid_video_ids_update
-        )
-        and channelid_video["QRcode"]
+        (display_rss_address or output_dir in ids_update)
+        and qrcode
         and output_dir not in gVar.displayed_QRcode
     ):
         qr_code(xml_url)

Podflow/message/fail_message_initialize.py

@@ -139,6 +139,11 @@ error_reason = [
         "\033[31m响应超时\033[0m",
         "regexp",
     ],
+    [
+        r"Requested format is not available. Use --list-formats for a list of available formats",
+        "\033[31m格式不可用\033[0m",
+        "text",
+    ],
 ]
 
 

Podflow/message/get_media_name.py

@@ -0,0 +1,26 @@
+# Podflow/message/get_media_name.py
+# coding: utf-8
+
+import re
+
+
+# 定义一个函数，用于获取媒体名称
+def get_media_name(id_type, items):
+    # 如果id_type为youtube
+    if id_type == "youtube":
+        # 使用正则表达式匹配items中的youtube链接，返回匹配结果
+        return re.findall(
+            r"(?:/UC.{22}/)(.{11}\.m4a|.{11}\.mp4)(?=\"|\?)",
+            items,
+        )
+    # 如果id_type为bilibili
+    elif id_type == "bilibili":
+        # 使用正则表达式匹配items中的bilibili链接，返回匹配结果
+        return re.findall(
+            r"(?:/[0-9]+/)(BV.{10}\.m4a|BV.{10}\.mp4|BV.{10}_p[0-9]+\.m4a|BV.{10}_p[0-9]+\.mp4|BV.{10}_[0-9]{9}\.m4a|BV.{10}_[0-9]{9}\.mp4)(?=\"|\?)",
+            items,
+        )
+    # 如果id_type不是youtube或bilibili
+    else:
+        # 返回空列表
+        return []

Podflow/message/save_rss.py

@@ -0,0 +1,85 @@
+# Podflow/message/save_rss.py
+# coding: utf-8
+
+from Podflow import gVar
+from Podflow.basic.qr_code import qr_code
+from Podflow.message.xml_rss import xml_rss
+from Podflow.basic.file_save import file_save
+from Podflow.basic.write_log import write_log
+from Podflow.message.backup_zip_save import backup_zip_save
+from Podflow.message.display_qrcode_and_url import display_qrcode_and_url
+
+
+# 保存rss文件模块
+def save_rss():
+    # 定义一个空列表，用于存储所有rss的items
+    main_items = []
+    # 遍历gVar.all_items字典，获取每个rss的输出目录和items_dict
+    for output_dir, items_dict in gVar.all_items.items():
+        # 获取items_dict中的各个字段
+        title = items_dict["title"]
+        link = items_dict["link"]
+        description = items_dict["description"]
+        category = items_dict["category"]
+        icon = items_dict["icon"]
+        items = items_dict["items"]
+        # 调用file_save函数，将rss保存到指定目录
+        file_save(
+            xml_rss(title, link, description, category, icon, items),
+            f"{output_dir}.xml",
+            "channel_rss",
+        )
+        # 获取items_dict中的其他字段
+        display_rss_address = items_dict["DisplayRSSaddress"]
+        qrcode = items_dict["QRcode"]
+        id_name = items_dict["ID_Name"]
+        id_type = items_dict["type"]
+        # 根据id_type获取对应的ids_update
+        if id_type == "youtube":
+            ids_update = gVar.channelid_youtube_ids_update
+        elif id_type == "bilibili":
+            ids_update = gVar.channelid_bilibili_ids_update
+        else:
+            ids_update = {}
+        # 调用display_qrcode_and_url函数，显示rss地址和二维码
+        display_qrcode_and_url(
+            output_dir,
+            display_rss_address,
+            qrcode,
+            id_name,
+            ids_update,
+        )
+        # 如果items_dict中的InmainRSS字段为True，则将items添加到main_items列表中
+        if items_dict["InmainRSS"]:
+            main_items.append(items)
+
+    # 生成主rss
+    overall_rss = xml_rss(
+        gVar.config["title"],
+        gVar.config["link"],
+        gVar.config["description"],
+        gVar.config["category"],
+        gVar.config["icon"],
+        "\n".join(main_items),
+    )
+
+    # 保存主rss
+    file_save(overall_rss, f"{gVar.config['filename']}.xml")
+
+    # 获取gVar.config中的地址和文件名
+    address = gVar.config["address"]
+    filename = gVar.config["filename"]
+    # 如果gVar.config中的token字段存在，则将token添加到overall_url中
+    if token := gVar.config["token"]:
+        overall_url = f"{address}/{filename}.xml?token={token}"
+    else:
+        overall_url = f"{address}/{filename}.xml"
+    # 调用write_log函数，记录总播客已更新
+    write_log("总播客已更新", f"地址:\n\033[34m{overall_url}\033[0m")
+    # 如果gVar.displayed_QRcode中不包含"main"，则调用qr_code函数，显示总播客的二维码，并将"main"添加到gVar.displayed_QRcode中
+    if "main" not in gVar.displayed_QRcode:
+        qr_code(overall_url)
+        gVar.displayed_QRcode.append("main")
+
+    # 备份主rss
+    backup_zip_save(overall_rss)

Podflow/remove/remove_file.py

@@ -9,6 +9,7 @@ from Podflow.basic.write_log import write_log
 # 删除多余媒体文件模块
 def remove_file():
     channelid_youtube_ids = gVar.channelid_youtube_ids
+
     for output_dir, name in channelid_youtube_ids.items():
         for file_name in os.listdir(f"channel_audiovisual/{output_dir}"):
             if file_name not in gVar.all_youtube_content_ytid[output_dir]:

Podflow/upload/add_upload.py

@@ -0,0 +1,36 @@
+# Podflow/upload/add_upload.py
+# coding: utf-8
+
+import time
+from Podflow import gVar
+
+
+# 添加新媒体至上传列表模块
+def add_upload():
+    # 获取video_id_update_format和video_id_failed的值
+    video_id_update_format = gVar.video_id_update_format
+    video_id_failed = gVar.video_id_failed
+    # 遍历video_id_update_format的键值对
+    for video_id, video_id_value in video_id_update_format.items():
+        # 判断video_id_value是否为字典，并且main不在video_id_failed中
+        if (
+            isinstance(video_id_value, dict)
+            and video_id_value["main"] not in video_id_failed
+        ):
+            # 构造media_id
+            media_id = f"{video_id}.{video_id_value['media']}"
+            # 判断gVar.upload_original中是否存在media_id
+            if not any(
+                item.get("media_id") == media_id for item in gVar.upload_original
+            ):
+                # 如果不存在，则将media_id、channel_id、media_time、upload、remove、hash添加到gVar.upload_original中
+                gVar.upload_original.append(
+                    {
+                        "media_id": media_id,
+                        "channel_id": video_id_value["id"],
+                        "media_time": int(time.time()),
+                        "upload": False,
+                        "remove": False,
+                        "hash": None,
+                    }
+                )

Podflow/upload/get_upload_original.py

@@ -3,15 +3,17 @@
 
 import re
 import json
+from datetime import datetime
 from collections import Counter
 from email.utils import parsedate_tz, mktime_tz
 from Podflow import gVar
 from Podflow.basic.file_save import file_save
 from Podflow.basic.write_log import write_log
+from Podflow.message.get_media_name import get_media_name
 
 
 # 获取原始上传数据模块
-def get_upload_original():
+def get_upload():
     xmls_original = gVar.xmls_original
     try:
         # 尝试打开并读取 JSON 文件
@@ -28,49 +30,38 @@ def get_upload_original():
     if upload_original:
         # 提取每个条目的 channel_id
         channel_ids = [item.get("channel_id") for item in upload_original]
-
         # 统计每个 channel_id 的出现次数
         channelid_counts = Counter(channel_ids)
-
         # 将出现次数转换为字典
         age_counts = dict(channelid_counts)
-
         # 统计 xmls_original 中每个键对应的 <guid> 标签内的元素数量
         xmls_original_counts = {
             key: len(re.findall(r"(?<=<guid>).+(?=</guid>)", value))
             for key, value in xmls_original.items()
         }
-
-        # 如果两个计数字典不相等，清空 upload_original
+        # 如果两个计数字典不相等，提示错误
         if age_counts != xmls_original_counts:
-            upload_original = []
-
-    # 如果 upload_original 仍然为空
-    if not upload_original:
+            print(
+                f"{datetime.now().strftime('%H:%M:%S')}|无法获取完整原始上传信息"
+            )
+    # 如果 upload_original 为空
+    else:
         # 遍历 xmls_original 的每个键值对
         for xmls_original_key, xmls_original_value in xmls_original.items():
             # 如果当前键在 channelid_youtube_ids 中
             if xmls_original_key in gVar.channelid_youtube_ids:
                 # 使用正则表达式解析包含特定格式媒体ID的字符串
-                media = re.findall(
-                    r"(?:/UC.{22}/)(.{11}\.m4a|.{11}\.mp4)(?=\"|\?)",
-                    xmls_original_value,
-                )
+                media = get_media_name("youtube", xmls_original_value)
             # 如果当前键在 channelid_bilibili_ids 中
             elif xmls_original_key in gVar.channelid_bilibili_ids:
-                media = re.findall(
-                    r"(?:/[0-9]+/)(BV.{10}\.m4a|BV.{10}\.mp4|BV.{10}_p[0-9]+\.m4a|BV.{10}_p[0-9]+\.mp4|BV.{10}_[0-9]{9}\.m4a|BV.{10}_[0-9]{9}\.mp4)(?=\"|\?)",
-                    xmls_original_value,
-                )
+                media = get_media_name("bilibili", xmls_original_value)
             else:
                 media = []
-
             # 查找每个上传条目的发布时间
             upload_time = re.findall(
                 r"(?<=<pubDate>).+(?=</pubDate>)",
                 xmls_original_value,
             )
-
             # 将日期字符串列表转换为 Unix 时间戳列表
             timestamps = [
                 mktime_tz(
@@ -79,13 +70,11 @@ def get_upload_original():
                 for date_string in upload_time
                 if parsedate_tz(date_string)  # 确保解析成功
             ]
-
             # 如果媒体和时间戳的数量不匹配，记录错误并清空 upload_original
             if len(media) != len(timestamps):
                 write_log("获取原始上传内容失败")  # 错误日志
                 upload_original.clear()  # 清空 upload_original
                 break  # 退出循环
-
             # 如果数量匹配，则整合 media_id、channel_id 和上传时间到 upload_original 列表
             upload_original += [
                 {
@@ -93,13 +82,23 @@ def get_upload_original():
                     "channel_id": xmls_original_key,
                     "media_time": value,
                     "upload": False,
+                    "remove": False,
+                    "hash": None,
                 }
                 for value, key in zip(
                     timestamps, media
                 )  # 使用 zip() 将 media 和 timestamps 组合成对
             ]
-
         # 如果成功填充 upload_original
         if upload_original:
             file_save(upload_original, "upload.json", "channel_data")  # 保存到文件
     return upload_original
+
+
+# 初始化原始上传信息
+def get_upload_original():
+    if gVar.config["upload"]:
+        if upload_original := get_upload():
+            gVar.upload_original = upload_original
+        else:
+            gVar.config["upload"] = False

Podflow/upload/linked_client.py

@@ -0,0 +1,74 @@
+# Podflow/upload/linked_client.py
+# coding: utf-8
+
+import time
+import socket
+from datetime import datetime
+from Podflow.upload.upload_print import upload_print
+
+
+BROADCAST_PORT = 37000
+TIMEOUT = 1  # 搜索超时时间（秒）
+MAX_BROADCAST_PORT = 37101  # 尝试广播的最大端口
+
+
+# 发现局域网内的服务器
+def discover_server(broadcast_port, timeout):
+    servers = []
+
+    # 创建UDP socket
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.settimeout(timeout)
+
+        try:
+            # 发送广播请求
+            sock.sendto(b"DISCOVER_SERVER_REQUEST", ("<broadcast>", broadcast_port))
+        except Exception as e:
+            upload_print(f"广播请求发送失败: {e}")
+            return servers
+
+        # 等待响应
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                data, addr = sock.recvfrom(1024)
+                if data.startswith(b"SERVER_INFO|"):
+                    try:
+                        port = int(data.decode().split("|")[1])
+                        servers.append((addr[0], port))
+                    except (IndexError, ValueError):
+                        upload_print(f"收到来自 {addr} 的服务响应格式不正确")
+            except socket.timeout:
+                break
+            except Exception as e:
+                upload_print(f"接收数据出错: {e}")
+                break
+
+    return servers
+
+
+# 自动发现并连接服务器模块
+def connect_server():
+    upload_print("正在搜索服务器...")
+
+    current_port = BROADCAST_PORT
+    servers = []
+    time_print = f"{datetime.now().strftime('%H:%M:%S')}|"
+
+    # 在允许的端口范围内尝试发现服务器
+    while current_port < MAX_BROADCAST_PORT:
+        print(f"\r{time_print}正在尝试广播端口 {current_port}...", end="")
+        servers = discover_server(current_port, TIMEOUT)
+        if servers:
+            print("")
+            break
+        current_port += 1
+
+    if not servers:
+        upload_print("找不到服务器")
+        return
+
+    # 选择第一个找到的服务器
+    server_ip, server_port = servers[0]
+    upload_print(f"正在连接到{server_ip}:{server_port}")

Podflow/upload/linked_server.py

@@ -0,0 +1,32 @@
+# Podflow/upload/linked_server.py
+# coding: utf-8
+
+import socket
+from Podflow.httpfs.port_judge import port_judge
+from Podflow.upload.upload_print import upload_print
+
+
+def usable_port(port, max_num):
+    hostip = "0.0.0.0"
+    while port <= max_num:
+        if port_judge(hostip, port):
+            return port
+        else:
+            port += 1
+    return None
+
+
+# 处理服务发现请求的UDP服务模块
+def handle_discovery(broadcast_port, service_port):
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.bind(("", broadcast_port))
+
+        upload_print("发现服务已启动...")
+        while True:
+            data, addr = sock.recvfrom(1024)
+            if data == b"DISCOVER_SERVER_REQUEST":
+                upload_print(f"来自{addr}的发现请求")
+                response = f"SERVER_INFO|{service_port}".encode()
+                sock.sendto(response, addr)

Podflow/upload/update_upload.py

@@ -0,0 +1,74 @@
+# Podflow/upload/update_upload.py
+# coding: utf-8
+
+import re
+import time
+from email.utils import parsedate_tz, mktime_tz
+from Podflow import gVar
+from Podflow.basic.file_save import file_save
+from Podflow.message.get_media_name import get_media_name
+
+
+# 更新并保存上传列表模块
+def update_upload():
+    # 如果没有开启上传功能，则直接返回
+    if not gVar.config["upload"]:
+        return
+    # 初始化一个字典，用于存储每个输出目录的媒体名称
+    media_name = {}
+    # 初始化一个列表，用于存储需要上传的媒体部分
+    main_upload = []
+    # 获取原始上传列表
+    upload_original = gVar.upload_original
+    # 获取所有项目
+    all_items = gVar.all_items
+    # 遍历所有项目，获取每个输出目录的媒体名称
+    for output_dir, items_dict in all_items.items():
+        media_name[output_dir] = get_media_name(items_dict["type"], items_dict["items"])
+    # 遍历原始上传列表，筛选出需要上传的媒体部分
+    for upload_part in upload_original:
+        if (
+            upload_part["channel_id"] in media_name
+            and upload_part["media_id"] in media_name[upload_part["channel_id"]]
+        ):
+            main_upload.append(upload_part)
+
+    # 获取需要上传的媒体部分的ID
+    media_ids = [item["media_id"] for item in main_upload if "media_id" in item]
+    # 遍历每个输出目录的媒体部分，筛选出需要上传的媒体部分
+    for output_dir, media_parts in media_name.items():
+        for part in media_parts:
+            if part not in media_ids:
+                # 构造正则表达式，用于匹配媒体部分
+                pattern = rf"<!-- {output_dir} -->(?:(?!<!-- {output_dir} -->).)+channel_audiovisual/{output_dir}/{part}.+?<!-- {output_dir} -->"
+                pubdate_text = ""
+                # 在所有项目中匹配媒体部分
+                if match := re.search(
+                    pattern, all_items[output_dir]["items"], flags=re.DOTALL
+                ):
+                    date_text = match.group()
+                    # 在匹配的媒体部分中提取发布日期
+                    pattern = r"(?<=<pubDate>).+(?=</pubDate>)"
+                    if match := re.search(pattern, date_text):
+                        pubdate_text = match.group()
+                # 如果发布日期存在，则转换为时间戳；否则，使用当前时间戳
+                pubdate_text = (
+                    mktime_tz(parsedate_tz(pubdate_text))
+                    if parsedate_tz(pubdate_text)
+                    else int(time.time())
+                )
+
+                # 将需要上传的媒体部分添加到列表中
+                main_upload.append(
+                    {
+                        "media_id": part,
+                        "channel_id": output_dir,
+                        "media_time": pubdate_text,
+                        "upload": False,
+                        "remove": False,
+                        "hash": None,
+                    }
+                )
+
+    # 将需要上传的媒体部分保存到文件中
+    file_save(main_upload, "upload.json", "channel_data")  # 保存到文件

Podflow/upload/upload_print.py

@@ -0,0 +1,8 @@
+# Podflow/upload/upload_print.py
+# coding: utf-8
+
+from datetime import datetime
+
+
+def upload_print(text):
+    print(f"{datetime.now().strftime('%H:%M:%S')}|{text}")