Spaces:
Sleeping
Sleeping
| """ | |
| Video Keyword Finder with Gradio Interface | |
| ======================================== | |
| A Python script that finds and timestamps specific keywords within video files. | |
| It transcribes the audio using Whisper AI and finds all occurrences of specified keywords | |
| with their timestamps and surrounding context. Supports both local video files and YouTube URLs. | |
| Requirements | |
| ----------- | |
| - Python 3.8 or higher | |
| - ffmpeg (must be installed and accessible in system PATH) | |
| - GPU recommended but not required | |
| """ | |
| import whisper_timestamped as whisper | |
| import datetime | |
| import os | |
| import tempfile | |
| import yt_dlp | |
| import re | |
| import logging | |
| import math | |
| import subprocess | |
| import glob | |
| import gradio as gr | |
| # Set up logging | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format='%(asctime)s - %(levelname)s - %(message)s', | |
| handlers=[ | |
| logging.StreamHandler() | |
| ] | |
| ) | |
| def parse_time(time_str): | |
| """Convert time string (HH:MM:SS) to seconds""" | |
| if not time_str or time_str.strip() == "": | |
| return None | |
| try: | |
| time_parts = list(map(int, time_str.split(':'))) | |
| if len(time_parts) == 3: # HH:MM:SS | |
| return time_parts[0] * 3600 + time_parts[1] * 60 + time_parts[2] | |
| elif len(time_parts) == 2: # MM:SS | |
| return time_parts[0] * 60 + time_parts[1] | |
| else: | |
| return int(time_str) # Just seconds | |
| except: | |
| raise ValueError("Time must be in HH:MM:SS, MM:SS, or seconds format") | |
| def format_time(seconds): | |
| """Convert seconds to HH:MM:SS format""" | |
| return str(datetime.timedelta(seconds=int(seconds))) | |
| def is_youtube_url(url): | |
| """Check if the provided string is a YouTube URL""" | |
| if not url or url.strip() == "": | |
| return False | |
| youtube_regex = ( | |
| r'(https?://)?(www\.)?' | |
| r'(youtube|youtu|youtube-nocookie)\.(com|be)/' | |
| r'(watch\?v=|embed/|v/|.+\?v=)?([^&=%\?]{11})' | |
| ) | |
| return bool(re.match(youtube_regex, url)) | |
| def download_youtube_video(url): | |
| """Download YouTube video and return path to temporary file""" | |
| temp_dir = tempfile.gettempdir() | |
| temp_file = os.path.join(temp_dir, 'youtube_video.mp4') | |
| ydl_opts = { | |
| 'format': 'best[ext=mp4]', | |
| 'outtmpl': temp_file, | |
| 'quiet': False, | |
| 'progress_hooks': [lambda d: logging.info(f"Download progress: {d.get('status', 'unknown')}")], | |
| 'socket_timeout': 30, | |
| } | |
| try: | |
| logging.info(f"Starting download of YouTube video: {url}") | |
| with yt_dlp.YoutubeDL(ydl_opts) as ydl: | |
| info = ydl.extract_info(url, download=True) | |
| logging.info(f"Video info extracted: {info.get('title', 'Unknown title')}") | |
| if os.path.exists(temp_file): | |
| file_size = os.path.getsize(temp_file) | |
| logging.info(f"Download complete. File size: {file_size / (1024*1024):.2f} MB") | |
| return temp_file | |
| else: | |
| raise Exception("Download completed but file not found") | |
| except Exception as e: | |
| logging.error(f"Error downloading YouTube video: {str(e)}") | |
| raise | |
| def get_video_duration(video_path): | |
| """Get video duration using ffprobe""" | |
| cmd = [ | |
| 'ffprobe', | |
| '-v', 'error', | |
| '-show_entries', 'format=duration', | |
| '-of', 'default=noprint_wrappers=1:nokey=1', | |
| video_path | |
| ] | |
| try: | |
| output = subprocess.check_output(cmd).decode().strip() | |
| return float(output) | |
| except subprocess.CalledProcessError as e: | |
| logging.error(f"Error getting video duration: {str(e)}") | |
| raise | |
| def split_video(video_path, segment_duration=120): | |
| """Split video into segments using ffmpeg""" | |
| try: | |
| temp_dir = tempfile.gettempdir() | |
| segment_pattern = os.path.join(temp_dir, 'segment_%03d.mp4') | |
| # Remove any existing segments | |
| for old_segment in glob.glob(os.path.join(temp_dir, 'segment_*.mp4')): | |
| try: | |
| os.remove(old_segment) | |
| except: | |
| pass | |
| # Split video into segments | |
| cmd = [ | |
| 'ffmpeg', | |
| '-i', video_path, | |
| '-f', 'segment', | |
| '-segment_time', str(segment_duration), | |
| '-c', 'copy', | |
| '-reset_timestamps', '1', | |
| segment_pattern | |
| ] | |
| logging.info("Splitting video into segments...") | |
| subprocess.run(cmd, check=True, capture_output=True) | |
| # Get list of generated segments | |
| segments = sorted(glob.glob(os.path.join(temp_dir, 'segment_*.mp4'))) | |
| logging.info(f"Created {len(segments)} segments") | |
| return segments | |
| except Exception as e: | |
| logging.error(f"Error splitting video: {str(e)}") | |
| raise | |
| def process_segments(segments, keywords): | |
| """Process each segment sequentially""" | |
| results = {keyword: [] for keyword in keywords} | |
| # Load whisper model once | |
| logging.info("Loading Whisper model...") | |
| model = whisper.load_model("base") | |
| for i, segment_path in enumerate(segments): | |
| try: | |
| segment_num = int(re.search(r'segment_(\d+)', segment_path).group(1)) | |
| start_time = segment_num * 120 # Each segment is 120 seconds | |
| logging.info(f"Processing segment {i+1}/{len(segments)} (starting at {format_time(start_time)})") | |
| # Transcribe segment | |
| audio = whisper.load_audio(segment_path) | |
| transcription = whisper.transcribe(model, audio) | |
| # Process results | |
| for segment in transcription['segments']: | |
| text = segment['text'].lower() | |
| timestamp = segment['start'] + start_time # Adjust timestamp relative to full video | |
| for keyword in keywords: | |
| if keyword.lower() in text: | |
| results[keyword].append(( | |
| timestamp, | |
| segment['text'] | |
| )) | |
| logging.info(f"Found keyword '{keyword}' at {format_time(timestamp)}: {segment['text']}") | |
| except Exception as e: | |
| logging.error(f"Error processing segment {segment_path}: {str(e)}") | |
| continue | |
| finally: | |
| # Clean up segment file | |
| try: | |
| os.remove(segment_path) | |
| except: | |
| pass | |
| return results | |
| def find_keywords_in_video(video_path, keywords, begin_time=None, end_time=None): | |
| """Find timestamps for keywords in video transcription""" | |
| try: | |
| logging.info(f"Processing video: {video_path}") | |
| logging.info(f"Searching for keywords: {keywords}") | |
| # Convert keywords string to list and clean up | |
| if isinstance(keywords, str): | |
| keywords = [k.strip() for k in keywords.split(',')] | |
| # Get video duration | |
| duration = get_video_duration(video_path) | |
| logging.info(f"Video duration: {duration:.2f} seconds") | |
| # Set time bounds | |
| start = parse_time(begin_time) if begin_time else 0 | |
| end = min(parse_time(end_time) if end_time else duration, duration) | |
| if start is not None and end is not None and start >= end: | |
| raise ValueError("End time must be greater than start time") | |
| # Split video into segments | |
| segment_duration = 120 # 2 minutes per segment | |
| segments = split_video(video_path, segment_duration) | |
| # Process segments sequentially | |
| results = process_segments(segments, keywords) | |
| return results | |
| except Exception as e: | |
| logging.error(f"Error processing video: {str(e)}") | |
| raise | |
| def process_video(video_file, youtube_url, keywords_input, start_time="0:00", end_time=None): | |
| """ | |
| Process video file or YouTube URL and find keywords | |
| """ | |
| try: | |
| # Convert keywords string to list | |
| keywords = [k.strip() for k in keywords_input.split(',') if k.strip()] | |
| if not keywords: | |
| return "Please enter at least one keyword (separated by commas)" | |
| # Handle input source | |
| if youtube_url and youtube_url.strip(): | |
| if not is_youtube_url(youtube_url): | |
| return "Invalid YouTube URL. Please provide a valid URL." | |
| video_path = download_youtube_video(youtube_url) | |
| cleanup_needed = True | |
| elif video_file is not None: | |
| video_path = video_file | |
| cleanup_needed = False | |
| else: | |
| return "Please provide either a video file or a YouTube URL" | |
| try: | |
| # Find keywords | |
| results = find_keywords_in_video( | |
| video_path=video_path, | |
| keywords=keywords, | |
| begin_time=start_time if start_time else None, | |
| end_time=end_time if end_time else None | |
| ) | |
| # Format results | |
| output = [] | |
| total_matches = sum(len(matches) for matches in results.values()) | |
| output.append(f"Total matches found: {total_matches}\n") | |
| if total_matches == 0: | |
| output.append("No matches found for any keywords.") | |
| else: | |
| for keyword, matches in results.items(): | |
| if matches: | |
| output.append(f"\nResults for '{keyword}':") | |
| for timestamp, context in matches: | |
| output.append(f"[{format_time(timestamp)}] {context}") | |
| else: | |
| output.append(f"\nNo occurrences found for '{keyword}'") | |
| return "\n".join(output) | |
| finally: | |
| # Cleanup temporary files | |
| if cleanup_needed and os.path.exists(video_path): | |
| try: | |
| os.remove(video_path) | |
| except: | |
| pass | |
| except Exception as e: | |
| logging.error(f"Error processing video: {str(e)}") | |
| return f"Error processing video: {str(e)}" | |
| # Create Gradio interface | |
| with gr.Blocks(title="Video Keyword Finder", theme=gr.themes.Soft()) as demo: | |
| gr.Markdown(""" | |
| # 🎥 Video Keyword Finder | |
| Find timestamps for specific keywords in your videos using AI transcription. | |
| Upload a video file or provide a YouTube URL, then enter the keywords you want to find. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| video_input = gr.File( | |
| label="Upload Video File", | |
| file_types=["video"], | |
| type="filepath" | |
| ) | |
| youtube_url = gr.Textbox( | |
| label="Or Enter YouTube URL", | |
| placeholder="https://www.youtube.com/watch?v=..." | |
| ) | |
| keywords = gr.Textbox( | |
| label="Keywords (comma-separated)", | |
| placeholder="enter, your, keywords, here" | |
| ) | |
| with gr.Row(): | |
| start_time = gr.Textbox( | |
| label="Start Time (HH:MM:SS)", | |
| placeholder="0:00", | |
| value="0:00" | |
| ) | |
| end_time = gr.Textbox( | |
| label="End Time (HH:MM:SS)", | |
| placeholder="Optional" | |
| ) | |
| submit_btn = gr.Button("Find Keywords", variant="primary") | |
| with gr.Column(): | |
| output = gr.Textbox( | |
| label="Results", | |
| placeholder="Keywords and timestamps will appear here...", | |
| lines=20 | |
| ) | |
| gr.Markdown(""" | |
| ### Instructions: | |
| 1. Upload a video file or paste a YouTube URL | |
| 2. Enter keywords separated by commas (e.g., "hello, world, python") | |
| 3. Optionally set start and end times (format: HH:MM:SS) | |
| 4. Click "Find Keywords" and wait for results | |
| Note: Processing time depends on video length. A 1-hour video typically takes 15-30 minutes. | |
| """) | |
| submit_btn.click( | |
| fn=process_video, | |
| inputs=[video_input, youtube_url, keywords, start_time, end_time], | |
| outputs=output | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch(share=True, debug=True) | |