Convert documents to videos using large language models

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

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 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 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
import time
import dashscope
from dashscope.audio.tts_v2 import SpeechSynthesizer

import traceback

def read_json_file(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        data = json.load(file)
    return data

def split_into_sentences(text):
    # List of Chinese punctuation marks
    punctuation = ['，', '。', '；', '？', '！']
    brackets = {'(': ')', '[': ']', '{': '}', '（': '）', '【': '】', '《': '》'}

    # Initialize result list and temporary sentence storage
    sentences = []
    temp_sentence = ''
    bracket_stack = []

    # Iterate over each character in text
    for char in text:
        # If left bracket, push to stack
        if char in brackets:
            bracket_stack.append(char)
        # If right bracket and matches top of stack, pop stack
        elif char in brackets.values() and bracket_stack and brackets[bracket_stack[-1]] == char:
            bracket_stack.pop()

        # If character is Chinese punctuation and bracket stack is empty, sentence ends
        if char in punctuation and not bracket_stack:
            # Add temp sentence to result and clear it
            sentences.append(temp_sentence.strip())
            temp_sentence = ''
        else:
            # Otherwise, add character to temp sentence
            temp_sentence += char

    # Handle last sentence without ending punctuation
    if temp_sentence:
        sentences.append(temp_sentence.strip())

    return sentences

def save_sentences_to_markdown(sentences, base_dir, index1):
    for index2, sentence in enumerate(sentences, start=1):
        # Create directory
        dir_name = f'audio_for_paragraph_{index1}'
        dir_path = os.path.join(base_dir, dir_name)
        os.makedirs(dir_path, exist_ok=True)

        # Build filename
        file_name = f'paragraph_{index1}_sentence_{index2}.md'
        file_path = os.path.join(dir_path, file_name)

        # Write Markdown file
        with open(file_path, 'w', encoding='utf-8') as file:
            file.write(sentence + '\n')

def process_json_file(json_file_path, base_dir):

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

    file_prefix = os.path.splitext(os.path.basename(json_file_path))[0]

    base_dir = os.path.join(base_dir, file_prefix)

    # Read JSON file
    json_data = read_json_file(json_file_path)

    # Process each entry in JSON data
    for index1, item in enumerate(json_data):
        if 'content' in item:
            content = item['content']
            # Check if content is a link
            if not is_url(content):
                sentences = split_into_sentences(content)
                save_sentences_to_markdown(sentences, base_dir, index1+1)

def is_url(s):
    url_pattern = re.compile(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')
    return bool(url_pattern.match(s))

def synthesize_md_to_speech(base_directory):
    """
    Find all .md files in the specified directory, read their content, and use DashScope API to convert to speech.
    Save as same-name .mp3 files in the same directory.

    Parameters:
    base_directory (str): Top-level directory containing .md files.
    """
    # Ensure DashScope API key is set in environment variables
    if 'DASHSCOPE_API_KEY' not in os.environ:
        raise ValueError("DashScope API key must be set in the environment variables.")

    # Walk through directory and subdirectories
    for root, dirs, files in os.walk(base_directory):
        for file in files:
            if file.endswith('.md'):
                # Build full file path
                md_file_path = os.path.join(root, file)

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

                # Initialize speech synthesizer
                speech_synthesizer = SpeechSynthesizer(model='cosyvoice-v2', voice='longxiaochun_v2')

                # Synthesize speech
                audio_data = speech_synthesizer.call(text)

                # Build output .mp3 file path
                mp3_file_path = os.path.splitext(md_file_path)[0] + '.mp3'

                # Save audio to file
                with open(mp3_file_path, 'wb') as f:
                    f.write(audio_data)

                print(f'Synthesized text from file "{md_file_path}" to file: {mp3_file_path}')

import os
import re
from moviepy import AudioFileClip
from typing import List

def format_time(seconds):
    hours, remainder = divmod(seconds, 3600)
    minutes, seconds = divmod(remainder, 60)
    milliseconds = int((seconds - int(seconds)) * 1000)
    seconds = int(seconds)
    return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d},{milliseconds:03d}"

# Function to get audio file duration
def get_audio_duration(file_path):
    audio = AudioFileClip(file_path)
    duration = audio.duration
    audio.close()
    return duration

# Function to generate SRT subtitle line
def create_srt_line(index, start_time, end_time, text):
    return f"{index}\n{start_time} --> {end_time}\n{text}\n\n"

def generate_srt_from_audio(base_dir: str, output_dir: str, output_srt_file: str) -> None:
    """
    Generate SRT subtitle file from audio folders in the specified directory.

    :param base_dir: Root directory containing audio folders.
    :param output_dir: Directory to save SRT file.
    :param output_srt_file: Full path to output SRT file.
    """

    # Create output directory if it doesn't exist
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    # Ensure output file name ends with .srt
    if not output_srt_file.endswith('.srt'):
        output_srt_file += '.srt'

    # Initialize current time
    current_time = 2.000  # Initial time

    # Open SRT file for writing
    with open(output_srt_file, 'w', encoding='utf-8') as srt_file:
        srt_index = 1

        # Get all matching subdirectories and sort by index
        sub_dirs = [d for d in os.listdir(base_dir) if d.startswith('audio_for_paragraph_')]
        sub_dirs.sort(key=lambda x: int(re.search(r'\d+', x).group()))

        # Loop through subdirectories
        for sub_dir in sub_dirs:
            sub_dir_path = os.path.join(base_dir, sub_dir)

            # Find all .md and .mp3 files
            files = [f for f in os.listdir(sub_dir_path) if f.endswith('.md') or f.endswith('.mp3')]
            md_files = [f for f in files if f.endswith('.md')]

            # Sort .md files by index1 and index2
            md_files.sort(key=lambda x: (int(x.split('_')[1]), int(x.split('_')[3].split('.')[0])))

            # Process each .md file
            for md_file in md_files:
                md_file_path = os.path.join(sub_dir_path, md_file)
                mp3_file_path = os.path.splitext(md_file_path)[0] + '.mp3'

                # Ensure matching .mp3 file exists
                if os.path.exists(mp3_file_path):
                    # Read .md file content
                    with open(md_file_path, 'r', encoding='utf-8') as f:
                        text = f.read().strip()

                    # Get .mp3 file duration
                    duration = get_audio_duration(mp3_file_path)

                    # Generate SRT subtitle line
                    start_time_str = format_time(current_time)
                    end_time_str = format_time(current_time + duration)
                    srt_line = create_srt_line(srt_index, start_time_str, end_time_str, text)

                    # Write to SRT file
                    srt_file.write(srt_line)

                    # Update current time
                    current_time += duration + 0.3  # Add 0.3 seconds to avoid overlap

                    srt_index += 1
                else:
                    print(f"No corresponding MP3 file found for {md_file}")

    print("SRT file generated successfully.")

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

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 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()

#!/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"