podflow 2025.1.26__py3-none-any.whl

Podflow/youtube/get.py

@@ -0,0 +1,376 @@
+# Podflow/youtube/get.py
+# coding: utf-8
+
+import contextlib
+import re
+import os
+import threading
+from datetime import datetime
+from Podflow import gVar
+from Podflow.basic.http_client import http_client
+from Podflow.basic.vary_replace import vary_replace
+from Podflow.basic.get_html_dict import get_html_dict
+from Podflow.basic.list_merge_tidy import list_merge_tidy
+
+
+# 从YouTube播放列表获取更新模块
+def get_youtube_html_playlists(
+    youtube_key,  # YouTube 频道的唯一标识
+    youtube_value,  # YouTube 账户或其他标识信息
+    guids=None,  # 视频 ID 列表（用于比较已有视频）
+    direction_forward=True,  # 控制获取方向，默认向前获取新的视频
+    update_size=20,  # 更新数量限制，最多获取 20 个新视频
+    youtube_content_ytid_original=None,  # 原始 YouTube 视频 ID 列表
+):
+    idlist = []  # 存储新获取的 YouTube 视频 ID
+    item = {}  # 存储视频信息（标题、描述、封面等）
+    threads = []  # 线程列表，用于并发获取视频详细信息
+    fail = []  # 存储获取失败的视频 ID
+
+    if guids is None:
+        guids = [""]
+    if youtube_content_ytid_original is None:
+        youtube_content_ytid_original = []
+
+    try:
+        videoid_start = guids[0] if direction_forward else guids[-1]  # 获取起始视频 ID
+    except IndexError:
+        videoid_start = ""  # 处理空列表情况，避免 IndexError
+
+    # 获取视频详细信息的内部函数
+    def get_video_item(videoid, youtube_value):
+        yt_Initial_Player_Response = get_html_dict(
+            f"https://www.youtube.com/watch?v={videoid}",
+            f"{youtube_value}|{videoid}",
+            "ytInitialPlayerResponse",
+        )  # 解析 YouTube 页面，获取视频信息
+        if not yt_Initial_Player_Response:
+            return None  # 若获取失败，则返回 None
+
+        try:
+            player_Microformat_Renderer = yt_Initial_Player_Response["microformat"][
+                "playerMicroformatRenderer"
+            ]
+        except (KeyError, TypeError, IndexError, ValueError):
+            player_Microformat_Renderer = {}  # 解析失败时，返回空字典
+            fail.append(videoid)  # 记录失败的视频 ID
+
+        if player_Microformat_Renderer:
+            try:
+                item[videoid]["description"] = player_Microformat_Renderer[
+                    "description"
+                ]["simpleText"]
+            except (KeyError, TypeError, IndexError, ValueError):
+                item[videoid]["description"] = ""  # 若没有描述，则置为空
+            item[videoid]["pubDate"] = player_Microformat_Renderer[
+                "publishDate"
+            ]  # 获取发布时间
+            item[videoid]["image"] = player_Microformat_Renderer["thumbnail"][
+                "thumbnails"
+            ][0]["url"]  # 获取封面图
+            with contextlib.suppress(KeyError, TypeError, IndexError, ValueError):
+                fail.remove(videoid)  # 若成功获取，则从失败列表中移除
+        else:
+            return None  # 若无有效数据，返回 None
+
+    # 获取播放列表数据
+    yt_initial_data = get_html_dict(
+        f"https://www.youtube.com/watch?v={videoid_start}&list=UULF{youtube_key[-22:]}",
+        f"{youtube_value} HTML",
+        "ytInitialData",
+    )  # 解析 YouTube 播放列表页面，获取数据
+    if not yt_initial_data:
+        return None  # 若获取失败，则返回 None
+
+    try:
+        playlists = yt_initial_data["contents"]["twoColumnWatchNextResults"][
+            "playlist"
+        ]["playlist"]["contents"]
+        main_title = yt_initial_data["contents"]["twoColumnWatchNextResults"][
+            "playlist"
+        ]["playlist"]["ownerName"]["simpleText"]
+    except (KeyError, TypeError, IndexError, ValueError):
+        return None  # 若解析失败，返回 None
+
+    # 若方向是向前获取（最新视频）或没有起始视频 ID
+    if direction_forward or not videoid_start:
+        for playlist in playlists:
+            videoid = playlist["playlistPanelVideoRenderer"]["videoId"]  # 提取视频 ID
+            if (
+                playlist["playlistPanelVideoRenderer"]["navigationEndpoint"][
+                    "watchEndpoint"
+                ]["index"]
+                == update_size
+            ):
+                break  # 如果达到更新上限，则停止
+            if videoid not in guids:  # 确保视频 ID 不是已存在的
+                title = playlist["playlistPanelVideoRenderer"]["title"][
+                    "simpleText"
+                ]  # 获取视频标题
+                idlist.append(videoid)  # 添加到 ID 列表
+                item[videoid] = {"title": title, "yt-dlp": True}  # 记录视频信息
+                if videoid in youtube_content_ytid_original:  # 若视频已在原始列表中
+                    item[videoid]["yt-dlp"] = False  # 标记为已存在
+                    item_thread = threading.Thread(
+                        target=get_video_item, args=(videoid, youtube_value)
+                    )  # 启动线程获取详细信息
+                    item_thread.start()
+                    threads.append(item_thread)
+    else:  # 处理向后获取（获取较旧的视频）
+        reversed_playlists = []
+        for playlist in reversed(playlists):
+            videoid = playlist["playlistPanelVideoRenderer"]["videoId"]
+            if videoid not in guids:
+                reversed_playlists.append(playlist)  # 收集未存在的旧视频
+            else:
+                break  # 如果找到已存在的视频 ID，则停止
+
+        for playlist in reversed(reversed_playlists[-update_size:]):
+            videoid = playlist["playlistPanelVideoRenderer"]["videoId"]
+            title = playlist["playlistPanelVideoRenderer"]["title"]["simpleText"]
+            idlist.append(videoid)
+            item[videoid] = {"title": title, "yt-dlp": True}
+            if videoid in youtube_content_ytid_original:
+                item[videoid]["yt-dlp"] = False
+                item_thread = threading.Thread(
+                    target=get_video_item, args=(videoid, youtube_value)
+                )
+                item_thread.start()
+                threads.append(item_thread)
+
+    for thread in threads:
+        thread.join()  # 等待所有线程完成
+
+    # 处理获取失败的视频
+    for videoid in fail:
+        get_video_item(videoid, youtube_value)  # 重新尝试获取失败的视频
+
+    if fail:  # 如果仍然有失败的视频
+        if direction_forward or not videoid_start:
+            for videoid in fail:
+                print(
+                    f"{datetime.now().strftime('%H:%M:%S')}|{youtube_value}|{videoid} HTML无法更新, 将不获取"
+                )
+                if videoid in idlist:
+                    idlist.remove(videoid)  # 安全地移除视频 ID，避免 `ValueError`
+                del item[videoid]  # 删除对应的字典项
+        else:
+            print(
+                f"{datetime.now().strftime('%H:%M:%S')}|{youtube_value} HTML有失败只更新部分"
+            )
+            index = len(idlist)
+            for videoid in fail:
+                if videoid in idlist:
+                    index = min(idlist.index(videoid), index)  # 计算最早失败视频的索引
+            idlist_fail = idlist[index:]  # 截取失败的视频 ID 列表
+            idlist = idlist[:index]  # 只保留成功的视频 ID
+            for videoid in idlist_fail:
+                if videoid in idlist:
+                    idlist.remove(videoid)  # 安全删除失败视频 ID
+
+    return {"list": idlist, "item": item, "title": main_title}  # 返回最终结果
+
+
+def get_youtube_shorts_id(youtube_key, youtube_value):
+    videoIds = []
+    url = f"https://www.youtube.com/channel/{youtube_key}/shorts"
+    if data := get_html_dict(url, youtube_value, "ytInitialData"):
+        with contextlib.suppress(KeyError, TypeError, IndexError, ValueError):
+            items = data["contents"]["twoColumnBrowseResultsRenderer"]["tabs"][2][
+                "tabRenderer"
+            ]["content"]["richGridRenderer"]["contents"]
+            for item in items:
+                videoId = item["richItemRenderer"]["content"]["shortsLockupViewModel"][
+                    "onTap"
+                ]["innertubeCommand"]["reelWatchEndpoint"]["videoId"]
+                videoIds.append(videoId)
+    return videoIds
+
+
+# 更新Youtube频道xml模块
+def youtube_rss_update(
+    youtube_key,
+    youtube_value,
+    pattern_youtube_varys,
+    pattern_youtube404,
+    pattern_youtube_error,
+):
+    channelid_youtube = gVar.channelid_youtube
+    channelid_youtube_rss = gVar.channelid_youtube_rss
+    channelid_youtube_ids_update = gVar.channelid_youtube_ids_update
+    # 获取已下载媒体名称
+    youtube_media = (
+        ("m4a", "mp4")  # 根据 channelid_youtube 的媒体类型选择文件格式
+        if channelid_youtube[youtube_value]["media"] == "m4a"
+        else ("mp4",)  # 如果不是 m4a，则只选择 mp4
+    )
+    try:
+        # 遍历指定目录下的所有文件，筛选出以 youtube_media 结尾的文件
+        youtube_content_ytid_original = [
+            os.path.splitext(file)[0]  # 获取文件名（不包括扩展名）
+            for file in os.listdir(f"channel_audiovisual/{youtube_key}")  # 指定的目录
+            if file.endswith(youtube_media)  # 筛选文件
+        ]
+    except Exception:
+        # 如果发生异常，设置为空列表
+        youtube_content_ytid_original = []
+    try:
+        # 获取原始XML中的内容
+        original_item = gVar.xmls_original[youtube_key]
+        guids = re.findall(r"(?<=<guid>).+(?=</guid>)", original_item)  # 查找所有guid
+    except KeyError:
+        # 如果没有找到对应的key，则guids为空
+        guids = []
+    # 构建 URL
+    youtube_url = f"https://www.youtube.com/feeds/videos.xml?channel_id={youtube_key}"
+    youtube_response = http_client(youtube_url, youtube_value)  # 请求YouTube数据
+    youtube_html_playlists = None
+    youtube_channel_response = None
+    if youtube_response is not None and re.search(
+        pattern_youtube404, youtube_response.text, re.DOTALL
+    ):
+        youtube_url = f"https://www.youtube.com/channel/{youtube_key}"
+        youtube_channel_response = http_client(youtube_url, f"{youtube_value} HTML")
+        if youtube_channel_response is not None:
+            pattern_youtube_error_mark = False
+            for pattern_youtube_error_key in pattern_youtube_error:
+                if pattern_youtube_error_key in youtube_channel_response.text:
+                    pattern_youtube_error_mark = True
+                    youtube_response = youtube_channel_response
+                    break
+            if not pattern_youtube_error_mark:
+                # 检查响应是否有效，最多重试3次
+                for _ in range(3):
+                    if youtube_html_playlists := get_youtube_html_playlists(
+                        youtube_key,
+                        youtube_value,
+                        [
+                            elem
+                            for elem in guids
+                            if elem in youtube_content_ytid_original
+                        ],  # 仅选择已下载的guids
+                        True,
+                        channelid_youtube[youtube_value]["update_size"],
+                        youtube_content_ytid_original,
+                    ):
+                        break
+        shorts_ytid = []
+    elif youtube_response is not None and channelid_youtube[youtube_value]["NoShorts"]:
+        shorts_ytid = get_youtube_shorts_id(youtube_key, youtube_value)
+        gVar.video_id_failed += shorts_ytid  # 将Shorts视频添加到失败列表中
+    else:
+        shorts_ytid = []
+    # 读取原Youtube频道xml文件并判断是否要更新
+    try:
+        with open(
+            f"channel_id/{youtube_key}.txt",
+            "r",
+            encoding="utf-8",  # 以utf-8编码打开文件
+        ) as file:
+            youtube_content_original = file.read()  # 读取文件内容
+            youtube_content_original_clean = vary_replace(
+                pattern_youtube_varys, youtube_content_original
+            )  # 清洗内容
+    except FileNotFoundError:  # 如果文件不存在
+        youtube_content_original = None
+        youtube_content_original_clean = None
+    if youtube_html_playlists is not None:  # 如果有新播放列表
+        channelid_youtube_rss[youtube_key] = {
+            "content": youtube_html_playlists,
+            "type": "dict",
+        }
+        if youtube_html_playlists["item"]:
+            channelid_youtube_ids_update[youtube_key] = youtube_value  # 更新标识
+        youtube_content_ytid = youtube_html_playlists["list"]  # 获取视频ID列表
+    else:
+        if youtube_response is not None:
+            # 如果没有新的播放列表，但响应有效
+            channelid_youtube_rss[youtube_key] = {
+                "content": youtube_response,
+                "type": "html",
+            }
+            youtube_content = youtube_response.text  # 获取响应内容
+            if not youtube_channel_response:
+                youtube_content_clean = vary_replace(
+                    pattern_youtube_varys, youtube_content
+                )  # 清洗内容
+                if (
+                    youtube_content_clean != youtube_content_original_clean
+                    and youtube_response
+                ):  # 判断是否要更新
+                    channelid_youtube_ids_update[youtube_key] = (
+                        youtube_value  # 更新标识
+                    )
+        else:
+            # 如果没有响应，使用原始内容
+            channelid_youtube_rss[youtube_key] = {
+                "content": youtube_content_original,
+                "type": "text",
+            }
+            youtube_content = youtube_content_original
+        try:
+            # 从内容中提取视频ID
+            youtube_content_ytid = re.findall(
+                r"(?<=<id>yt:video:).{11}(?=</id>)", youtube_content
+            )
+        except TypeError:
+            youtube_content_ytid = []  # 处理类型错误
+        youtube_content_ytid = youtube_content_ytid[
+            : channelid_youtube[youtube_value][
+                "update_size"
+            ]  # 限制视频ID数量
+        ]
+    youtube_content_new = list_merge_tidy(youtube_content_ytid, guids)  # 合并并去重
+    if youtube_content_ytid := [
+        exclude
+        for exclude in youtube_content_ytid
+        if exclude not in youtube_content_ytid_original
+        and exclude not in shorts_ytid  # 仅选择新视频ID(并且不是Shorts)
+    ]:
+        channelid_youtube_ids_update[youtube_key] = youtube_value  # 更新标识
+        gVar.youtube_content_ytid_update[youtube_key] = (
+            youtube_content_ytid  # 保存更新的视频ID
+        )
+    # 向后更新
+    if channelid_youtube[youtube_value]["BackwardUpdate"] and guids:
+        # 计算向后更新的数量
+        backward_update_size = channelid_youtube[youtube_value]["last_size"] - len(
+            youtube_content_new
+        )
+        if backward_update_size > 0:
+            for _ in range(3):
+                # 获取历史播放列表
+                if youtube_html_backward_playlists := get_youtube_html_playlists(
+                    youtube_key,
+                    youtube_value,
+                    guids,
+                    False,
+                    min(
+                        backward_update_size,
+                        channelid_youtube[youtube_value]["BackwardUpdate_size"],
+                    ),
+                    youtube_content_ytid_original,
+                ):
+                    break
+            if youtube_html_backward_playlists:
+                backward_list = youtube_html_backward_playlists[
+                    "list"
+                ]  # 获取向后更新的列表
+                for guid in backward_list.copy():
+                    if guid in youtube_content_new:
+                        backward_list.remove(guid)  # 从列表中移除已更新的GUID
+            if youtube_html_backward_playlists and backward_list:
+                channelid_youtube_ids_update[youtube_key] = youtube_value  # 更新标识
+                channelid_youtube_rss[youtube_key].update(
+                    {"backward": youtube_html_backward_playlists}
+                )  # 添加向后更新内容
+                youtube_content_ytid_backward = []
+                youtube_content_ytid_backward.extend(
+                    guid
+                    for guid in backward_list
+                    if guid not in youtube_content_ytid_original
+                )
+                if youtube_content_ytid_backward:
+                    gVar.youtube_content_ytid_backward_update[youtube_key] = (
+                        youtube_content_ytid_backward  # 保存向后更新的ID
+                    )

Podflow/youtube/login.py

@@ -0,0 +1,39 @@
+# Podflow/youtube/login.py
+# coding: utf-8
+
+from datetime import datetime
+from Podflow.basic.http_client import http_client
+from Podflow.basic.write_log import write_log
+from Podflow.netscape.get_cookie_dict import get_cookie_dict
+
+
+def get_youtube_cookie_fail(arg0):
+    print(f"{datetime.now().strftime('%H:%M:%S')}{arg0}")
+    write_log("YouTube \033[31m获取cookie失败\033[0m")
+    return None
+
+
+# 获取YouTube cookie模块
+def get_youtube_cookie(channelid_youtube_ids):
+    if not channelid_youtube_ids:
+        return
+    youtube_cookie = get_cookie_dict("channel_data/yt_dlp_youtube.txt")
+    if youtube_cookie is None:
+        write_log("YouTube \033[31m获取cookie失败\033[0m")
+        return None
+    if response := http_client(
+        "https://www.youtube.com", "YouTube主页", 10, 4, True, youtube_cookie
+    ):
+        html_content = response.text
+        if '"LOGGED_IN":true' in html_content:
+            print(
+                f"{datetime.now().strftime('%H:%M:%S')}|YouTube \033[32m获取cookie成功\033[0m"
+            )
+            return youtube_cookie
+        elif '"LOGGED_IN":false' in html_content:
+            return get_youtube_cookie_fail("|登陆YouTube失败")
+        else:
+            return get_youtube_cookie_fail("|登陆YouTube无法判断")
+    else:
+        write_log("YouTube \033[31m获取cookie失败\033[0m")
+        return None

podflow-2025.1.26.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.1
+Name: podflow
+Version: 2025.1.26
+Summary: A podcast server that includes YouTube and BiliBili
+Home-page: https://github.com/gruel-zxz/podflow
+Author: gruel_zxz
+Author-email: zhuxizhouzxz@gmail.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: astral>=3.2
+Requires-Dist: bottle>=0.13.2
+Requires-Dist: qrcode>=8.0
+Requires-Dist: yt-dlp>=2025.1.15
+Requires-Dist: chardet>=5.2.0
+Requires-Dist: cherrypy>=18.10.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: pycryptodome>=3.21.0
+Requires-Dist: ffmpeg-python>=0.2.0
+Requires-Dist: BeautifulSoup4>=4.12.3
+
+# Podflow
+
+<img src='https://raw.githubusercontent.com/gruel-zxz/podflow/main/Podflow.png' alt='logo' style='width: 150px; height: 150px;'/>
+
+建立Podcast服务器，用于下载YouTube和哔哩哔哩的音视频并导入到Podcast中。
+
+需要新建[配置文件](#主配置), 或通过首次运行后自动生成
+
+YouTube的cookies需要使用chrome插件导出Netscape格式并保存到channel_data文件夹中
+
+PS:可能存在大量未知bug，改进中并尝试加入抖音……
+
+### 安装方法
+
+需要`Python 3.8`以上环境，并安装ffmpeg (安装方法: <https://ffmpeg.org/>)。
+
+Podflow可以使用以下命令进行安装
+
+```
+pip install Podflow
+```
+
+在iOS上可以使用[Shortcuts](<https://apps.apple.com/us/app/shortcuts/id915249334/>)运行Podflow, 需要用到[a-shell](<https://apps.apple.com/us/app/a-shell/id1473805438/>)
+和[捷径脚本](<https://www.icloud.com/shortcuts/54213ea7e46b4b21b7a0bce02f9c64a1/>)
+
+### 命令行参数说明
+
+| 参数           | 选项              | 类型            | 默认值         | 描述                                             |
+|----------------|-------------------|-----------------|-----------------|--------------------------------------------------|
+| `-n`           | `--times`         | `int`         | +∞              | 次数                                             |
+| `-d`           | `--delay`         | `int`         | 1500            | 延迟（单位: 秒）                                   |
+| `-c`           | `--config`        | `string`      | "config.json"   | 配置文件的路径                                     |
+| `--shortcuts`  |                   | `string`      | []              | 仅适用于捷径APP                                   |
+| `--httpfs`     |                   | `boolean`     | 无              | 仅启用服务器功能, 不更新频道                         |
+
+### 使用示例
+
+你可以使用以下命令行格式来运行程序:
+
+```
+Podflow -n 24 -d 3600
+```
+
+---
+
+### 主配置
+
+| 参数                  | 类型        | 默认值                                | 描述                                                                                         |
+| --------------------- | ----------- | ------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `channelid_youtube`   | `dict`      | `{...}`                               | 可以按[YouTube频道配置](#YouTube频道配置)编写, 也可以按`{"youtube": "UCBR8-60-B28hp2BmDPdntcQ"}`编写, 其他参数会按默认值自动补全 |
+| `channelid_bilibili`  | `dict`      | `{...}`                               | 可以按[哔哩哔哩频道配置](#哔哩哔哩频道配置)编写, 也可以按`{"哔哩哔哩弹幕网": "8047632"}`编写, 其他参数会按默认值自动补全 |
+| `preparation_per_count` | `int`       | `100`                                 | 获取媒体信息每组数量                                                                         |
+| `completion_count`    | `int`       | `100`                                 | 媒体缺失时最大补全数量                                                                       |
+| `retry_count`         | `int`       | `5`                                   | 媒体下载重试次数                                                                             |
+| `url`                 | `string`    | `"http://127.0.0.1"`                  | HTTP共享地址                                                                                 |
+| `port`                | `int`       | `8000`                                | HTTP共享端口                                                                                 |
+| `port_in_url`         | `boolean`   | `true`                                | HTTP共享地址是否包含端口                                                                     |
+| `httpfs`              | `boolean`   | `false`                               | HTTP共享日志                                                                                 |
+| `title`               | `string`    | `"Podflow"`                           | 博客的名称                                                                                   |
+| `filename`            | `string`    | `"Podflow"`                           | 主XML的文件名称                                                                              |
+| `link`                | `string`    | `"https://github.com/gruel-zxz/podflow"` | 博客主页                                                                                   |
+| `description`         | `string`    | `"在iOS平台上借助workflow和a-shell搭建专属的播客服务器。"` | 博客信息                                                                                   |
+| `icon`                | `string`    | `"https://raw.githubusercontent.com/gruel-zxz/podflow/main/Podflow.png"` | 博客图标                                                                                   |
+| `category`            | `string`    | `"TV &amp; Film"`                     | 博客类型                                                                                   |
+| `token`               | `string`    | `""`                                  | token认证, 如为null或""将不启用token                                                        |
+| `delete_incompletement` | `boolean` | `false`                               | 是否删除下载中断媒体(下载前处理流程)                                                         |
+| `remove_media`        | `boolean`   | `true`                                | 是否删除无用的媒体文件                                                                       |
+
+---
+
+### YouTube频道配置
+
+| 参数                  | 类型        | 默认值                                | 描述                                                           |
+| --------------------- | ----------- | ------------------------------------- | -------------------------------------------------------------- |
+| `id`                  | `string`    | `"UCBR8-60-B28hp2BmDPdntcQ"`          | 频道ID                                                        |
+| `title`               | `string`    | `"YouTube"`                           | 频道名称                                                     |
+| `update_size`         | `int`       | `15`                                  | 每次获取频道媒体数量                                           |
+| `quality`             | `string`    | `"480"`                               | 媒体分辨率(仅在media为视频时有效)                              |
+| `last_size`           | `int`       | `50`                                  | 媒体保留数量                                                 |
+| `media`               | `string`    | `"m4a"`                               | 下载媒体类型                                                 |
+| `DisplayRSSaddress`   | `boolean`   | `false`                               | 是否在Print中显示子博客地址                                    |
+| `InmainRSS`           | `boolean`   | `true`                                | 是否在主博客中                                               |
+| `QRcode`              | `boolean`   | `false`                               | 是否显示子博客地址二维码(仅在DisplayRSSaddress为True时有效)     |
+| `BackwardUpdate`      | `boolean`   | `false`                               | 是否向后更新                                                 |
+| `BackwardUpdate_size` | `int`       | `3`                                   | 向后更新数量(仅在BackwardUpdate为True时有效)                  |
+| `want_retry_count`    | `int`       | `8`                                   | 媒体获取失败后多少次后重试                                    |
+| `NoShorts`            | `boolean`   | `false`                               | 是否不下载Shorts媒体                                         |
+| `title_change`        | `list`      | `[]`                                  | 标题文本修改规则                                              |
+
+---
+
+### 哔哩哔哩频道配置
+
+| 参数                  | 类型        | 默认值                                | 描述                                                           |
+| --------------------- | ----------- | ------------------------------------- | -------------------------------------------------------------- |
+| `id`                  | `string`    | `"8047632"`                           | 频道ID                                                        |
+| `title`               | `string`    | `"哔哩哔哩弹幕网"`                     | 频道名称                                                     |
+| `update_size`         | `int`       | `25`                                  | 每次获取频道媒体数量                                           |
+| `quality`             | `string`    | `"480"`                               | 媒体分辨率(仅在media为视频时有效)                              |
+| `last_size`           | `int`       | `100`                                 | 媒体保留数量                                                 |
+| `media`               | `string`    | `"m4a"`                               | 下载媒体类型                                                 |
+| `DisplayRSSaddress`   | `boolean`   | `false`                               | 是否在Print中显示子博客地址                                    |
+| `InmainRSS`           | `boolean`   | `true`                                | 是否在主博客中                                               |
+| `QRcode`              | `boolean`   | `false`                               | 是否显示子博客地址二维码(仅在DisplayRSSaddress为True时有效)     |
+| `BackwardUpdate`      | `boolean`   | `false`                               | 是否向后更新                                                 |
+| `BackwardUpdate_size` | `int`       | `3`                                   | 向后更新数量(仅在BackwardUpdate为True时有效)                  |
+| `want_retry_count`    | `int`       | `8`                                   | 媒体获取失败后多少次后重试                                    |
+| `AllPartGet`          | `boolean`   | `false`                               | 是否提前获取分P或互动视频                                     |
+| `title_change`        | `dict`      | `{}`                                  | 标题文本修改规则                                              |
+
+---
+
+### 配置文件参考
+
+```json
+{
+    "preparation_per_count": 100,
+    "completion_count": 100,
+    "retry_count": 5,
+    "url": "http://127.0.0.1",
+    "port": 8000,
+    "port_in_url": true,
+    "httpfs": false,
+    "title": "Podflow",
+    "filename": "Podflow",
+    "link": "https://github.com/gruel-zxz/podflow",
+    "description": "在iOS平台上借助workflow和a-shell搭建专属的播客服务器。",
+    "icon": "https://raw.githubusercontent.com/gruel-zxz/podflow/main/Podflow.png",
+    "category": "TV &amp; Film",
+    "token": "",
+    "delete_incompletement": false,
+    "remove_media": true,
+    "channelid_youtube": {
+        "youtube": {
+            "update_size": 15,
+            "id": "UCBR8-60-B28hp2BmDPdntcQ",
+            "title": "YouTube",
+            "quality": "480",
+            "last_size": 50,
+            "media": "m4a",
+            "DisplayRSSaddress": false,
+            "InmainRSS": true,
+            "QRcode": false,
+            "BackwardUpdate": false,
+            "BackwardUpdate_size": 3,
+            "want_retry_count": 8,
+            "title_change": [
+                {
+                    "mode": "add-left",
+                    "match": "",
+                    "url": "https://www.youtube.com/playlist?list=...",
+                    "text": ""
+                },
+                {
+                    "mode": "add-right",
+                    "match": "",
+                    "url": "",
+                    "text": ""
+                }
+            ],
+            "NoShorts": false
+        }
+    },
+    "channelid_bilibili": {
+        "哔哩哔哩弹幕网": {
+            "update_size": 25,
+            "id": "8047632",
+            "title": "哔哩哔哩弹幕网",
+            "quality": "480",
+            "last_size": 100,
+            "media": "m4a",
+            "DisplayRSSaddress": false,
+            "InmainRSS": true,
+            "QRcode": false,
+            "BackwardUpdate": false,
+            "BackwardUpdate_size": 3,
+            "want_retry_count": 8,
+            "title_change": {
+                "mode": "replace",
+                "match": "",
+                "text": ""
+            },
+            "AllPartGet": false
+        }
+    }
+}
+```
+
+