Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+vatex_training_v1.0.json filter=lfs diff=lfs merge=lfs -text

.ipynb_checkpoints/vatex_download-checkpoint.py

@@ -0,0 +1,188 @@
+import json
+import subprocess
+import argparse
+import logging
+import sys
+import os
+import multiprocessing
+import glob  # Import the glob module
+from tqdm import tqdm
+
+# --- Setup Logging ---
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    stream=sys.stdout
+)
+
+def download_worker(task_args):
+    """
+    The worker function for a single download task.
+    This function is executed by each process in the multiprocessing pool.
+
+    Args:
+        task_args (tuple): A tuple containing (item, output_dir).
+                           - item (dict): The video dictionary from the JSON.
+                           - output_dir (str): The directory to save the video.
+
+    Returns:
+        tuple: A tuple containing (bool, str) for success/failure and the video_info_string.
+               e.g., (True, 'video_id_...') or (False, 'video_id_...')
+    """
+    item, output_dir = task_args
+    video_info_string = None  # Initialize in case of early failure
+
+    try:
+        # Get the full video info string (e.g., 'bjtnAh_wz1c_000002_000012')
+        video_info_string = item['videoID']
+
+        # This logic is now robust against underscores in the video ID
+        parts = video_info_string.split('_')
+        if len(parts) < 3:
+            raise ValueError("videoID string does not have enough parts.")
+
+        end_time = parts[-1]        # The last part is the end time
+        start_time = parts[-2]      # The second-to-last part is the start time
+        video_id = "_".join(parts[:-2]) # Join everything else to form the video_id
+
+        start_seconds = int(start_time)
+        end_seconds = int(end_time)
+
+    except (KeyError, ValueError) as e:
+        logging.warning(f"Skipping entry due to malformed data: {item}. Error: {e}")
+        # Return failure with a placeholder if video_info_string could not be parsed
+        return False, (video_info_string or f"malformed_data:_{item}")
+
+    # Define the full output path for the video file
+    output_path_template = os.path.join(output_dir, f"{video_info_string}.%(ext)s")
+    youtube_url = f"https://www.youtube.com/watch?v={video_id}"
+
+    command = [
+        'yt-dlp',
+        '--quiet', '--no-warnings',
+        '-o', output_path_template,  # Use -o as a shorthand for --output
+        '--download-sections', f"*{start_seconds}-{end_seconds}",
+        '--force-keyframes-at-cuts',
+        '--remux-video', 'mp4',
+        youtube_url
+    ]
+
+    try:
+        # Using capture_output=True and text=True to get stdout/stderr if needed
+        subprocess.run(command, check=True, capture_output=True, text=True)
+        return True, video_info_string
+    except FileNotFoundError:
+        logging.error("CRITICAL: 'yt-dlp' command not found. Please ensure it's installed and in your PATH.")
+        # This error is critical and will likely affect all workers, but we return failure for this task.
+        return False, video_info_string
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Failed to download {video_info_string}. Reason: {e.stderr.strip()}")
+        return False, video_info_string
+    except Exception as e:
+        logging.error(f"An unexpected error occurred for {video_info_string}: {e}")
+        return False, video_info_string
+
+def process_downloads(json_file_path, output_dir, num_jobs):
+    """
+    Orchestrates the parallel downloading of video segments, skipping existing files.
+
+    Args:
+        json_file_path (str): The path to the input JSON file.
+        output_dir (str): The directory to save downloaded videos.
+        num_jobs (int): The number of parallel processes to use.
+    """
+    try:
+        with open(json_file_path, 'r', encoding='utf-8') as f:
+            video_data = json.load(f)
+        logging.info(f"Loaded {len(video_data)} video entries from '{json_file_path}'.")
+    except FileNotFoundError:
+        logging.error(f"Error: The file '{json_file_path}' was not found.")
+        sys.exit(1)
+    except json.JSONDecodeError:
+        logging.error(f"Error: Failed to decode JSON from '{json_file_path}'. Check format.")
+        sys.exit(1)
+
+    os.makedirs(output_dir, exist_ok=True)
+    logging.info(f"Output directory set to '{output_dir}'.")
+
+    # --- NEW: Pre-filter tasks to implement resumability ---
+    tasks_to_run = []
+    skipped_count = 0
+    logging.info("Checking for existing files to skip...")
+
+    for item in tqdm(video_data, desc="Scanning for existing files"):
+        try:
+            video_info_string = item['videoID']
+            # Create a pattern to match filename with any extension
+            file_pattern = os.path.join(output_dir, f"{video_info_string}.*")
+            # Use glob.glob to find if any file matches the pattern
+            if glob.glob(file_pattern):
+                skipped_count += 1
+            else:
+                tasks_to_run.append((item, output_dir))
+        except KeyError:
+            # This will be handled properly by the worker, just pass it through
+            tasks_to_run.append((item, output_dir))
+
+    if not tasks_to_run:
+        logging.info("All video files already exist. Nothing to download.")
+        logging.info(f"Total files skipped: {skipped_count}")
+        return
+
+    logging.info(f"Found {skipped_count} existing files. Queuing {len(tasks_to_run)} new downloads.")
+    logging.info(f"Starting downloads with {num_jobs} parallel jobs...")
+
+    success_count = 0
+    failure_count = 0
+
+    with multiprocessing.Pool(processes=num_jobs) as pool:
+        # Use imap_unordered for efficiency, as download order doesn't matter
+        results_iterator = pool.imap_unordered(download_worker, tasks_to_run)
+
+        for _ in tqdm(range(len(tasks_to_run)), desc="Downloading Videos"):
+            success, video_id = next(results_iterator)
+            if success:
+                success_count += 1
+            else:
+                failure_count += 1
+
+    logging.info("--- Download Summary ---")
+    logging.info(f"Successfully downloaded: {success_count}")
+    logging.info(f"Skipped (already exist): {skipped_count}")
+    logging.info(f"Failed to download:    {failure_count}")
+    logging.info("------------------------")
+
+def main():
+    """Main function to parse arguments and start the download process."""
+    parser = argparse.ArgumentParser(
+        description="Download video segments in parallel from a JSON file using yt-dlp. Skips existing files.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument(
+        "json_file",
+        type=str,
+        help="Path to the JSON file containing video information."
+    )
+    parser.add_argument(
+        "-o", "--output-dir",
+        type=str,
+        default="video_downloads",
+        help="Directory to save downloaded videos. (Default: 'video_downloads')"
+    )
+    parser.add_argument(
+        "-j", "--jobs",
+        type=int,
+        default=4,
+        help="Number of parallel download jobs to run. (Default: 4)"
+    )
+
+    args = parser.parse_args()
+
+    if args.jobs <= 0:
+        logging.error("Number of jobs must be a positive integer.")
+        sys.exit(1)
+
+    process_downloads(args.json_file, args.output_dir, args.jobs)
+
+if __name__ == "__main__":
+    main()

.ipynb_checkpoints/vatex_monitor_downloads-checkpoint.py

@@ -0,0 +1,300 @@
+import curses
+import json
+import time
+import sys
+import os
+import glob
+import argparse
+from datetime import datetime
+
+# --- Configuration ---
+BAR_CHAR = "#"  # Simpler character that works in all terminals
+EMPTY_BAR_CHAR = "-"
+REFRESH_INTERVAL_SECONDS = 1
+
+def format_time(seconds):
+    """Format seconds into a human-readable time string."""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    elif seconds < 3600:
+        minutes = seconds / 60
+        return f"{minutes:.1f}m"
+    else:
+        hours = seconds / 3600
+        return f"{hours:.1f}h"
+
+def analyze_progress(json_file_path, output_dir, last_stats=None):
+    """
+    Analyzes the JSON file and output directory to calculate progress.
+    """
+    start_time = time.time()
+    
+    # 1. Get the set of all expected video IDs from the JSON file
+    try:
+        with open(json_file_path, 'r', encoding='utf-8') as f:
+            video_data = json.load(f)
+        expected_video_ids = {item['videoID']: item.get('title', 'Unknown') 
+                             for item in video_data if 'videoID' in item}
+        total_videos = len(expected_video_ids)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return 0, 0, 0, [], 0, 0, {}
+
+    # 2. Get the set of all completed video IDs from the output directory
+    completed_video_ids = set()
+    completed_files_with_info = []
+    file_sizes = {}
+    
+    try:
+        for filepath in glob.glob(os.path.join(output_dir, '*.*')):
+            basename = os.path.basename(filepath)
+            video_id = os.path.splitext(basename)[0]
+            
+            if video_id in expected_video_ids:
+                completed_video_ids.add(video_id)
+                try:
+                    mtime = os.path.getmtime(filepath)
+                    size = os.path.getsize(filepath)
+                    title = expected_video_ids.get(video_id, 'Unknown')
+                    completed_files_with_info.append((basename, mtime, size, title, video_id))
+                    file_sizes[video_id] = size
+                except FileNotFoundError:
+                    continue
+    except FileNotFoundError:
+        pass
+    
+    # 3. Sort recent files by modification time (newest first)
+    completed_files_with_info.sort(key=lambda x: x[1], reverse=True)
+    recent_files = completed_files_with_info[:10]  # Show up to 10 recent files
+
+    # 4. Calculate stats
+    completed_videos = len(completed_video_ids)
+    pending_videos = total_videos - completed_videos
+    
+    # 5. Calculate download rate and ETA
+    download_rate = 0
+    eta = 0
+    
+    if last_stats and 'completed' in last_stats and last_stats['completed'] < completed_videos:
+        time_diff = time.time() - last_stats.get('timestamp', start_time)
+        if time_diff > 0:
+            download_rate = (completed_videos - last_stats['completed']) / time_diff * 60  # per minute
+            if download_rate > 0 and pending_videos > 0:
+                eta = pending_videos / download_rate * 60  # seconds
+    
+    return total_videos, completed_videos, pending_videos, recent_files, download_rate, eta, file_sizes
+
+def draw_progress_bar(stdscr, y, x, width, label, percentage, color_pair):
+    """Draws a label and a progress bar with improved visuals."""
+    if width <= 0 or y >= stdscr.getmaxyx()[0]: 
+        return
+    
+    # Reserve space for label, percentage, and brackets
+    label_width = len(label)
+    percent_str = f" [{percentage:5.1f}%]"
+    bar_area_width = width - label_width - len(percent_str)
+    
+    if bar_area_width <= 0: 
+        return
+
+    filled_len = int(bar_area_width * percentage / 100)
+    bar = BAR_CHAR * filled_len + EMPTY_BAR_CHAR * (bar_area_width - filled_len)
+
+    try:
+        stdscr.addstr(y, x, label, curses.color_pair(3))
+        stdscr.addstr(y, x + label_width, bar, color_pair)
+        stdscr.addstr(y, x + label_width + bar_area_width, percent_str)
+    except curses.error:
+        # Safely handle drawing errors
+        pass
+
+def format_size(size_bytes):
+    """Format bytes into human-readable format."""
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes/1024:.1f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes/(1024*1024):.1f} MB"
+    else:
+        return f"{size_bytes/(1024*1024*1024):.2f} GB"
+
+def safe_addstr(stdscr, y, x, text, attr=0):
+    """Safely add a string to the screen, handling boundary errors."""
+    height, width = stdscr.getmaxyx()
+    if y < 0 or y >= height or x < 0 or x >= width:
+        return
+    
+    # Truncate the string if it would go off-screen
+    max_len = width - x
+    if max_len <= 0:
+        return
+    
+    display_text = text[:max_len]
+    
+    try:
+        stdscr.addstr(y, x, display_text, attr)
+    except curses.error:
+        # Safely handle any curses errors
+        pass
+
+def main(stdscr, json_path, output_dir):
+    # --- Curses Setup ---
+    curses.curs_set(0)  # Hide cursor
+    curses.use_default_colors()
+    curses.init_pair(1, curses.COLOR_GREEN, -1)   # Success / Bar
+    curses.init_pair(2, curses.COLOR_WHITE, -1)   # Normal text
+    curses.init_pair(3, curses.COLOR_CYAN, -1)    # Labels
+    curses.init_pair(4, curses.COLOR_RED, -1)     # Error / Warning
+    curses.init_pair(5, curses.COLOR_YELLOW, -1)  # Info
+    
+    # For tracking download rate
+    last_stats = None
+    start_time = time.time()
+    
+    while True:
+        stdscr.erase()
+        height, width = stdscr.getmaxyx()
+
+        # --- Data Loading ---
+        total, completed, pending, recent_files, download_rate, eta, file_sizes = analyze_progress(
+            json_path, output_dir, last_stats
+        )
+        
+        # Update stats for next iteration
+        last_stats = {
+            'completed': completed,
+            'timestamp': time.time()
+        }
+        
+        # Calculate total downloaded size
+        total_size = sum(file_sizes.values())
+        
+        # --- Drawing UI ---
+        # Header
+        header = f"Download Monitor - {os.path.basename(json_path)}"
+        safe_addstr(stdscr, 0, 2, header, curses.A_BOLD)
+        safe_addstr(stdscr, 1, 2, f"Output: {os.path.basename(output_dir)}", curses.A_DIM)
+        safe_addstr(stdscr, 2, 2, "Press 'q' to quit, 'r' to refresh", curses.A_DIM)
+        
+        try:
+            stdscr.hline(3, 0, "-", width)
+        except curses.error:
+            pass
+            
+        y_pos = 5
+
+        # Stats Section
+        if total == 0:
+            safe_addstr(stdscr, y_pos, 4, "Waiting for data or JSON not found...", curses.color_pair(4) | curses.A_BOLD)
+            y_pos += 2
+        else:
+            # Stats header
+            safe_addstr(stdscr, y_pos, 4, "Download Statistics", curses.color_pair(3) | curses.A_BOLD)
+            y_pos += 2
+            
+            # Left column stats
+            safe_addstr(stdscr, y_pos, 4, f"Total Videos: {total}", curses.color_pair(2))
+            safe_addstr(stdscr, y_pos + 1, 4, f"Completed: {completed}", curses.color_pair(1))
+            safe_addstr(stdscr, y_pos + 2, 4, f"Pending: {pending}", curses.color_pair(5))
+            
+            # Right column stats if there's enough space
+            if width > 50:
+                right_col = width // 2
+                safe_addstr(stdscr, y_pos, right_col, f"Total Size: {format_size(total_size)}", curses.color_pair(2))
+                safe_addstr(stdscr, y_pos + 1, right_col, f"Rate: {download_rate:.1f} videos/min", curses.color_pair(1))
+                
+                if eta > 0:
+                    eta_str = format_time(eta)
+                    safe_addstr(stdscr, y_pos + 2, right_col, f"ETA: {eta_str}", curses.color_pair(5))
+                else:
+                    safe_addstr(stdscr, y_pos + 2, right_col, "ETA: calculating...", curses.color_pair(5))
+            
+            y_pos += 4
+            
+            # Progress Bar
+            percentage = (completed / total) * 100 if total > 0 else 0
+            draw_progress_bar(stdscr, y_pos, 4, width - 8, "Progress: ", percentage, curses.color_pair(1))
+            y_pos += 2
+            
+            # Runtime
+            runtime = time.time() - start_time
+            runtime_str = format_time(runtime)
+            safe_addstr(stdscr, y_pos, 4, f"Runtime: {runtime_str}", curses.color_pair(2))
+            y_pos += 2
+
+        # Separator
+        try:
+            stdscr.hline(y_pos, 0, "-", width)
+        except curses.error:
+            pass
+            
+        y_pos += 1
+
+        # Recent Files Section
+        safe_addstr(stdscr, y_pos, 2, "Recently Completed Files:", curses.color_pair(3) | curses.A_BOLD)
+        y_pos += 2
+        
+        if recent_files:
+            for i, (filename, mtime, size, title, video_id) in enumerate(recent_files):
+                if y_pos >= height - 1: 
+                    break
+                
+                # Format the time
+                time_str = datetime.fromtimestamp(mtime).strftime("%H:%M:%S")
+                size_str = format_size(size)
+                
+                # Display title if available, otherwise filename
+                display_name = title if title != 'Unknown' else filename
+                
+                # Truncate long names
+                max_name_len = width - 25 if width > 25 else 10
+                if len(display_name) > max_name_len:
+                    display_name = display_name[:max_name_len-3] + "..."
+                
+                file_info = f"{display_name} ({size_str}, {time_str})"
+                safe_addstr(stdscr, y_pos, 4, file_info, curses.color_pair(2))
+                y_pos += 1
+        else:
+            safe_addstr(stdscr, y_pos, 4, "(No completed files found yet)", curses.color_pair(4))
+
+        stdscr.refresh()
+        
+        # Non-blocking input with a timeout
+        stdscr.timeout(REFRESH_INTERVAL_SECONDS * 1000)
+        key = stdscr.getch()
+        if key == ord('q'):
+            break
+        elif key == ord('r'):
+            # Force refresh
+            continue
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="A curses-based monitor for the video downloader script.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument(
+        "json_file",
+        type=str,
+        help="Path to the JSON file containing video information (the same one used by the downloader)."
+    )
+    parser.add_argument(
+        "output_dir",
+        type=str,
+        help="Path to the output directory where videos are being saved."
+    )
+    args = parser.parse_args()
+
+    print(f"Starting download monitor...")
+    print(f" - Watching JSON: {args.json_file}")
+    print(f" - Watching Dir:  {args.output_dir}")
+    print("\nPress 'q' in the monitor window to exit.")
+    time.sleep(1)
+
+    try:
+        curses.wrapper(main, args.json_file, args.output_dir)
+    except curses.error as e:
+        print(f"\nCurses error: {e}")
+        print("Your terminal window might be too small to run the monitor.")
+    except KeyboardInterrupt:
+        print("\nMonitor stopped.")

vatex-dataset.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83b91fc11c98614c4f75c24b5899210c4646966bfc9d74da46cc2a6197d10382
+size 44904550397

vatex_download.py

@@ -0,0 +1,188 @@
+import json
+import subprocess
+import argparse
+import logging
+import sys
+import os
+import multiprocessing
+import glob  # Import the glob module
+from tqdm import tqdm
+
+# --- Setup Logging ---
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    stream=sys.stdout
+)
+
+def download_worker(task_args):
+    """
+    The worker function for a single download task.
+    This function is executed by each process in the multiprocessing pool.
+
+    Args:
+        task_args (tuple): A tuple containing (item, output_dir).
+                           - item (dict): The video dictionary from the JSON.
+                           - output_dir (str): The directory to save the video.
+
+    Returns:
+        tuple: A tuple containing (bool, str) for success/failure and the video_info_string.
+               e.g., (True, 'video_id_...') or (False, 'video_id_...')
+    """
+    item, output_dir = task_args
+    video_info_string = None  # Initialize in case of early failure
+
+    try:
+        # Get the full video info string (e.g., 'bjtnAh_wz1c_000002_000012')
+        video_info_string = item['videoID']
+
+        # This logic is now robust against underscores in the video ID
+        parts = video_info_string.split('_')
+        if len(parts) < 3:
+            raise ValueError("videoID string does not have enough parts.")
+
+        end_time = parts[-1]        # The last part is the end time
+        start_time = parts[-2]      # The second-to-last part is the start time
+        video_id = "_".join(parts[:-2]) # Join everything else to form the video_id
+
+        start_seconds = int(start_time)
+        end_seconds = int(end_time)
+
+    except (KeyError, ValueError) as e:
+        logging.warning(f"Skipping entry due to malformed data: {item}. Error: {e}")
+        # Return failure with a placeholder if video_info_string could not be parsed
+        return False, (video_info_string or f"malformed_data:_{item}")
+
+    # Define the full output path for the video file
+    output_path_template = os.path.join(output_dir, f"{video_info_string}.%(ext)s")
+    youtube_url = f"https://www.youtube.com/watch?v={video_id}"
+
+    command = [
+        'yt-dlp',
+        '--quiet', '--no-warnings',
+        '-o', output_path_template,  # Use -o as a shorthand for --output
+        '--download-sections', f"*{start_seconds}-{end_seconds}",
+        '--force-keyframes-at-cuts',
+        '--remux-video', 'mp4',
+        youtube_url
+    ]
+
+    try:
+        # Using capture_output=True and text=True to get stdout/stderr if needed
+        subprocess.run(command, check=True, capture_output=True, text=True)
+        return True, video_info_string
+    except FileNotFoundError:
+        logging.error("CRITICAL: 'yt-dlp' command not found. Please ensure it's installed and in your PATH.")
+        # This error is critical and will likely affect all workers, but we return failure for this task.
+        return False, video_info_string
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Failed to download {video_info_string}. Reason: {e.stderr.strip()}")
+        return False, video_info_string
+    except Exception as e:
+        logging.error(f"An unexpected error occurred for {video_info_string}: {e}")
+        return False, video_info_string
+
+def process_downloads(json_file_path, output_dir, num_jobs):
+    """
+    Orchestrates the parallel downloading of video segments, skipping existing files.
+
+    Args:
+        json_file_path (str): The path to the input JSON file.
+        output_dir (str): The directory to save downloaded videos.
+        num_jobs (int): The number of parallel processes to use.
+    """
+    try:
+        with open(json_file_path, 'r', encoding='utf-8') as f:
+            video_data = json.load(f)
+        logging.info(f"Loaded {len(video_data)} video entries from '{json_file_path}'.")
+    except FileNotFoundError:
+        logging.error(f"Error: The file '{json_file_path}' was not found.")
+        sys.exit(1)
+    except json.JSONDecodeError:
+        logging.error(f"Error: Failed to decode JSON from '{json_file_path}'. Check format.")
+        sys.exit(1)
+
+    os.makedirs(output_dir, exist_ok=True)
+    logging.info(f"Output directory set to '{output_dir}'.")
+
+    # --- NEW: Pre-filter tasks to implement resumability ---
+    tasks_to_run = []
+    skipped_count = 0
+    logging.info("Checking for existing files to skip...")
+
+    for item in tqdm(video_data, desc="Scanning for existing files"):
+        try:
+            video_info_string = item['videoID']
+            # Create a pattern to match filename with any extension
+            file_pattern = os.path.join(output_dir, f"{video_info_string}.*")
+            # Use glob.glob to find if any file matches the pattern
+            if glob.glob(file_pattern):
+                skipped_count += 1
+            else:
+                tasks_to_run.append((item, output_dir))
+        except KeyError:
+            # This will be handled properly by the worker, just pass it through
+            tasks_to_run.append((item, output_dir))
+
+    if not tasks_to_run:
+        logging.info("All video files already exist. Nothing to download.")
+        logging.info(f"Total files skipped: {skipped_count}")
+        return
+
+    logging.info(f"Found {skipped_count} existing files. Queuing {len(tasks_to_run)} new downloads.")
+    logging.info(f"Starting downloads with {num_jobs} parallel jobs...")
+
+    success_count = 0
+    failure_count = 0
+
+    with multiprocessing.Pool(processes=num_jobs) as pool:
+        # Use imap_unordered for efficiency, as download order doesn't matter
+        results_iterator = pool.imap_unordered(download_worker, tasks_to_run)
+
+        for _ in tqdm(range(len(tasks_to_run)), desc="Downloading Videos"):
+            success, video_id = next(results_iterator)
+            if success:
+                success_count += 1
+            else:
+                failure_count += 1
+
+    logging.info("--- Download Summary ---")
+    logging.info(f"Successfully downloaded: {success_count}")
+    logging.info(f"Skipped (already exist): {skipped_count}")
+    logging.info(f"Failed to download:    {failure_count}")
+    logging.info("------------------------")
+
+def main():
+    """Main function to parse arguments and start the download process."""
+    parser = argparse.ArgumentParser(
+        description="Download video segments in parallel from a JSON file using yt-dlp. Skips existing files.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument(
+        "json_file",
+        type=str,
+        help="Path to the JSON file containing video information."
+    )
+    parser.add_argument(
+        "-o", "--output-dir",
+        type=str,
+        default="video_downloads",
+        help="Directory to save downloaded videos. (Default: 'video_downloads')"
+    )
+    parser.add_argument(
+        "-j", "--jobs",
+        type=int,
+        default=4,
+        help="Number of parallel download jobs to run. (Default: 4)"
+    )
+
+    args = parser.parse_args()
+
+    if args.jobs <= 0:
+        logging.error("Number of jobs must be a positive integer.")
+        sys.exit(1)
+
+    process_downloads(args.json_file, args.output_dir, args.jobs)
+
+if __name__ == "__main__":
+    main()

vatex_monitor_downloads.py

@@ -0,0 +1,300 @@
+import curses
+import json
+import time
+import sys
+import os
+import glob
+import argparse
+from datetime import datetime
+
+# --- Configuration ---
+BAR_CHAR = "#"  # Simpler character that works in all terminals
+EMPTY_BAR_CHAR = "-"
+REFRESH_INTERVAL_SECONDS = 1
+
+def format_time(seconds):
+    """Format seconds into a human-readable time string."""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    elif seconds < 3600:
+        minutes = seconds / 60
+        return f"{minutes:.1f}m"
+    else:
+        hours = seconds / 3600
+        return f"{hours:.1f}h"
+
+def analyze_progress(json_file_path, output_dir, last_stats=None):
+    """
+    Analyzes the JSON file and output directory to calculate progress.
+    """
+    start_time = time.time()
+    
+    # 1. Get the set of all expected video IDs from the JSON file
+    try:
+        with open(json_file_path, 'r', encoding='utf-8') as f:
+            video_data = json.load(f)
+        expected_video_ids = {item['videoID']: item.get('title', 'Unknown') 
+                             for item in video_data if 'videoID' in item}
+        total_videos = len(expected_video_ids)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return 0, 0, 0, [], 0, 0, {}
+
+    # 2. Get the set of all completed video IDs from the output directory
+    completed_video_ids = set()
+    completed_files_with_info = []
+    file_sizes = {}
+    
+    try:
+        for filepath in glob.glob(os.path.join(output_dir, '*.*')):
+            basename = os.path.basename(filepath)
+            video_id = os.path.splitext(basename)[0]
+            
+            if video_id in expected_video_ids:
+                completed_video_ids.add(video_id)
+                try:
+                    mtime = os.path.getmtime(filepath)
+                    size = os.path.getsize(filepath)
+                    title = expected_video_ids.get(video_id, 'Unknown')
+                    completed_files_with_info.append((basename, mtime, size, title, video_id))
+                    file_sizes[video_id] = size
+                except FileNotFoundError:
+                    continue
+    except FileNotFoundError:
+        pass
+    
+    # 3. Sort recent files by modification time (newest first)
+    completed_files_with_info.sort(key=lambda x: x[1], reverse=True)
+    recent_files = completed_files_with_info[:10]  # Show up to 10 recent files
+
+    # 4. Calculate stats
+    completed_videos = len(completed_video_ids)
+    pending_videos = total_videos - completed_videos
+    
+    # 5. Calculate download rate and ETA
+    download_rate = 0
+    eta = 0
+    
+    if last_stats and 'completed' in last_stats and last_stats['completed'] < completed_videos:
+        time_diff = time.time() - last_stats.get('timestamp', start_time)
+        if time_diff > 0:
+            download_rate = (completed_videos - last_stats['completed']) / time_diff * 60  # per minute
+            if download_rate > 0 and pending_videos > 0:
+                eta = pending_videos / download_rate * 60  # seconds
+    
+    return total_videos, completed_videos, pending_videos, recent_files, download_rate, eta, file_sizes
+
+def draw_progress_bar(stdscr, y, x, width, label, percentage, color_pair):
+    """Draws a label and a progress bar with improved visuals."""
+    if width <= 0 or y >= stdscr.getmaxyx()[0]: 
+        return
+    
+    # Reserve space for label, percentage, and brackets
+    label_width = len(label)
+    percent_str = f" [{percentage:5.1f}%]"
+    bar_area_width = width - label_width - len(percent_str)
+    
+    if bar_area_width <= 0: 
+        return
+
+    filled_len = int(bar_area_width * percentage / 100)
+    bar = BAR_CHAR * filled_len + EMPTY_BAR_CHAR * (bar_area_width - filled_len)
+
+    try:
+        stdscr.addstr(y, x, label, curses.color_pair(3))
+        stdscr.addstr(y, x + label_width, bar, color_pair)
+        stdscr.addstr(y, x + label_width + bar_area_width, percent_str)
+    except curses.error:
+        # Safely handle drawing errors
+        pass
+
+def format_size(size_bytes):
+    """Format bytes into human-readable format."""
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes/1024:.1f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes/(1024*1024):.1f} MB"
+    else:
+        return f"{size_bytes/(1024*1024*1024):.2f} GB"
+
+def safe_addstr(stdscr, y, x, text, attr=0):
+    """Safely add a string to the screen, handling boundary errors."""
+    height, width = stdscr.getmaxyx()
+    if y < 0 or y >= height or x < 0 or x >= width:
+        return
+    
+    # Truncate the string if it would go off-screen
+    max_len = width - x
+    if max_len <= 0:
+        return
+    
+    display_text = text[:max_len]
+    
+    try:
+        stdscr.addstr(y, x, display_text, attr)
+    except curses.error:
+        # Safely handle any curses errors
+        pass
+
+def main(stdscr, json_path, output_dir):
+    # --- Curses Setup ---
+    curses.curs_set(0)  # Hide cursor
+    curses.use_default_colors()
+    curses.init_pair(1, curses.COLOR_GREEN, -1)   # Success / Bar
+    curses.init_pair(2, curses.COLOR_WHITE, -1)   # Normal text
+    curses.init_pair(3, curses.COLOR_CYAN, -1)    # Labels
+    curses.init_pair(4, curses.COLOR_RED, -1)     # Error / Warning
+    curses.init_pair(5, curses.COLOR_YELLOW, -1)  # Info
+    
+    # For tracking download rate
+    last_stats = None
+    start_time = time.time()
+    
+    while True:
+        stdscr.erase()
+        height, width = stdscr.getmaxyx()
+
+        # --- Data Loading ---
+        total, completed, pending, recent_files, download_rate, eta, file_sizes = analyze_progress(
+            json_path, output_dir, last_stats
+        )
+        
+        # Update stats for next iteration
+        last_stats = {
+            'completed': completed,
+            'timestamp': time.time()
+        }
+        
+        # Calculate total downloaded size
+        total_size = sum(file_sizes.values())
+        
+        # --- Drawing UI ---
+        # Header
+        header = f"Download Monitor - {os.path.basename(json_path)}"
+        safe_addstr(stdscr, 0, 2, header, curses.A_BOLD)
+        safe_addstr(stdscr, 1, 2, f"Output: {os.path.basename(output_dir)}", curses.A_DIM)
+        safe_addstr(stdscr, 2, 2, "Press 'q' to quit, 'r' to refresh", curses.A_DIM)
+        
+        try:
+            stdscr.hline(3, 0, "-", width)
+        except curses.error:
+            pass
+            
+        y_pos = 5
+
+        # Stats Section
+        if total == 0:
+            safe_addstr(stdscr, y_pos, 4, "Waiting for data or JSON not found...", curses.color_pair(4) | curses.A_BOLD)
+            y_pos += 2
+        else:
+            # Stats header
+            safe_addstr(stdscr, y_pos, 4, "Download Statistics", curses.color_pair(3) | curses.A_BOLD)
+            y_pos += 2
+            
+            # Left column stats
+            safe_addstr(stdscr, y_pos, 4, f"Total Videos: {total}", curses.color_pair(2))
+            safe_addstr(stdscr, y_pos + 1, 4, f"Completed: {completed}", curses.color_pair(1))
+            safe_addstr(stdscr, y_pos + 2, 4, f"Pending: {pending}", curses.color_pair(5))
+            
+            # Right column stats if there's enough space
+            if width > 50:
+                right_col = width // 2
+                safe_addstr(stdscr, y_pos, right_col, f"Total Size: {format_size(total_size)}", curses.color_pair(2))
+                safe_addstr(stdscr, y_pos + 1, right_col, f"Rate: {download_rate:.1f} videos/min", curses.color_pair(1))
+                
+                if eta > 0:
+                    eta_str = format_time(eta)
+                    safe_addstr(stdscr, y_pos + 2, right_col, f"ETA: {eta_str}", curses.color_pair(5))
+                else:
+                    safe_addstr(stdscr, y_pos + 2, right_col, "ETA: calculating...", curses.color_pair(5))
+            
+            y_pos += 4
+            
+            # Progress Bar
+            percentage = (completed / total) * 100 if total > 0 else 0
+            draw_progress_bar(stdscr, y_pos, 4, width - 8, "Progress: ", percentage, curses.color_pair(1))
+            y_pos += 2
+            
+            # Runtime
+            runtime = time.time() - start_time
+            runtime_str = format_time(runtime)
+            safe_addstr(stdscr, y_pos, 4, f"Runtime: {runtime_str}", curses.color_pair(2))
+            y_pos += 2
+
+        # Separator
+        try:
+            stdscr.hline(y_pos, 0, "-", width)
+        except curses.error:
+            pass
+            
+        y_pos += 1
+
+        # Recent Files Section
+        safe_addstr(stdscr, y_pos, 2, "Recently Completed Files:", curses.color_pair(3) | curses.A_BOLD)
+        y_pos += 2
+        
+        if recent_files:
+            for i, (filename, mtime, size, title, video_id) in enumerate(recent_files):
+                if y_pos >= height - 1: 
+                    break
+                
+                # Format the time
+                time_str = datetime.fromtimestamp(mtime).strftime("%H:%M:%S")
+                size_str = format_size(size)
+                
+                # Display title if available, otherwise filename
+                display_name = title if title != 'Unknown' else filename
+                
+                # Truncate long names
+                max_name_len = width - 25 if width > 25 else 10
+                if len(display_name) > max_name_len:
+                    display_name = display_name[:max_name_len-3] + "..."
+                
+                file_info = f"{display_name} ({size_str}, {time_str})"
+                safe_addstr(stdscr, y_pos, 4, file_info, curses.color_pair(2))
+                y_pos += 1
+        else:
+            safe_addstr(stdscr, y_pos, 4, "(No completed files found yet)", curses.color_pair(4))
+
+        stdscr.refresh()
+        
+        # Non-blocking input with a timeout
+        stdscr.timeout(REFRESH_INTERVAL_SECONDS * 1000)
+        key = stdscr.getch()
+        if key == ord('q'):
+            break
+        elif key == ord('r'):
+            # Force refresh
+            continue
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="A curses-based monitor for the video downloader script.",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument(
+        "json_file",
+        type=str,
+        help="Path to the JSON file containing video information (the same one used by the downloader)."
+    )
+    parser.add_argument(
+        "output_dir",
+        type=str,
+        help="Path to the output directory where videos are being saved."
+    )
+    args = parser.parse_args()
+
+    print(f"Starting download monitor...")
+    print(f" - Watching JSON: {args.json_file}")
+    print(f" - Watching Dir:  {args.output_dir}")
+    print("\nPress 'q' in the monitor window to exit.")
+    time.sleep(1)
+
+    try:
+        curses.wrapper(main, args.json_file, args.output_dir)
+    except curses.error as e:
+        print(f"\nCurses error: {e}")
+        print("Your terminal window might be too small to run the monitor.")
+    except KeyboardInterrupt:
+        print("\nMonitor stopped.")

vatex_training_v1.0.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a3b5f08e354d9543ef4f1ab004f9db9bc4e5da49d9692f0c8c6aa3bef9751c4
+size 57319458