Convert documents to videos using large language models

Have you ever searched for something online and failed to find useful information?
Before large language models
We used search engines to find answers. But because web content quality varies widely, you might read five pages and still not find the answer you need.
![](https://alidocs.oss-cn-zhangjiakou.aliyuncs.com/res/54Lq3RNeD78gn7Ed/img/73015ab5-b36a-4da9-9b74-05f7e51e051a.png)
After large language models
Enter your question directly into a large language model—for example, “How do I install Python?” Because large language models hold vast, high-quality knowledge, they return accurate answers, including installation steps for different operating systems. This is much easier than searching manually.
![](https://alidocs.oss-cn-zhangjiakou.aliyuncs.com/res/54Lq3RNeD78gn7Ed/img/099ec62b-b47a-47ab-afeb-06006ce9936f.png)
Large language models are now influencing every part of our lives. From ChatGPT’s breakout success at the end of 2022 to the ongoing “hundred-model competition,” large language models have become hot topics in both technology and public discourse.
Large language models mark a major milestone in artificial intelligence. They advance AI capabilities and open new possibilities for humanity.
Some compare the invention of large language models to a pivotal moment in human history. A poetic answer might be: the moment humans learned to use fire.
![](https://alidocs.oss-cn-zhangjiakou.aliyuncs.com/res/8K4nyR5gBWWYqLbj/img/0840fa91-85af-4f30-b3d2-6e348569a37c.webp)
After completing this course, you will be able to:
Understand the features, key concepts, and working principles of large language models;
Learn about Alibaba Cloud’s large language model offerings and product matrix;
Explore common scenarios and examples of large language model applications.

import argparse
import datetime
import os
import shutil

# Import functions here



def main(args):
    # Record start time
    start_time = datetime.datetime.now()
    # Create output path and copy render assets
    input_base_name = os.path.splitext(os.path.basename(args.input_txt_path))[0]

    if not os.path.exists(args.markdown_path):
        os.makedirs(args.markdown_path)  
    for filename in os.listdir(args.input_style_path):
        full_path = os.path.join(args.input_style_path, filename)
        if os.path.isfile(full_path):
            shutil.copy2(full_path, args.markdown_path) 


    # Call functions here

    # Record end time
    end_time = datetime.datetime.now() 

    # Calculate total time
    elapsed_time = end_time - start_time  
    elapsed_hours, remainder = divmod(elapsed_time.total_seconds(), 3600)
    elapsed_minutes, elapsed_seconds = divmod(remainder, 60)
    
    start_time_str = start_time.strftime("%Y-%m-%d %H:%M:%S")
    end_time_str = end_time.strftime("%Y-%m-%d %H:%M:%S")
    elapsed_time_str = f"{int(elapsed_hours)}h {int(elapsed_minutes)}m {int(elapsed_seconds)}s"
    
    print(f"Start time: {start_time_str}")
    print(f"End time: {end_time_str}")
    print(f"Total time: {elapsed_time_str}")


if __name__ == "__main__":

    parser = argparse.ArgumentParser(description="Convert documents to videos")
 
    # Add command-line argument --input_txt_path, default value './input/section_1.md', path to input text
    parser.add_argument('--input_txt_path', type=str, default='./input/section_1.md', help='Path to input text')

    # Add command-line argument --input_style_path, default value './style', path to style folder
    parser.add_argument('--input_style_path', type=str, default='./style', help='Path to input style folder')

    # Add command-line argument --markdown_style_path, default value './style/style.md', path to Markdown style file
    parser.add_argument('--markdown_style_path', type=str, default='./style/style.md', help='Path to Markdown style file')

    # Add command-line argument --logo_path, default value './style/logo.png', path to logo image
    parser.add_argument('--logo_path', type=str, default='./style/logo.png', help='Path to logo image')

    # Add command-line argument --theme_path, default value './style/theme.png', path to theme image
    parser.add_argument('--theme_path', type=str, default='./style/theme.png', help='Path to theme image')

    # Add command-line argument --title_path, default value './style/title.png', path to title image
    parser.add_argument('--title_path', type=str, default='./style/title.png', help='Path to title image')

    # Add command-line argument --json_path, default value './material/json', path to JSON files
    parser.add_argument('--json_path', type=str, default='./material/json', help='Path to JSON files')

    # Add command-line argument --image_path, default value './material/image', path to image folder
    parser.add_argument('--image_path', type=str, default='./material/image', help='Path to image folder')

    # Add command-line argument --audio_path, default value './material/audio', path to audio folder
    parser.add_argument('--audio_path', type=str, default='./material/audio', help='Path to audio folder')

    # Add command-line argument --markdown_path, default value './material/markdown', path to Markdown folder
    parser.add_argument('--markdown_path', type=str, default='./material/markdown', help='Path to Markdown folder')

    # Add command-line argument --srt_and_video_path, default value './material/video', path to subtitle and video folder
    parser.add_argument('--srt_and_video_path', type=str, default='./material/video', help='Path to subtitle and video folder')

    # Add command-line argument --fps, default value 30, frames per second
    parser.add_argument('--fps', type=int, default=30, help='Frames per second')

    # Add command-line argument --title, default value "Understanding Large Language Models", video title
    parser.add_argument('--title', type=str, default="Understanding Large Language Models", help='Document subject')

    args = parser.parse_args()

    main(args)

from http import HTTPStatus
import dashscope
import re

def theme_generate_with_qwen_plus(input_filepath, title):
    """
    Generate a summary title using Qwen-Plus.

    This function reads the content of a specified file and generates a precise, concise summary title based on that content and a given subject.
    
    Parameters:
    - input_filepath: Path to the input file. Its content is used to generate the summary title.
    - title: Subject around which the summary title must be built. Ensure the title closely relates to this subject.

    Returns:
    - response_content: Generated summary title.

    Notes:
    - Requests are streamed. Content is accumulated only when the response status code is HTTPStatus.OK.
    - On error, the function prints relevant request error details.
    """
    # Read input file content
    with open(input_filepath, 'r', encoding='utf-8') as file:
        content = file.read()

    # Build prompt to guide the model to generate a title tightly focused on the subject
    prompt = f"""
                Create a precise, concise summary title for the following document. The title must reflect the core content and ignore all links—focus only on text.
                Keep the title tightly focused on the subject "{title}".
                Return only the title—no extra text. Use no more than 10 Chinese characters. Answer in Chinese.
                Document content:
              """

    # Build message format
    messages = [{
        'role': 'user',
        'content': f"""
                    "{prompt}"
                    "{content}"
                   """
    }]

    # Initialize response content
    response_content = ''

    # Stream responses
    responses = dashscope.Generation.call("qwen-plus",
                                          messages=messages,
                                          result_format='message',
                                          stream=True,
                                          incremental_output=True)

    # Accumulate title content from responses
    for response in responses:
        if response.status_code == HTTPStatus.OK:
            response_content += response.output.choices[0]['message']['content']
        else:
            # Print error info
            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
                response.request_id, response.status_code,
                response.code, response.message
            ))

    # Remove surrounding double quotes if present
    response_content = re.sub(r'^"|"$', '', response_content)

    # Return generated title
    return response_content

# Import
from theme_generate import theme_generate_with_qwen_plus

# Call
# Call Qwen-Plus via API to generate a document title
theme = theme_generate_with_qwen_plus(args.input_txt_path, args.title)
# Print document title
print(theme)

from http import HTTPStatus
import dashscope
import json
import os
def doc_split_with_qwen_plus(input_filepath, output_filepath):

    if not os.path.exists(output_filepath):
        os.makedirs(output_filepath)

    with open(input_filepath, 'r', encoding='utf-8') as file:
        content = file.read()

    prompt = """
                    Process the document by splitting it into sections and generating section titles. Follow these rules:

                    1. **Section logic**: Analyze the document content and split it into sections based on semantic meaning.

                    2. **Title creation**: For each section, write a concise title—no more than 10 characters—that accurately summarizes its core idea.

                    3. **Output format**: Output must be valid JSON. Each section and its title form one entry. Example format:
                    

                    [ 
                        {"title": " ", "content": " "},
                        {"title": " ", "content": " "},
                        ...
                    ]
              
                    Start with "[" and end with "]". Output nothing else.

                    4. **Text fidelity**: The "content" field in each JSON entry must match the original document exactly—no additions, deletions, or changes. Process the entire document without omissions. Preserve the relative position of text and links.

                    5. **Link handling**: Save Markdown image links separately in JSON entries. Set "title" to "link{index}" and "content" to the URL, where index is the link order.

                    6. **Formatting restrictions**: Output must contain no extra spaces, line feeds, tab characters, or HTML/XML/Markdown symbols. Use Chinese only.
    
                    Follow all rules strictly.

                    Document content:
              """

    messages = [{
        'role': 'user',
        'content': f"""
                    "{prompt}"
                    "{content}"
                   """
    }]

    response_content = ''
    responses = dashscope.Generation.call("qwen-plus",
                                          messages=messages,
                                          result_format='message',
                                          stream=True,
                                          incremental_output=True)

    for response in responses:
        if response.status_code == HTTPStatus.OK:
            response_content += response.output.choices[0]['message']['content']
        else:
            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
                response.request_id, response.status_code,
                response.code, response.message
            ))
    if response_content.startswith("```") and response_content.endswith("```"):
        response_content = response_content[8:-3].strip()

    input_base_name = os.path.splitext(os.path.basename(input_filepath))[0]
    output_file_path = os.path.join(output_filepath, f'{input_base_name}.json')
    with open(output_file_path, 'w', encoding='utf-8') as json_file:
        json.dump(json.loads(response_content), json_file, ensure_ascii=False, indent=4)

    return response_content

# Import
from doc_split import doc_split_with_qwen_plus

# Call
# Call Qwen-Plus via API to split the input document into sections and generate a title for each
doc_split_with_qwen_plus(args.input_txt_path, os.path.join(args.json_path))

import asyncio

import os
from http import HTTPStatus
import dashscope

def call_with_stream(content):
    prompt2 = """
                    Extract the main points from the text below and output them in Markdown format. Use Chinese.
                    If the text is a link, output it directly in Markdown format.
                    Output only valid Markdown. Avoid symbols like '''.
                    Keep Markdown content concise.
                    In each Markdown section, limit content lines to three.
                    Do not add extra paragraphs after "- content".

                    Example input: Have you ever searched for something online and failed to find useful information?
                    Example output: - Search engine issue: Hard to find useful information

                    Example input: https://alidocs.oss-cn-zhangjiakou.aliyuncs.com/res/54Lq3RNeD78gn7Ed/img/6f9f3049-78a2-46b3-a052-88792052890d.png
                    Example output: https://alidocs.oss-cn-zhangjiakou.aliyuncs.com/res/54Lq3RNeD78gn7Ed/img/6f9f3049-78a2-46b3-a052-88792052890d.png

                    Text to process:
                    

              """


    messages = [{
        'role': 'user',
        'content': f"""
                    "{prompt2}"
                    "{content}"
                   """
    }]

    response_content = ''
    responses = dashscope.Generation.call("qwen-plus",
                                          messages=messages,
                                          result_format='message',
                                          stream=True,
                                          incremental_output=True)

    for response in responses:
        if response.status_code == HTTPStatus.OK:
            response_content += response.output.choices[0]['message']['content']
        else:
            print('Request id: %s, Status code: %s, error code: %s, error message: %s' % (
                response.request_id, response.status_code,
                response.code, response.message
            ))

    return response_content

import os
import re
from pathlib import Path
import os


def merge_style_with_md_files(md_file_path, style_file_path):
    # Check if style file exists
    if not os.path.isfile(style_file_path):
        raise FileNotFoundError(f"Style file {style_file_path} does not exist.")
    
    # Read style file content
    with open(style_file_path, 'r', encoding='utf-8') as f:
        style_content = f.read()
    
    # Loop through all files in the specified directory
    for filename in os.listdir(md_file_path):
        if filename.startswith('section') and filename.endswith('.md'):
            file_path = os.path.join(md_file_path, filename)
            # Merge style content with .md file content
            if os.path.exists(file_path):
                with open(file_path, 'r+', encoding='utf-8') as f:
                    original_content = f.read()
                    # Move pointer to start to overwrite
                    f.seek(0)
                    f.write(style_content + '\n\n' + original_content)
                    # Clear buffer to ensure all data is written
                    f.truncate()


def remove_trailing_dashes(directory):
    """
    Remove trailing consecutive dashes (---) from Markdown files if they appear at the end with no content after (except optional line breaks).
    """
    for filename in os.listdir(directory):
        # Check if file starts with 'section' and ends with '.md'
        if filename.startswith('section') and filename.endswith('.md'):
            filepath = os.path.join(directory, filename)

            # Read file content
            with open(filepath, 'r', encoding='utf-8') as file:
                content = file.read()

            # Check if file ends with '---' followed only by optional line breaks
            if content.rstrip().endswith('---') and content.rstrip('---').endswith('\n'):
                # Remove trailing '---' and line breaks
                content = content.rstrip('---\n')

            # Replace all "------" with empty string
            content = content.replace("------", "")
            content = re.sub(r'\n{3,}', '\n\n', content)

            # Write updated content
            with open(filepath, 'w', encoding='utf-8') as file:
                file.write(content)


def remove_empty_lines(filename):
    # Read file content
    with open(filename, 'r', encoding='utf-8') as file:
        content = file.read()
    # Replace all "------" with empty string
    content = content.replace("------", "")
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(content)


def append_string_to_file(file_path):
    # Read file content
    with open(file_path, 'r', encoding='utf-8') as file:
        content = file.read()

    # Append string '---' to end of file
    new_content = content + '---'

    # Write new content
    with open(file_path, 'w', encoding='utf-8') as file:
        file.write(new_content)


def insert_logo(file_path, logo_path):
    # Read file content
    with open(file_path, 'r', encoding='utf-8') as file:
        content = file.read()

    # Get logo filename
    logo_filename = Path(logo_path).name

    # Define string to insert
    insert_str = f"""<!--\nbackgroundImage: url("./{logo_filename}");\nbackgroundSize: 10% ;\nbackgroundPosition: 98% 3% ;\n-->
                    """

    # Use regex to replace
    # Replace only standalone "---", not those surrounded by other dashes
    new_content = re.sub(r'(?<!-)---(?!-)', f'\n{insert_str}\n---', content, flags=re.DOTALL)

    # Write new content
    with open(file_path, 'w', encoding='utf-8') as file:
        file.write(new_content)


def insert_bg_if_no_link(filename, theme_url):
    # Store final result
    result = []

    # Read file content
    with open(filename, 'r', encoding='utf-8') as file:
        content = file.read()

    # Get theme filename
    theme_filename = Path(theme_url).name

    # Split text using regex
    sections = re.split(r'---+', content)

    # Loop through each section
    for i, section in enumerate(sections):
        # Look for "# {string}" pattern
        header_match = re.search(r'# \{(.+?)\}', section)
        if header_match:
            # Extract content after "# {string}"
            header_content = section[header_match.end():].strip()

            # Check if content contains ![parameter](url) links
            if not re.search(r'!\[[^\]]*\]\([^\)]*\)', header_content):
                # If no links and no background image, add specified text after "# {string}"
                section = f'{section[:header_match.end()]}![bg 110% opacity:.80](./{theme_filename})\n{section[header_match.end():]}\n---'

        # Add processed section to result
        result.append(section)

        # Keep original separator if not last section
        if i < len(sections) - 1:
            result.append('---')

    # Write result back to file
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(''.join(result))


def title_to_md(file_path, content, title_url):
    # Read original file content
    title_filename = Path(title_url).name
    with open(file_path, 'r', encoding='utf-8') as file:
        original_content = file.read()
    content = f"![bg right:60% ](./{title_filename})\n# {content}\n---"
    # Prepend new content
    new_content = content + '\n' + original_content

    # Write new content
    with open(file_path, 'w', encoding='utf-8') as file:
        file.write(new_content)

import json
import os
import re
from qwen_plus_marp import call_with_stream
from pathlib import Path

def is_link(text):
    """Check if given text is a link."""
    return text.startswith("http://") or text.startswith("https://")

def parse_json_list_to_markdown(json_list, theme_url):
    """
    Convert list of JSON objects to Markdown format, processing 'content' with call_with_stream.
    
    Parameters:
    - json_list (list): List of dicts, each with 'title' and 'content' keys.
    
    Returns:
    - str: Markdown-formatted string.
    """
    theme = "![bg 110% opacity:.80](./{theme_filename})\n\n"
    theme_filename = Path(theme_url).name
    markdown_content = ""
    for item in json_list:
        title = item.get('title', 'Unnamed')
        processed_content = call_with_stream(item.get('content', ''))
        
        if is_link(processed_content):
            markdown_content += f"---\n\n![bg right 70%]({processed_content})\n\n---"
        else:
            markdown_content += f"\n\n# {title}\n\n{processed_content}\n\n---"
    return markdown_content


def parse_json_list_to_markdown_new(json_list, theme_url):
    """
    Convert list of JSON objects to Markdown format, processing 'content' with call_with_stream.
    
    Parameters:
    - json_list (list): List of dicts, each with 'title' and 'content' keys.
    
    Returns:
    - str: Markdown-formatted string.
    """
    theme_filename = Path(theme_url).name
    theme = f"![bg 110% opacity:.80](./{theme_filename})\n\n"

    markdown_content = ""

    for i, item in enumerate(json_list):
        title = item.get('title', 'Unnamed')
        processed_content = call_with_stream(item.get('content', ''))
        if processed_content.startswith("```") and processed_content.endswith("```"):
            processed_content = processed_content[11:-3].strip()

        if not is_link(json_list[i].get('content')):
            # If this is the last item
            if i == len(json_list) - 1:
                markdown_content += f"\n\n## {title}\n\n{processed_content}\n\n{theme}\n\n---"
            else:
                if not is_link(json_list[i + 1].get('content')):
                    # Current and next are not links
                    markdown_content += f"\n\n## {title}\n\n{processed_content}\n\n{theme}\n\n---"
                else:
                    # Current is not a link but next is
                    markdown_content += f"\n\n## {title}\n\n{processed_content}\n\n---"
        else:
            # Current is a link
            markdown_content += f"---\n\n![bg right 70%]({json_list[i].get('content')})\n\n---"

    return markdown_content


def convert_json_file_to_md(json_file_path, output_dir, theme_url):
    """
    Read JSON file, process content with call_with_stream, and save as Markdown file.
    
    Parameters:
    - json_file_path (str): Path to JSON file.
    - output_dir (str): Directory to save Markdown file.
    """
    
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    with open(json_file_path, 'r', encoding='utf-8') as file:
        json_data = json.load(file)
    
    markdown_content = parse_json_list_to_markdown_new(json_data, theme_url)
    
    base_name = os.path.splitext(os.path.basename(json_file_path))[0]
    md_file_name = f"{base_name}.md"
    output_path = os.path.join(output_dir, md_file_name)
    
    with open(output_path, 'w', encoding='utf-8') as file:
        file.write(markdown_content)

def save_markdown_to_file(content, filename):
    """ Save Markdown content to file """
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(content)

def process_markdown(input_file):
    """ Process Markdown text, split as needed, and save """
    with open(input_file, 'r', encoding='utf-8') as file:
        input_text = file.read()

    # Use regex to ensure each part ends with "---"
    parts = re.split(r'(?<=---\n)', input_text)

    # Remove empty strings
    parts = [part.strip() for part in parts if part.strip()]

    filenames = []
    base_path = os.path.dirname(input_file)  # Get base path
    
    for i, part in enumerate(parts):
        # Generate filename
        filename = f'{os.path.splitext(os.path.basename(input_file))[0]}_{i}.md'
        # Build full path
        full_filename = os.path.join(base_path, filename)
        save_markdown_to_file(f'{part}', full_filename)
        filenames.append(full_filename)

# Import
from json2md import convert_json_file_to_md
# Call
# Summarize section content, save as Markdown, and set background image. Replace theme.png in the style folder with your custom background.
for filename in os.listdir(args.json_path):
    if filename.endswith('.json'):
        json_file_path = os.path.join(args.json_path, filename)
        convert_json_file_to_md(json_file_path, args.markdown_path, args.theme_path)

# Import
from markdown_gather import insert_logo, remove_empty_lines, title_to_md

# Call
# Add document title as title page at start of Markdown file and set title page background. Replace title.png in the style folder with your custom title background.
title_to_md(os.path.join(args.markdown_path,f'{input_base_name}.md'), theme, args.title_path)

# Remove blank lines to meet Marp formatting requirements
remove_empty_lines(os.path.join(args.markdown_path,f'{input_base_name}.md'))

# Add Alibaba Cloud logo. Replace with your own logo: name it logo.png and place it in the style folder.
insert_logo(os.path.join(args.markdown_path,f'{input_base_name}.md'), os.path.join(args.logo_path))

# Import
from markdown_gather import merge_style_with_md_files, remove_trailing_dashes
# Call
process_markdown(os.path.join(args.markdown_path,f'{input_base_name}.md'))

# Add Marp style file. Customize styles using Marp docs: name your style file style.md and place it in the style folder.
merge_style_with_md_files(args.markdown_path, args.markdown_style_path)

# Remove trailing "---" from Markdown files to avoid blank slides
remove_trailing_dashes(args.markdown_path)  

import os
import re
from pathlib import Path
import os


def merge_style_with_md_files(md_file_path, style_file_path):
    # Check if style file exists
    if not os.path.isfile(style_file_path):
        raise FileNotFoundError(f"Style file {style_file_path} does not exist.")
    
    # Read style file content
    with open(style_file_path, 'r', encoding='utf-8') as f:
        style_content = f.read()
    
    # Loop through all files in the specified directory
    for filename in os.listdir(md_file_path):
        if filename.startswith('section') and filename.endswith('.md'):
            file_path = os.path.join(md_file_path, filename)
            # Merge style content with .md file content
            if os.path.exists(file_path):
                with open(file_path, 'r+', encoding='utf-8') as f:
                    original_content = f.read()
                    # Move pointer to start to overwrite
                    f.seek(0)
                    f.write(style_content + '\n\n' + original_content)
                    # Clear buffer to ensure all data is written
                    f.truncate()


def remove_trailing_dashes(directory):
    """
    Remove trailing consecutive dashes (---) from Markdown files if they appear at the end with no content after (except optional line breaks).
    """
    for filename in os.listdir(directory):
        # Check if file starts with 'section' and ends with '.md'
        if filename.startswith('section') and filename.endswith('.md'):
            filepath = os.path.join(directory, filename)

            # Read file content
            with open(filepath, 'r', encoding='utf-8') as file:
                content = file.read()

            # Check if file ends with '---' followed only by optional line breaks
            if content.rstrip().endswith('---') and content.rstrip('---').endswith('\n'):
                # Remove trailing '---' and line breaks
                content = content.rstrip('---\n')

            # Replace all "------" with empty string
            content = content.replace("------", "")
            content = re.sub(r'\n{3,}', '\n\n', content)

            # Write updated content
            with open(filepath, 'w', encoding='utf-8') as file:
                file.write(content)


def remove_empty_lines(filename):
    # Read file content
    with open(filename, 'r', encoding='utf-8') as file:
        content = file.read()
    # Replace all "------" with empty string
    content = content.replace("------", "")
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(content)


def append_string_to_file(file_path):
    # Read file content
    with open(file_path, 'r', encoding='utf-8') as file:
        content = file.read()

    # Append string '---' to end of file
    new_content = content + '---'

    # Write new content
    with open(file_path, 'w', encoding='utf-8') as file:
        file.write(new_content)


def insert_logo(file_path, logo_path):
    # Read file content
    with open(file_path, 'r', encoding='utf-8') as file:
        content = file.read()

    # Get logo filename
    logo_filename = Path(logo_path).name

    # Define string to insert
    insert_str = f"""<!--\nbackgroundImage: url("./{logo_filename}");\nbackgroundSize: 10% ;\nbackgroundPosition: 98% 3% ;\n-->
                    """

    # Use regex to replace
    # Replace only standalone "---", not those surrounded by other dashes
    new_content = re.sub(r'(?<!-)---(?!-)', f'\n{insert_str}\n---', content, flags=re.DOTALL)

    # Write new content
    with open(file_path, 'w', encoding='utf-8') as file:
        file.write(new_content)


def insert_bg_if_no_link(filename, theme_url):
    # Store final result
    result = []

    # Read file content
    with open(filename, 'r', encoding='utf-8') as file:
        content = file.read()

    # Get theme filename
    theme_filename = Path(theme_url).name

    # Split text using regex
    sections = re.split(r'---+', content)

    # Loop through each section
    for i, section in enumerate(sections):
        # Look for "# {string}" pattern
        header_match = re.search(r'# \{(.+?)\}', section)
        if header_match:
            # Extract content after "# {string}"
            header_content = section[header_match.end():].strip()

            # Check if content contains ![parameter](url) links
            if not re.search(r'!\[[^\]]*\]\([^\)]*\)', header_content):
                # If no links and no background image, add specified text after "# {string}"
                section = f'{section[:header_match.end()]}![bg 110% opacity:.80](./{theme_filename})\n{section[header_match.end():]}\n---'

        # Add processed section to result
        result.append(section)

        # Keep original separator if not last section
        if i < len(sections) - 1:
            result.append('---')

    # Write result back to file
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(''.join(result))


def title_to_md(file_path, content, title_url):
    # Read original file content
    title_filename = Path(title_url).name
    with open(file_path, 'r', encoding='utf-8') as file:
        original_content = file.read()
    content = f"![bg right:60% ](./{title_filename})\n# {content}\n---"
    # Prepend new content
    new_content = content + '\n' + original_content

    # Write new content
    with open(file_path, 'w', encoding='utf-8') as file:
        file.write(new_content)

# Import
from marp2image import convert_md_files_to_png
# Call
# Generate presentation slide images using Marp
convert_md_files_to_png(os.path.join(args.markdown_path,f'{input_base_name}.md'), args.image_path)

import os
from pydub import AudioSegment

def calculate_audio_durations(directory):
    """
    Calculate total duration (in seconds) of all MP3 files in folders named audio_for_paragraph_{index}.
    
    Parameters:
        directory (str): Root directory to scan.

    Returns:
        list: List of total durations (in seconds) for each audio_for_paragraph_{index} folder.
    """
    # Initialize result list
    durations = []
    
    # Scan subdirectories
    for entry in os.scandir(directory):
        if entry.is_dir() and entry.name.startswith("audio_for_paragraph_"):
            # Extract index
            index = int(entry.name.split("_")[-1])
            
            # Initialize total duration for this folder
            total_duration_ms = 0
            
            # Scan files in folder
            for file_entry in os.scandir(entry.path):
                if file_entry.name.endswith(".mp3"):
                    # Load MP3 and calculate duration
                    audio = AudioSegment.from_mp3(file_entry.path)
                    delay = 300
                    total_duration_ms += len(audio) + delay
            
            # Convert to seconds and add to results
            total_duration_seconds = total_duration_ms / 1000.0
            durations.append((index, total_duration_seconds))
    
    # Sort by index
    durations.sort(key=lambda x: x[0])


    
    # Keep only durations (seconds)
    durations = [duration for _, duration in durations]

    durations.insert(0, 2)
    
    return durations

# Import
from calculate_durations_for_each_image import calculate_audio_durations
# Call
# Calculate total audio duration for each paragraph
durations = calculate_audio_durations(os.path.join(args.audio_path, input_base_name))

from moviepy import *
import os
import re
from PIL import Image
import natsort
import math
import numpy as np

def images_to_video_with_durations(input_image_path, output_video_path, durations, fps, base_name):
    # Get all matching image files and sort by number in filename
    pattern = r'^' + re.escape(base_name) + r'_(\d+)\.png$'
    image_files = [
        f"{input_image_path}/{file}"
        for file in os.listdir(input_image_path)
        if re.match(pattern, file)
    ]
    image_files = natsort.natsorted(image_files, key=lambda x: int(re.match(pattern, os.path.basename(x)).group(1)))

    # Set background size
    target_width, target_height = 1280, 720
    background_size = (target_width, target_height)

    # Create clip for each image
    clips = []
    for i, file in enumerate(image_files):
        img = Image.open(file)
        width, height = img.size
        ratio = width / height
        if width > target_width or height > target_height:
            if ratio > target_width / target_height:
                new_width = target_width
                new_height = math.floor(new_width / ratio)
            else:
                new_height = target_height
                new_width = math.floor(new_height * ratio)
        else:
            new_width, new_height = width, height

        img = img.resize((new_width, new_height), resample=Image.Resampling.LANCZOS)
        img_clip = ImageClip(np.array(img)).with_duration(durations[i]).with_position(("center", "center"))

        bg_clip = ColorClip(size=background_size, color=(255,255,255), duration=durations[i])
        composite_clip = CompositeVideoClip([bg_clip, img_clip])
        # Add transition effect (except for last clip)
        # if i < len(image_files) - 1:  # Ensure not last clip
        #     composite_clip = composite_clip.fx(vfx.fadein, duration=0.3).fx(vfx.fadeout, duration=0.3)

    
        clips.append(composite_clip)

    # Concatenate all clips
    final_clip = concatenate_videoclips(clips, method="compose")


    # Write video file
    output_filename = f"{base_name}.mp4"

    final_clip.write_videofile(os.path.join(output_video_path, output_filename), fps=fps)

# Import
from movie_editor import images_to_video_with_durations
# Call
images_to_video_with_durations(os.path.join(args.image_path,f'{input_base_name}'), args.srt_and_video_path, durations, args.fps, input_base_name)

import os
from moviepy import *
from glob import glob
import re
def merge_audio_and_add_to_video(video_path, audio_base_dir, output_path):
    """
    Merge multiple audio files and add to video.

    :param video_path: Path to video file.
    :param audio_base_dir: Base directory containing audio folders.
    :param output_path: Path to output video.
    """
    # Load video file
    video_clip = VideoFileClip(video_path)
    
    # Initialize audio list
    audio_clips = []

    silent_audio_start = AudioClip(lambda t: [0,0], duration=2)
    audio_clips.append(silent_audio_start)
    
    # Get all audio folders and sort by number
    audio_dirs = glob(os.path.join(audio_base_dir, "audio_for_paragraph_*"))
    audio_dirs.sort(key=lambda x: int(re.search(r'\d+', os.path.basename(x)).group()))

    # Loop through audio folders
    for audio_dir in audio_dirs:
        # Get index for current directory
        index = int(os.path.basename(audio_dir).split("_")[-1])
        
        # Get all MP3 files in directory
        mp3_files = glob(os.path.join(audio_dir, f"paragraph_{index}_sentence_*.mp3"))
        mp3_files.sort(key=lambda x: int(re.search(r'_sentence_(\d+)', os.path.basename(x)).group(1)))

        # Loop through sorted MP3 files
        for mp3_file in mp3_files:
            # Load audio file
            audio_clip = AudioFileClip(mp3_file)
            
            # Add to audio list
            if audio_clips:
                # Add 0.3-second silence before each audio after the first
                silent_audio = AudioClip(lambda t: [0,0], duration=0.3)
                audio_clips.append(silent_audio)
            audio_clips.append(audio_clip)
    
    # Concatenate all audio clips
    final_audio = concatenate_audioclips(audio_clips)
    
    # Add audio to video
    video_with_audio = video_clip.with_audio(final_audio)
    
    # Write video with new audio
    video_with_audio.write_videofile(output_path, codec='libx264', audio_codec='aac')
    
    # Close clips to release resources
    video_clip.close()

# Import
from audio2video import merge_audio_and_add_to_video
# Call
merge_audio_and_add_to_video(os.path.join(args.srt_and_video_path,f'{input_base_name}.mp4'), os.path.join(args.audio_path,f'{input_base_name}'), os.path.join(args.srt_and_video_path,f'{input_base_name}_with_audio.mp4'))

import subprocess
import os
def merge_video_and_subtitle(video_and_srt_path, base_name):
    video_ext = ".mp4"
    srt_ext = ".srt"

    video_path = os.path.join(video_and_srt_path, f"{base_name}_with_audio" + video_ext).replace("\\", "/")
    srt_path = os.path.join(video_and_srt_path, base_name + srt_ext).replace("\\", "/")
    output_path = os.path.join(video_and_srt_path, f"{base_name}_with_audio_with_subs" + video_ext).replace("\\", "/")

    command = [
        'ffmpeg',
        '-i', video_path,
        '-vf', f'subtitles={srt_path}',
        '-c:a', 'copy',
        output_path
    ]

    try:
        subprocess.run(command, check=True)
    except subprocess.CalledProcessError as e:
        print(f"An error occurred while merging video and subtitles: {e}")

# Import
from srt2video import merge_video_and_subtitle
# Call
merge_video_and_subtitle(args.srt_and_video_path, input_base_name)

import os
import re
from moviepy import VideoFileClip, concatenate_videoclips

def merge_videos(input_directory):
    # Define video file pattern
    video_pattern = r"section_(\d+)_with_audio_with_subs\.mp4"
    
    # Find and sort matching files
    files = sorted(
        (fn for fn in os.listdir(input_directory) if re.match(video_pattern, fn)),
        key=lambda x: int(re.match(video_pattern, x).group(1))
    )
    
    # Load all video clips
    clips = [VideoFileClip(os.path.join(input_directory, file)) for file in files]
    
    # Concatenate all clips
    final_clip = concatenate_videoclips(clips)
    
    # Output merged video
    output_path = os.path.join(input_directory, 'output_merge_all_video.mp4')
    final_clip.write_videofile(output_path, audio_codec='aac')

merge_videos("./material/video")

#!/bin/bash

# Log file path
log_file="./result.log"

# Clear log file
> "$log_file"

# Record script start time
start_time=$(date +%s)

# Define Python script paths
python_main_script_path="main.py"
python_merge_script_path="merge_all_videos.py"

# Define video output path
video_path=“./material/video/”
# Get all matching filenames and sort numerically
files=$(find ./input -maxdepth 1 -type f -name "section_*.md" | sort -V)

# Loop through files
index=0
for file in $files; do
    index_part=$(basename "$file" .md | cut -d '_' -f 2)
    echo "Processing part ${index_part}" >> "$log_file"
    python "$python_main_script_path" --input_txt_path "$file" >> "$log_file" 2>&1
    if [ $? -ne 0 ]; then
        echo "Error processing $file" >> "$log_file"
        exit 1
    fi
    ((index++))
done

# Merge videos
python "$python_merge_script_path" --input_directory $video_path >> "$log_file" 2>&1

# Record script end time
end_time=$(date +%s)

# Calculate runtime
runtime=$((end_time - start_time))

# Format runtime as hh:mm:ss
hours=$((runtime / 3600))
minutes=$(((runtime % 3600) / 60))
seconds=$((runtime % 60))

# Output completion message
echo "Video generation completed" >> "$log_file"
echo "Total time: $hours hours $minutes minutes $seconds seconds" >> "$log_file"

# Output log
cat "$log_file"