Как отправить субтитры к видео vkvideo в python?

[shpshp]

Использую следующий python-скрипт для загрузки видео mp4 в канал на vkvideo. Как к этому видео добавить субтитры? Встроенные в видео субтитры не видятся.

import vk_api
import requests
import json
import os
import glob
import time
import shutil
import argparse
from tqdm import tqdm
import config


class VKVideoUploader:
    def __init__(self, access_token):
        self.vk_session = vk_api.VkApi(token=access_token)
        self.vk = self.vk_session.get_api()

    def upload_to_group(self, video_path, group_id, title="Group Video", description=""):
        try:
            upload_server = self.vk.video.save(
                group_id=abs(group_id),
                name=title,
                description=description
            )
            
            upload_url = upload_server['upload_url']
            
            file_size = os.path.getsize(video_path)
            
            with open(video_path, 'rb') as video_data:
                print(f" Uploading to group: {title} ({file_size / (1024*1024):.2f} MB)")
                
                class ProgressBar:
                    def __init__(self, total_size):
                        self.total_size = total_size
                        self.progress_bar = tqdm(
                            total=total_size,
                            unit='B',
                            unit_scale=True,
                            unit_divisor=1024,
                            desc="Uploading",
                            bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]'
                        )
                        self.uploaded = 0
                    
                    def __call__(self, chunk):
                        self.uploaded += len(chunk)
                        self.progress_bar.update(len(chunk))
                    
                    def close(self):
                        self.progress_bar.close()
                
                class ReadableWithProgress:
                    def __init__(self, file_obj, callback):
                        self.file_obj = file_obj
                        self.callback = callback
                        self.total_read = 0
                        
                    def read(self, size=-1):
                        chunk = self.file_obj.read(size)
                        if chunk and self.callback:
                            self.callback(chunk)
                        return chunk
                
                progress_tracker = ProgressBar(file_size)
                
                files = {
                    'video_file': (
                        os.path.basename(video_path),
                        ReadableWithProgress(video_data, progress_tracker),
                        'video/mp4'
                    )
                }
                
                try:
                    response = requests.post(upload_url, files=files)
                finally:
                    progress_tracker.close()
                
                if response.status_code == 200:
                    result = response.json()
                    print(f"✅ Video '{title}' uploaded to group successfully!")
                    return result
                else:
                    print(f"❌ Upload failed for '{title}': {response.text}")
                    return None
                    
        except Exception as e:
            print(f"❌ Error uploading '{title}': {str(e)}")
            return None


def upload_all_videos_to_group(input_folder, output_folder, group_id, uploader):
    video_files = glob.glob(os.path.join(input_folder, "*.mp4"))
    
    if not video_files:
        print("⚠️ No .mp4 files found in the input folder.")
        return

    os.makedirs(output_folder, exist_ok=True)

    print(f" Found {len(video_files)} video(s) to upload.")
    
    for i, video_path in enumerate(video_files, 1):
        file_size = os.path.getsize(video_path)
        print(f"{i}. {os.path.basename(video_path)} ({file_size / (1024*1024):.2f} MB)")
    
    print(f"\n{'='*60}")
    print(f" Overall Progress: 0/{len(video_files)} videos")
    print('='*60)
    
    successful_uploads = 0
    failed_uploads = 0
    
    for idx, video_path in enumerate(video_files, 1):
        filename = os.path.basename(video_path)
        title = os.path.splitext(filename)[0]
        
        print(f"\n Processing video {idx}/{len(video_files)}: {filename}")
        print(f"{'='*40}")
        
        result = uploader.upload_to_group(
            video_path=video_path,
            group_id=group_id,
            title=title,
            description=f"Uploaded {time.strftime('%Y-%m-%d %H:%M:%S')}"
        )
        
        if result:
            successful_uploads += 1
            try:
                dest_path = os.path.join(output_folder, filename)
                shutil.move(video_path, dest_path)
                print(f" Moved to: {dest_path}")
            except Exception as move_error:
                print(f"⚠️ Failed to move file: {move_error}")
        else:
            failed_uploads += 1
        
        print(f"{'='*60}")
        print(f" Overall Progress: {idx}/{len(video_files)} videos")
        print(f"✅ Successful: {successful_uploads} | ❌ Failed: {failed_uploads}")
        print(f"{'='*60}")
        
        if idx < len(video_files):
            print("⏳ Waiting 2 seconds before next upload...")
            time.sleep(2)
    
    print(f"\n{'='*60}")
    print(" UPLOAD SUMMARY")
    print(f"{'='*60}")
    print(f" Total videos found: {len(video_files)}")
    print(f"✅ Successfully uploaded: {successful_uploads}")
    print(f"❌ Failed: {failed_uploads}")
    print(f"{'='*60}")


def main():
    parser = argparse.ArgumentParser(description="Upload MP4 videos to a VK group.")
    parser.add_argument(
        "--input",
        type=str,
        default="input",
        help="Input folder containing .mp4 files (default: 'input')"
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output",
        help="Output folder to move uploaded videos (default: 'output')"
    )
    parser.add_argument(
        "--group-id",
        type=int,
        default=config.DEFAULT_GROUP_ID,
        help=f"VK group ID (default: {config.DEFAULT_GROUP_ID})"
    )
    args = parser.parse_args()

    if not os.path.isdir(args.input):
        print(f"❌ Input folder '{args.input}' does not exist.")
        return

    uploader = VKVideoUploader(config.ACCESS_TOKEN)
    upload_all_videos_to_group(args.input, args.output, args.group_id, uploader)


if __name__ == "__main__":
    main()

Окружение

vk_api: 11.10.0