podflow 2025.1.26__py3-none-any.whl

Podflow/message/media_format.py

@@ -0,0 +1,195 @@
+# Podflow/message/media_format.py
+# coding: utf-8
+
+import yt_dlp
+from Podflow.message.fail_message_initialize import fail_message_initialize
+
+
+class MyLogger:
+    def debug(self, msg):
+        pass
+
+    def warning(self, msg):
+        pass
+
+    def info(self, msg):
+        pass
+
+    def error(self, msg):
+        pass
+
+
+def duration_and_formats(video_website, video_url, cookies):
+    fail_message, infos = None, []
+    try:
+        # 初始化 yt_dlp 实例, 并忽略错误
+        ydl_opts = {
+            "no_warnings": True,
+            "quiet": True,  # 禁止非错误信息的输出
+            "logger": MyLogger(),
+        }
+        if cookies:
+            if "www.bilibili.com" in video_website:
+                ydl_opts["http_headers"] = {
+                    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+                    "Referer": "https://www.bilibili.com/",
+                }
+            elif "www.youtube.com" in video_website:
+                ydl_opts["http_headers"] = {
+                    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+                    "Referer": "https://www.youtube.com/",
+                }
+            ydl_opts["cookiefile"] = cookies  # cookies 是你的 cookies 文件名
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            # 使用提供的 URL 提取视频信息
+            if info_dict := ydl.extract_info(f"{video_website}", download=False):
+                # 获取视频时长并返回
+                entries = info_dict.get("entries", None)
+                download_url = info_dict.get("original_url", None)
+                if entries:
+                    infos.extend(
+                        {
+                            "title": entry.get("title"),
+                            "duration": entry.get("duration"),
+                            "formats": entry.get("formats"),
+                            "timestamp": entry.get("timestamp"),
+                            "id": entry.get("id"),
+                            "description": entry.get("description"),
+                            "url": entry.get("webpage_url"),
+                            "image": entry.get("thumbnail"),
+                            "download": {
+                                "url": download_url,
+                                "num": playlist_num + 1,
+                            },
+                            "format_note": entry.get("format_note"),
+                        }
+                        for playlist_num, entry in enumerate(entries)
+                    )
+                else:
+                    infos.append(
+                        {
+                            "title": info_dict.get("title"),
+                            "duration": info_dict.get("duration"),
+                            "formats": info_dict.get("formats"),
+                            "timestamp": info_dict.get("timestamp"),
+                            "id": info_dict.get("id"),
+                            "description": info_dict.get("description"),
+                            "url": info_dict.get("webpage_url"),
+                            "image": info_dict.get("thumbnail"),
+                            "download": {"url": download_url, "num": None},
+                            "format_note": info_dict.get("format_note"),
+                        }
+                    )
+    except Exception as message_error:
+        fail_message = fail_message_initialize(message_error, video_url)
+    return fail_message, infos
+
+
+# 定义条件判断函数
+def check_resolution(item, quality):
+    if "aspect_ratio" in item and (isinstance(item["aspect_ratio"], (float, int))):
+        if item["aspect_ratio"] >= 1:
+            return item["height"] <= int(quality)
+        else:
+            return item["width"] <= int(quality)
+    else:
+        return False
+
+
+def check_ext(item, media):
+    return item["ext"] == media if "ext" in item else False
+
+
+def check_vcodec(item):
+    if "vcodec" in item:
+        return (
+            "vp" not in item["vcodec"].lower()
+            and "av01" not in item["vcodec"].lower()
+            and "hev1" not in item["vcodec"].lower()
+        )
+    else:
+        return False
+
+
+# 获取最好质量媒体的id
+def best_format_id(formats):
+    tbr_max = 0.0
+    format_id_best = ""
+    vcodec_best = ""
+    for form in formats:
+        if (
+            "tbr" in form
+            and "drc" not in form["format_id"]
+            and form["protocol"] == "https"
+            and (isinstance(form["tbr"], (float, int)))
+            and form["tbr"] >= tbr_max
+        ):
+            tbr_max = form["tbr"]
+            format_id_best = form["format_id"]
+            vcodec_best = form["vcodec"]
+    return format_id_best, vcodec_best
+
+
+# 获取媒体时长和ID模块
+def media_format(video_website, video_url, media="m4a", quality="480", cookies=None):
+    fail_message = None
+    video_id_count, change_error, fail_message, infos = 0, None, "", []
+    while (
+        video_id_count < 3
+        and change_error is None
+        and (fail_message is not None or not infos)
+    ):
+        video_id_count += 1
+        fail_message, infos = duration_and_formats(video_website, video_url, cookies)
+    if fail_message is not None:
+        return fail_message
+    lists = []
+    for entry in infos:
+        duration = entry["duration"]
+        formats = entry["formats"]
+        if duration == "" or duration is None:
+            return "无法获取时长"
+        if formats == "" or formats is None:
+            return "无法获取格式"
+        # 进行筛选
+        formats_m4a = list(
+            filter(lambda item: check_ext(item, "m4a") and check_vcodec(item), formats)
+        )
+        (best_formats_m4a, vcodec_best) = best_format_id(formats_m4a)
+        if best_formats_m4a == "" or best_formats_m4a is None:
+            return (
+                "\033[31m试看\033[0m"
+                if entry["format_note"] == "试看"
+                else "无法获取音频ID"
+            )
+        duration_and_id = [duration, best_formats_m4a]
+        if media == "mp4":
+            formats_mp4 = list(
+                filter(
+                    lambda item: check_resolution(item, quality)
+                    and check_ext(item, "mp4")
+                    and check_vcodec(item),
+                    formats,
+                )
+            )
+            (best_formats_mp4, vcodec_best) = best_format_id(formats_mp4)
+            if best_formats_mp4 == "" or best_formats_mp4 is None:
+                return (
+                    "\033[31m试看\033[0m"
+                    if entry["format_note"] == "试看"
+                    else "无法获取视频ID"
+                )
+            duration_and_id.extend((best_formats_mp4, vcodec_best))
+        lists.append(
+            {
+                "duration_and_id": duration_and_id,
+                "title": entry.get("title"),
+                "timestamp": entry.get("timestamp"),
+                "id": entry.get("id"),
+                "description": entry.get("description"),
+                "url": entry.get("url"),
+                "image": entry.get("image"),
+                "download": entry.get("download"),
+            }
+        )
+    return lists

Podflow/message/original_rss_fail_print.py

@@ -0,0 +1,15 @@
+# Podflow/message/original_rss_fail_print.py
+# coding: utf-8
+
+from Podflow import gVar
+from Podflow.basic.write_log import write_log
+
+
+# 打印无法保留原节目信息模块
+def original_rss_fail_print(xmls_original_fail):
+    channelid_ids = gVar.channelid_youtube_ids | gVar.channelid_bilibili_ids
+    for item in xmls_original_fail:
+        if item in channelid_ids.keys():
+            write_log(
+                f"RSS文件中不存在 {channelid_ids[item]} 无法保留原节目"
+            )

Podflow/message/rss_create_hash.py

@@ -0,0 +1,26 @@
+# Podflow/message/rss_create_hash.py
+# coding: utf-8
+
+import re
+import hashlib
+
+
+# 生成哈希值模块
+def create_hash(data):
+    data_str = str(data)
+    hash_object = hashlib.sha256()
+    hash_object.update(data_str.encode())
+    return hash_object.hexdigest()
+
+
+# rss生成哈希值模块
+def rss_create_hash(data):
+    patterns = [
+        r"<lastBuildDate>(\w+), (\d{2}) (\w+) (\d{4}) (\d{2}):(\d{2}):(\d{2}) \+\d{4}</lastBuildDate>",
+        r"Podflow_light\.png",
+        r"Podflow_dark\.png",
+    ]
+    replacement = ""
+    for pattern in patterns:
+        data = re.sub(pattern, replacement, data)
+    return create_hash(data)

Podflow/message/title_correction.py

@@ -0,0 +1,30 @@
+# Podflow/message/title_correction.py
+# coding: utf-8
+
+import re
+
+
+# 标题文本修改
+def title_correction(title, video_url, title_changes: list):
+    for title_change in title_changes:
+        match = title_change.get("match", None)
+        mode = title_change["mode"]
+        text = title_change["text"]
+        table = title_change.get("table", [])
+
+        def add_title(mode, text, title):
+            if mode == "add-left":
+                return text + title
+            elif mode == "add-right":
+                return title + text
+
+        if text and text in title:
+            return title
+        elif video_url in table:
+            return add_title(mode, text, title)
+        elif match is not None and re.search(match, title):
+            if mode == "replace":
+                return re.sub(match, text, title)
+            else:
+                return add_title(mode, text, title)
+    return title

Podflow/message/update_information_display.py

@@ -0,0 +1,72 @@
+# Podflow/message/want_retry.py
+# coding: utf-8
+
+import re
+import os
+from Podflow.basic.write_log import write_log
+
+
+# 输出需要更新的信息模块
+def update_information_display(
+    channelid_ids_update, content_id_update, content_id_backward_update, name
+):
+    if not channelid_ids_update:
+        return
+    print_channelid_ids_update = f"需更新的{name}频道:\n"
+    # 获取命令行字节宽度
+    try:
+        terminal_width = os.get_terminal_size().columns
+    except OSError:
+        terminal_width = 47
+    # 尝试拆分输出
+    try:
+        for channelid_key, channelid_value in channelid_ids_update.items():
+            if len(print_channelid_ids_update) != len(name) + 8:
+                if (
+                    len(
+                        re.sub(
+                            r"\033\[[0-9;]+m",
+                            "",
+                            print_channelid_ids_update.split("\n")[-1],
+                        ).encode("GBK")
+                    )
+                    + len(f" | {channelid_value}".encode("utf-8"))
+                    <= terminal_width
+                ):
+                    print_channelid_ids_update += " | "
+                else:
+                    print_channelid_ids_update += "\n"
+            if (
+                channelid_key in content_id_update
+                and channelid_key in content_id_backward_update
+            ):
+                print_channelid_ids_update += f"\033[34m{channelid_value}\033[0m"
+            elif channelid_key in content_id_update:
+                print_channelid_ids_update += f"\033[32m{channelid_value}\033[0m"
+            elif channelid_key in content_id_backward_update:
+                print_channelid_ids_update += f"\033[36m{channelid_value}\033[0m"
+            else:
+                print_channelid_ids_update += f"\033[33m{channelid_value}\033[0m"
+    # 如果含有特殊字符将使用此输出
+    except Exception:
+        len_channelid_ids_update = len(channelid_ids_update)
+        count_channelid_ids_update = 1
+        for channelid_key, channelid_value in channelid_ids_update.items():
+            if (
+                channelid_key in content_id_update
+                and channelid_key in content_id_backward_update
+            ):
+                print_channelid_ids_update += f"\033[34m{channelid_value}\033[0m"
+            elif channelid_key in content_id_update:
+                print_channelid_ids_update += f"\033[32m{channelid_value}\033[0m"
+            elif channelid_key in content_id_backward_update:
+                print_channelid_ids_update += f"\033[36m{channelid_value}\033[0m"
+            else:
+                print_channelid_ids_update += f"\033[33m{channelid_value}\033[0m"
+            if count_channelid_ids_update != len_channelid_ids_update:
+                if count_channelid_ids_update % 2 != 0:
+                    print_channelid_ids_update += " | "
+                else:
+                    print_channelid_ids_update += "\n"
+                count_channelid_ids_update += 1
+    write_log(print_channelid_ids_update)

Podflow/message/update_youtube_bilibili_rss.py

@@ -0,0 +1,116 @@
+# Podflow/message/update_youtube_bilibili_rss.py
+# coding: utf-8
+
+import re
+import threading
+from Podflow import gVar
+from Podflow.basic.file_save import file_save
+from Podflow.basic.write_log import write_log
+from Podflow.youtube.get import youtube_rss_update
+from Podflow.basic.folder_build import folder_build
+from Podflow.bilibili.get import bilibili_rss_update
+
+
+# 更新Youtube和哔哩哔哩频道xml多线程模块
+def update_youtube_bilibili_rss():
+    pattern_youtube404 = r"Error 404 \(Not Found\)"  # 设置要匹配的正则表达式模式
+    pattern_youtube_error = {
+        "This channel was removed because it violated our Community Guidelines.": "违反社区准则",
+        "This channel does not exist.": "不存在 (ID错误) ",
+    }
+    pattern_youtube_varys = [
+        r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-2][0-9]:[0-6][0-9]:[0-6][0-9]\+00:00",
+        r'starRating count="[0-9]*"',
+        r'statistics views="[0-9]*"',
+        r"<id>yt:channel:(UC)?(.{22})?</id>",
+        r"<yt:channelId>(UC)?(.{22})?</yt:channelId>",
+    ]
+    youtube_bilibili_rss_update_threads = []  # 创建线程列表
+    # Youtube多线程
+    for youtube_key, youtube_value in gVar.channelid_youtube_ids.items():
+        thread = threading.Thread(
+            target=youtube_rss_update,
+            args=(
+                youtube_key,
+                youtube_value,
+                pattern_youtube_varys,
+                pattern_youtube404,
+                pattern_youtube_error,
+            ),
+        )
+        youtube_bilibili_rss_update_threads.append(thread)
+        # 开始多线程
+        thread.start()
+    # 哔哩哔哩多线程
+    for bilibili_key, bilibili_value in gVar.channelid_bilibili_ids.items():
+        thread = threading.Thread(
+            target=bilibili_rss_update, args=(bilibili_key, bilibili_value)
+        )
+        youtube_bilibili_rss_update_threads.append(thread)
+        # 开始多线程
+        thread.start()
+    # 等待所有线程完成
+    for thread in youtube_bilibili_rss_update_threads:
+        thread.join()
+
+    # 寻找错误原因
+    def youtube_error(youtube_content, pattern_youtube_error):
+        for (
+            pattern_youtube_error_key,
+            pattern_youtube_error_value,
+        ) in pattern_youtube_error.items():
+            if pattern_youtube_error_key in youtube_content:
+                return pattern_youtube_error_value
+
+    # 更新Youtube频道
+    for youtube_key, youtube_value in gVar.channelid_youtube_ids.copy().items():
+        youtube_response = gVar.channelid_youtube_rss[youtube_key]["content"]
+        youtube_response_type = gVar.channelid_youtube_rss[youtube_key]["type"]
+        # xml分类及存储
+        if youtube_response is not None:
+            if youtube_response_type == "dict":
+                # 构建频道文件夹
+                folder_build(youtube_key, "channel_audiovisual")
+            else:
+                if youtube_response_type == "html":
+                    youtube_content = youtube_response.text
+                elif youtube_response_type == "text":
+                    youtube_content = youtube_response
+                    write_log(f"YouTube频道 {youtube_value} 无法更新")
+                else:
+                    youtube_content = ""
+                # 判断频道id是否正确
+                if re.search(pattern_youtube404, youtube_content, re.DOTALL):
+                    del gVar.channelid_youtube_ids[youtube_key]  # 删除错误ID
+                    write_log(f"YouTube频道 {youtube_value} ID不正确无法获取")
+                elif youtube_error_message := youtube_error(
+                    youtube_content, pattern_youtube_error
+                ):
+                    del gVar.channelid_youtube_ids[youtube_key]  # 删除错误ID
+                    write_log(f"YouTube频道 {youtube_value} {youtube_error_message}")
+                else:
+                    # 构建文件
+                    file_save(youtube_content, f"{youtube_key}.txt", "channel_id")
+                    # 构建频道文件夹
+                    folder_build(youtube_key, "channel_audiovisual")
+        else:
+            if youtube_response_type == "text":
+                del gVar.channelid_youtube_ids[youtube_key]
+            write_log(f"YouTube频道 {youtube_value} 无法更新")
+    # 更新哔哩哔哩频道
+    for bilibili_key, bilibili_value in gVar.channelid_bilibili_ids.copy().items():
+        bilibili_space = gVar.channelid_bilibili_rss[bilibili_key]["content"]
+        bilibili_space_type = gVar.channelid_bilibili_rss[bilibili_key]["type"]
+        # xml分类及存储
+        if bilibili_space_type == "int":
+            del gVar.channelid_bilibili_ids[bilibili_key]  # 删除错误ID
+            write_log(f"BiliBili频道 {bilibili_value} ID不正确无法获取")
+        elif bilibili_space_type == "json":
+            write_log(f"BiliBili频道 {youtube_value} 无法更新")
+            if bilibili_space == {}:
+                del gVar.channelid_bilibili_ids[bilibili_key]
+        else:
+            # 构建文件
+            file_save(bilibili_space, f"{bilibili_key}.json", "channel_id")
+            # 构建频道文件夹
+            folder_build(bilibili_key, "channel_audiovisual")

Podflow/message/want_retry.py

@@ -0,0 +1,21 @@
+# Podflow/message/want_retry.py
+# coding: utf-8
+
+import re
+
+
+# 判断是否重试模块
+def want_retry(video_url, num=1):
+    # 定义正则表达式模式（不区分大小写）
+    pattern = rf'\|{video_url}\|(试看|跳过更新|删除或受限|充电专属|直播预约\|a few moments\.)'
+    # 读取 Podflow.log 文件
+    try:
+        with open('Podflow.log', 'r', encoding='utf-8') as file:
+            content = file.read()  # 读取文件内容
+        # 使用 re.findall() 查找所有匹配项
+        matches = re.findall(pattern, content)
+        # 计算匹配的个数
+        count = len(matches)
+    except Exception:
+        count = 0
+    return count < num or count % num == 0

Podflow/message/xml_item.py

@@ -0,0 +1,83 @@
+# Podflow/message/xml_item.py
+# coding: utf-8
+
+import os
+import html
+import hashlib
+from Podflow.message.title_correction import title_correction
+from Podflow.basic.time_format import time_format
+from Podflow.basic.get_duration import get_duration
+from Podflow import gVar
+
+
+# 生成item模块
+def xml_item(
+    video_url,
+    output_dir,
+    video_website,
+    channelid_title,
+    title,
+    description,
+    pubDate,
+    image,
+    title_change=None,
+):
+    if title_change is None:
+        title_change = []
+    channelid_title = html.escape(channelid_title)
+    if title_change:
+        title = title_correction(title, video_url, title_change)
+    # 查看标题中是否有频道名称如无添加到描述中并去除空字符
+    title = title.replace("\x00", "")
+    if channelid_title not in title:
+        if description == "":
+            description = f"『{channelid_title}』{description}"
+        else:
+            description = f"『{channelid_title}』\n{description}".replace("\x00", "")
+    # 更换描述换行符
+    replacement_description = description.replace("\n", "
").replace("\t", "	")
+    # 获取文件后缀和文件字节大小
+    if os.path.exists(f"channel_audiovisual/{output_dir}/{video_url}.mp4"):
+        video_length_bytes = os.path.getsize(
+            f"channel_audiovisual/{output_dir}/{video_url}.mp4"
+        )
+        output_format = "mp4"
+        video_type = "video/mp4"
+    else:
+        if os.path.exists(f"channel_audiovisual/{output_dir}/{video_url}.m4a"):
+            video_length_bytes = os.path.getsize(
+                f"channel_audiovisual/{output_dir}/{video_url}.m4a"
+            )
+        else:
+            video_length_bytes = 0
+        output_format = "m4a"
+        video_type = "audio/x-m4a"
+    # 获取文件时长
+    duration = time_format(
+        get_duration(f"channel_audiovisual/{output_dir}/{video_url}.{output_format}")
+    )
+    # 生成url
+    if gVar.config["token"]:
+        input_string = f"{gVar.config['token']}/channel_audiovisual/{output_dir}/{video_url}.{output_format}"
+    else:
+        input_string = f"channel_audiovisual/{output_dir}/{video_url}.{output_format}"
+    sha256_hash = hashlib.sha256(input_string.encode()).hexdigest()
+    url = f"{gVar.config['address']}/channel_audiovisual/{output_dir}/{video_url}.{output_format}?token={sha256_hash}"
+    # 回显对应的item
+    return f"""
+        <item>
+            <guid>{video_url}</guid>
+            <title>{title}</title>
+            <link>{video_website}</link>
+            <description>{replacement_description}</description>
+            <pubDate>{pubDate}</pubDate>
+            <enclosure url="{url}" length="{video_length_bytes}" type="{video_type}"></enclosure>
+            <itunes:author>{title}</itunes:author>
+            <itunes:subtitle>{title}</itunes:subtitle>
+            <itunes:summary><![CDATA[{description}]]></itunes:summary>
+            <itunes:image href="{image}"></itunes:image>
+            <itunes:duration>{duration}</itunes:duration>
+            <itunes:explicit>no</itunes:explicit>
+            <itunes:order>1</itunes:order>
+        </item>
+"""

Podflow/message/xml_original_item.py

@@ -0,0 +1,92 @@
+# Podflow/message/xml_original_item.py
+# coding: utf-8
+
+import re
+import html
+import hashlib
+from Podflow import gVar
+from Podflow.message.title_correction import title_correction
+
+
+# 生成原有的item模块
+def xml_original_item(original_item, channelid_title, change_judgment=False, title_change=None):
+    if title_change:
+        title_change = []
+    def description_change(text, sep, title, channelid_title):
+        channelid_title = html.escape(channelid_title)
+        if sep in text:
+            text_one, text_two = text.split(sep, 1)
+            if text_one[0] == "『" and text_one[-1] == "』":
+                text = text_two
+        elif text:
+            if text[0] == "『" and text[-1] == "』":
+                text = ""
+        if channelid_title not in title:
+            if text == "":
+                text = f"『{channelid_title}』{text}"
+            else:
+                text = f"『{channelid_title}』{sep}{text}".replace('\x00', '')
+        return text
+    guid = re.search(r"(?<=<guid>).+(?=</guid>)", original_item).group()
+    title = re.search(r"(?<=<title>).+(?=</title>)", original_item).group()
+    if title_change:
+        title = title_correction(title, guid, title_change)
+    title = title.replace('\x00', '')
+    link = re.search(r"(?<=<link>).+(?=</link>)", original_item).group()
+    description = re.search(r"(?<=<description>).+(?=</description>)", original_item)
+    description = description.group() if description else ""
+    if change_judgment:
+        description = description_change(description, "&#xA;", title, channelid_title)
+    pubDate = re.search(r"(?<=<pubDate>).+(?=</pubDate>)", original_item).group()
+    url = re.search(r"(?<=<enclosure url\=\").+?(?=\")", original_item).group()
+    url = re.search(r"(?<=/channel_audiovisual/).+/.+\.(m4a|mp4)", url).group()
+    if gVar.config["token"]:
+        input_string = f"{gVar.config['token']}/channel_audiovisual/{url}"
+    else:
+        input_string = f"channel_audiovisual/{url}"
+    sha256_hash = hashlib.sha256(input_string.encode()).hexdigest()
+    url = f"{gVar.config['address']}/channel_audiovisual/{url}?token={sha256_hash}"
+    length = re.search(r"(?<=length\=\")[0-9]+(?=\")", original_item).group()
+    type_video = re.search(
+        r"(?<=type\=\")(video/mp4|audio/x-m4a|audio/mpeg)(?=\")", original_item
+    ).group()
+    if type_video == "audio/mpeg":
+        type_video = "audio/x-m4a"
+    itunes_summary = re.search(
+        r"(?<=<itunes:summary><\!\[CDATA\[).+(?=\]\]></itunes:summary>)",
+        original_item,
+        flags=re.DOTALL,
+    )
+    itunes_summary = itunes_summary.group() if itunes_summary else ""
+    if change_judgment:
+        itunes_summary = description_change(itunes_summary, "\n", title, channelid_title)
+    itunes_image = re.search(
+        r"(?<=<itunes:image href\=\").+(?=\"></itunes:image>)", original_item
+    )
+    itunes_image = itunes_image.group() if itunes_image else ""
+    itunes_duration = re.search(
+        r"(?<=<itunes:duration>).+(?=</itunes:duration>)", original_item
+    ).group()
+    itunes_explicit = re.search(
+        r"(?<=<itunes:explicit>).+(?=</itunes:explicit>)", original_item
+    ).group()
+    itunes_order = re.search(
+        r"(?<=<itunes:order>).+(?=</itunes:order>)", original_item
+    ).group()
+    return f"""
+        <item>
+            <guid>{guid}</guid>
+            <title>{title}</title>
+            <link>{link}</link>
+            <description>{description}</description>
+            <pubDate>{pubDate}</pubDate>
+            <enclosure url="{url}" length="{length}" type="{type_video}"></enclosure>
+            <itunes:author>{title}</itunes:author>
+            <itunes:subtitle>{title}</itunes:subtitle>
+            <itunes:summary><![CDATA[{itunes_summary}]]></itunes:summary>
+            <itunes:image href="{itunes_image}"></itunes:image>
+            <itunes:duration>{itunes_duration}</itunes:duration>
+            <itunes:explicit>{itunes_explicit}</itunes:explicit>
+            <itunes:order>{itunes_order}</itunes:order>
+        </item>
+"""