Remove YouTube functionality completely - file upload only

Dockerfile

@@ -15,12 +15,6 @@ RUN apt-get update && apt-get install -y \
     libavcodec-dev \
     libavformat-dev \
     libswscale-dev \
-    curl \
-    wget \
-    ca-certificates \
-    dnsutils \
-    iputils-ping \
-    net-tools \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements first to leverage Docker cache
@@ -58,13 +52,10 @@ ENV HF_HOME=/tmp/cache/huggingface
 # DNS and network settings
 ENV PYTHONDONTWRITEBYTECODE=1
 ENV PYTHONPATH=/app
-# Configure DNS servers and network settings
-ENV DNS_SERVERS="8.8.8.8 1.1.1.1 208.67.222.222"
-ENV REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
-ENV SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
-# Network and DNS environment variables
-ENV PYTHONHTTPSVERIFY=0
-ENV CURL_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
+# Basic environment variables
+ENV PYTHONUNBUFFERED=1
+ENV FLASK_APP=app.py
+ENV FLASK_ENV=production
 
 # Expose port
 EXPOSE 5000

app.py

@@ -25,24 +25,8 @@ os.environ['XDG_CACHE_HOME'] = '/tmp/cache'
 os.environ['PYTHONDONTWRITEBYTECODE'] = '1'
 os.environ['PYTHONPATH'] = '/app'
 
-# Test network connectivity on startup
-try:
-    from utils.youtube_downloader import test_network_connectivity, check_dns_resolution, setup_network_environment
-    
-    # Setup network environment first
-    setup_network_environment()
-    
-    if test_network_connectivity():
-        logger.info("✅ Network connectivity test passed")
-    else:
-        logger.warning("⚠️ Network connectivity test failed")
-    
-    if check_dns_resolution():
-        logger.info("✅ DNS resolution test passed")
-    else:
-        logger.warning("⚠️ DNS resolution test failed")
-except Exception as e:
-    logger.warning(f"Could not run network tests: {e}")
+# Network tests removed - YouTube functionality disabled
+logger.info("📹 YouTube download functionality disabled")
 
 # Create cache directories if they don't exist
 os.makedirs('/tmp/cache/torch', exist_ok=True)
@@ -55,7 +39,8 @@ import uuid
 from werkzeug.utils import secure_filename
 
 from models.video_processor import VideoProcessor
-from utils.youtube_downloader import download_youtube_video
+# YouTube downloader removed
+# from utils.youtube_downloader import download_youtube_video
 
 # Configure clean logging
 # logging.basicConfig(
@@ -106,10 +91,11 @@ def allowed_file(filename):
     return '.' in filename and \
            filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-def is_youtube_url(url):
-    """Check if URL is a YouTube video"""
-    youtube_domains = ['youtube.com', 'youtu.be', 'www.youtube.com', 'm.youtube.com']
-    return any(domain in url.lower() for domain in youtube_domains)
+# YouTube functionality removed
+# def is_youtube_url(url):
+#     """Check if URL is a YouTube video"""
+#     youtube_domains = ['youtube.com', 'youtu.be', 'www.youtube.com', 'm.youtube.com']
+#     return any(domain in url.lower() for domain in youtube_domains)
 
 @app.route('/')
 def index():
@@ -118,7 +104,7 @@ def index():
 
 @app.route('/upload', methods=['POST'])
 def upload_video():
-    """Handle video upload or YouTube URL"""
+    """Handle video upload only (YouTube functionality disabled)"""
     global video_processor
     
     # Check if video processor is available, try to initialize if not
@@ -137,36 +123,23 @@ def upload_video():
     try:
         video_path = None
         
-        # Check if it's a YouTube URL
-        youtube_url = request.form.get('youtube_url', '').strip()
-        if youtube_url:
-            if not is_youtube_url(youtube_url):
-                return jsonify({'error': 'Invalid YouTube URL'}), 400
-            
-            logger.info(f"Processing YouTube URL: {youtube_url}")
-            try:
-                video_path = download_youtube_video(youtube_url, app.config['UPLOAD_FOLDER'])
-            except Exception as e:
-                logger.error(f"YouTube download error: {str(e)}")
-                return jsonify({'error': f'Failed to download YouTube video: {str(e)}'}), 400
+        # Handle file upload only
+        if 'video' not in request.files:
+            return jsonify({'error': 'No video file provided'}), 400
+        
+        file = request.files['video']
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
         
-        # Check if it's a file upload
-        elif 'video' in request.files:
-            file = request.files['video']
-            if file.filename == '':
-                return jsonify({'error': 'No file selected'}), 400
-            
-            if file and allowed_file(file.filename):
-                # Generate unique filename
-                filename = secure_filename(file.filename)
-                unique_filename = f"{uuid.uuid4()}_{filename}"
-                video_path = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
-                file.save(video_path)
-                logger.info(f"File uploaded: {video_path}")
-            else:
-                return jsonify({'error': 'Invalid file format'}), 400
+        if file and allowed_file(file.filename):
+            # Generate unique filename
+            filename = secure_filename(file.filename)
+            unique_filename = f"{uuid.uuid4()}_{filename}"
+            video_path = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
+            file.save(video_path)
+            logger.info(f"File uploaded: {video_path}")
         else:
-            return jsonify({'error': 'No video file or YouTube URL provided'}), 400
+            return jsonify({'error': 'Invalid file format. Please upload MP4, AVI, MOV, MKV, or other supported formats.'}), 400
         
         # Process video
         logger.info(f"Starting video processing: {video_path}")

requirements-flexible.txt

@@ -19,7 +19,7 @@ numpy>=1.24.0,<2.0.0
 pandas>=2.0.0
 
 # YouTube Downloads
-yt-dlp>=2024.1.0
+# yt-dlp removed - YouTube functionality disabled
 
 # Utilities
 tqdm>=4.65.0

requirements.txt

@@ -19,7 +19,7 @@ numpy==1.26.0
 pandas==2.1.0
 
 # YouTube Downloads
-yt-dlp==2024.1.6
+# yt-dlp removed - YouTube functionality disabled
 
 # Utilities
 tqdm==4.66.1

static/js/script.js

@@ -6,7 +6,6 @@ document.addEventListener('DOMContentLoaded', function() {
     const resultsSection = document.getElementById('results');
     const errorSection = document.getElementById('error');
     const videoInput = document.getElementById('video');
-    const youtubeInput = document.getElementById('youtube_url');
 
     // Exercise names for display
     const ACTIONS = [
@@ -17,28 +16,14 @@ document.addEventListener('DOMContentLoaded', function() {
         "shoulder press", "squat", "t bar row", "tricep Pushdown", "tricep dips"
     ];
 
-    // Clear other input when one is selected
-    videoInput.addEventListener('change', function() {
-        if (this.files.length > 0) {
-            youtubeInput.value = '';
-        }
-    });
-
-    youtubeInput.addEventListener('input', function() {
-        if (this.value.trim()) {
-            videoInput.value = '';
-        }
-    });
-
     uploadForm.addEventListener('submit', async function(e) {
         e.preventDefault();
         
         // Validate inputs
         const hasFile = videoInput.files.length > 0;
-        const hasYouTube = youtubeInput.value.trim();
         
-        if (!hasFile && !hasYouTube) {
-            showError('Please select a video file or provide a YouTube URL.');
+        if (!hasFile) {
+            showError('Please select a video file to upload.');
             return;
         }
 
@@ -49,14 +34,7 @@ document.addEventListener('DOMContentLoaded', function() {
 
         try {
             const formData = new FormData();
-            
-            if (hasFile) {
-                formData.append('video', videoInput.files[0]);
-            }
-            
-            if (hasYouTube) {
-                formData.append('youtube_url', youtubeInput.value.trim());
-            }
+            formData.append('video', videoInput.files[0]);
 
             const response = await fetch('/upload', {
                 method: 'POST',

templates/index.html

@@ -10,26 +10,17 @@
     <div class="container">
         <header>
             <h1>🏋️ Gym Exercise Recognition</h1>
-            <p>Upload a video or provide a YouTube link to recognize gym exercises</p>
+            <p>Upload a video file to recognize gym exercises</p>
         </header>
 
         <div class="upload-section">
             <form id="uploadForm" enctype="multipart/form-data">
                 <div class="input-group">
                     <label for="video">Upload Video File:</label>
-                    <input type="file" id="video" name="video" accept="video/*">
+                    <input type="file" id="video" name="video" accept="video/*" required>
                     <small>Supported formats: MP4, AVI, MOV, MKV, WebM, WMV, FLV, M4V, 3GP</small>
                 </div>
                 
-                <div class="or-divider">
-                    <span>OR</span>
-                </div>
-                
-                <div class="input-group">
-                    <label for="youtube_url">YouTube URL:</label>
-                    <input type="url" id="youtube_url" name="youtube_url" placeholder="https://www.youtube.com/watch?v=...">
-                </div>
-                
                 <button type="submit" id="submitBtn">
                     <span id="btnText">Analyze Video</span>
                     <span id="loadingSpinner" class="spinner" style="display: none;"></span>

utils/youtube_downloader.py

@@ -1,422 +0,0 @@
-import os
-import re
-import uuid
-import logging
-import socket
-from urllib.parse import urlparse, parse_qs
-
-logger = logging.getLogger(__name__)
-
-def check_dns_resolution():
-    """Check if DNS resolution is working"""
-    try:
-        # Try multiple DNS servers
-        dns_servers = ['8.8.8.8', '1.1.1.1', '208.67.222.222', '9.9.9.9']
-        
-        for dns_server in dns_servers:
-            try:
-                # Try to resolve YouTube with specific timeout
-                socket.setdefaulttimeout(10)
-                ip = socket.gethostbyname('www.youtube.com')
-                logger.info(f"DNS resolution successful: www.youtube.com -> {ip}")
-                return True
-            except Exception as e:
-                logger.warning(f"DNS server {dns_server} failed: {e}")
-                continue
-        
-        logger.error("All DNS servers failed")
-        return False
-        
-    except Exception as e:
-        logger.error(f"DNS resolution failed: {e}")
-        return False
-
-def setup_network_environment():
-    """Setup network environment variables"""
-    try:
-        import os
-        
-        # Set DNS servers via environment
-        os.environ['DNS_SERVERS'] = '8.8.8.8 1.1.1.1 208.67.222.222'
-        
-        # Disable SSL verification for testing
-        os.environ['PYTHONHTTPSVERIFY'] = '0'
-        os.environ['REQUESTS_CA_BUNDLE'] = '/etc/ssl/certs/ca-certificates.crt'
-        os.environ['SSL_CERT_FILE'] = '/etc/ssl/certs/ca-certificates.crt'
-        os.environ['CURL_CA_BUNDLE'] = '/etc/ssl/certs/ca-certificates.crt'
-        
-        logger.info("Network environment variables set")
-        return True
-    except Exception as e:
-        logger.warning(f"Could not set network environment: {e}")
-        return False
-
-def test_network_connectivity():
-    """Test basic network connectivity"""
-    try:
-        import subprocess
-        import shutil
-        
-        # Check if ping is available
-        if shutil.which('ping'):
-            # Try to ping Google DNS with shorter timeout
-            result = subprocess.run(['ping', '-c', '1', '-W', '5', '8.8.8.8'], 
-                                  capture_output=True, text=True, timeout=8)
-            if result.returncode == 0:
-                logger.info("Network connectivity test passed")
-                return True
-            else:
-                logger.warning(f"Ping test failed: {result.stderr}")
-                return False
-        else:
-            logger.warning("Ping not available, skipping network test")
-            return True
-            
-    except subprocess.TimeoutExpired:
-        logger.warning("Ping test timed out, but continuing...")
-        return True  # Don't fail on timeout
-    except Exception as e:
-        logger.warning(f"Network connectivity test failed: {e}")
-        return True  # Don't fail on network test errors
-
-def extract_video_id(url):
-    """Extract YouTube video ID from various URL formats"""
-    patterns = [
-        r'(?:v=|\/)([0-9A-Za-z_-]{11}).*',
-        r'(?:embed\/)([0-9A-Za-z_-]{11})',
-        r'(?:vi\/)([0-9A-Za-z_-]{11})',
-        r'(?:v\/)([0-9A-Za-z_-]{11})',
-        r'(?:\/|%3D)([0-9A-Za-z_-]{11})',
-        r'(?:watch.*v=)([0-9A-Za-z_-]{11})',
-        r'^([0-9A-Za-z_-]{11})$'
-    ]
-    
-    for pattern in patterns:
-        match = re.search(pattern, url)
-        if match:
-            return match.group(1)
-    
-    return None
-
-def download_youtube_video(url, output_dir):
-    """
-    Download YouTube video using yt-dlp
-    Returns: path to downloaded video file
-    """
-    try:
-        import yt_dlp
-    except ImportError:
-        raise ImportError("yt-dlp is required for YouTube downloads. Install with: pip install yt-dlp")
-    
-    # Setup network environment
-    setup_network_environment()
-    
-    # Check network connectivity first (but don't fail if it doesn't work)
-    if not test_network_connectivity():
-        logger.warning("Network connectivity test failed, but continuing with download attempt...")
-    
-    # Check DNS resolution
-    if not check_dns_resolution():
-        logger.warning("DNS resolution failed, but continuing with download attempt...")
-        # Don't fail immediately, try the download anyway
-    
-    # Try alternative DNS resolution methods
-    try:
-        import socket
-        import requests
-        
-        # Method 1: Try with requests library
-        try:
-            response = requests.get('https://www.youtube.com', timeout=10)
-            if response.status_code == 200:
-                logger.info("YouTube connectivity confirmed via requests")
-            else:
-                logger.warning(f"YouTube response status: {response.status_code}")
-        except Exception as e:
-            logger.warning(f"Requests method failed: {e}")
-        
-        # Method 2: Try with custom DNS resolution
-        try:
-            # Try to resolve with different methods
-            socket.setdefaulttimeout(10)
-            ip = socket.gethostbyname('www.youtube.com')
-            logger.info(f"Manual DNS resolution successful: {ip}")
-        except Exception as e:
-            logger.warning(f"Manual DNS resolution failed: {e}")
-            
-    except Exception as e:
-        logger.warning(f"Alternative DNS methods failed: {e}")
-    
-    # Extract video ID for unique filename
-    video_id = extract_video_id(url)
-    if not video_id:
-        raise ValueError("Invalid YouTube URL - cannot extract video ID")
-    
-    # Create unique filename with simpler pattern
-    unique_id = str(uuid.uuid4())[:8]
-    output_filename = f"youtube_{video_id}_{unique_id}.%(ext)s"
-    output_path = os.path.join(output_dir, output_filename)
-    
-    # Also create a backup simple filename
-    simple_filename = f"video_{unique_id}.%(ext)s"
-    simple_output_path = os.path.join(output_dir, simple_filename)
-    
-    # yt-dlp options with multiple output templates and enhanced network settings
-    ydl_opts = {
-        'outtmpl': [
-            output_path,           # Primary template
-            simple_output_path,    # Backup simple template
-            os.path.join(output_dir, '%(title)s.%(ext)s'),  # Title-based template
-            os.path.join(output_dir, '%(id)s.%(ext)s'),     # ID-based template
-        ],
-        'format': 'best[height<=720]/best',  # Prefer 720p or lower for faster processing
-        'noplaylist': True,
-        'quiet': False,  # Enable output for debugging
-        'no_warnings': False,  # Show warnings for debugging
-        'nocheckcertificate': True,  # Skip SSL certificate verification
-        'ignoreerrors': True,  # Continue on download errors
-        'socket_timeout': 120,  # Increase socket timeout significantly
-        'retries': 10,  # More retries
-        'fragment_retries': 10,  # More fragment retries
-        'progress_hooks': [lambda d: logger.info(f"Download progress: {d.get('status', 'unknown')}") if d.get('status') == 'finished' else None],
-        'http_headers': {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Accept-Encoding': 'gzip, deflate',
-            'Connection': 'keep-alive',
-        },
-        'extractor_args': {
-            'youtube': {
-                'skip': ['dash', 'live'],
-                'player_client': ['android', 'web'],
-            }
-        },
-    }
-    
-    logger.info(f"Downloading YouTube video: {url}")
-    
-    try:
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            # Get video info first
-            try:
-                info = ydl.extract_info(url, download=False)
-                if info is None:
-                    raise ValueError("Could not extract video information from URL")
-                
-                duration = info.get('duration', 0)
-                
-                # Check duration limit (10 minutes max for demo)
-                if duration > 600:  # 10 minutes
-                    raise ValueError(f"Video too long ({duration}s). Please use videos shorter than 10 minutes.")
-                
-                logger.info(f"Video info extracted: duration={duration}s")
-                
-            except Exception as info_error:
-                logger.warning(f"Could not extract video info: {info_error}")
-                # Continue with download anyway
-                info = None
-            
-            # Download the video
-            logger.info("Starting video download...")
-            logger.info(f"Output template: {output_path}")
-            logger.info(f"Output directory: {output_dir}")
-            
-            # List files before download
-            try:
-                files_before = os.listdir(output_dir)
-                logger.info(f"Files before download: {files_before}")
-            except Exception as e:
-                logger.warning(f"Could not list files before download: {e}")
-            
-            ydl.download([url])
-            
-            # List files after download
-            try:
-                files_after = os.listdir(output_dir)
-                logger.info(f"Files after download: {files_after}")
-            except Exception as e:
-                logger.warning(f"Could not list files after download: {e}")
-            
-            # Try fallback download if no file found
-            if not any(f.lower().endswith(('.mp4', '.mkv', '.webm', '.avi', '.m4v', '.mov')) for f in files_after):
-                logger.warning("No video file found, trying fallback download...")
-                
-                # Try with simpler options
-                fallback_opts = {
-                    'outtmpl': os.path.join(output_dir, '%(id)s.%(ext)s'),
-                    'format': 'best',
-                    'noplaylist': True,
-                    'quiet': False,
-                    'no_warnings': False,
-                    'nocheckcertificate': True,
-                    'ignoreerrors': True,
-                }
-                
-                try:
-                    with yt_dlp.YoutubeDL(fallback_opts) as ydl_fallback:
-                        ydl_fallback.download([url])
-                    
-                    # List files after fallback download
-                    try:
-                        files_after_fallback = os.listdir(output_dir)
-                        logger.info(f"Files after fallback download: {files_after_fallback}")
-                    except Exception as e:
-                        logger.warning(f"Could not list files after fallback download: {e}")
-                        
-                except Exception as fallback_error:
-                    logger.error(f"Fallback download also failed: {fallback_error}")
-                    
-                    # Try curl as last resort
-                    logger.warning("Trying curl as last resort...")
-                    try:
-                        import subprocess
-                        curl_cmd = [
-                            'curl', '-L', '-o', 
-                            os.path.join(output_dir, f'{video_id}.mp4'),
-                            '--connect-timeout', '30',
-                            '--max-time', '300',
-                            '--retry', '3',
-                            '--retry-delay', '2',
-                            url
-                        ]
-                        result = subprocess.run(curl_cmd, capture_output=True, text=True, timeout=300)
-                        if result.returncode == 0:
-                            logger.info("Curl download successful")
-                        else:
-                            logger.error(f"Curl download failed: {result.stderr}")
-                    except Exception as curl_error:
-                        logger.error(f"Curl download also failed: {curl_error}")
-            
-            # Find the actual downloaded file
-            logger.info("Searching for downloaded file...")
-            
-            downloaded_file = None
-            
-            # Method 1: Try all possible output templates
-            possible_templates = [
-                output_path.replace('.%(ext)s', ''),
-                simple_output_path.replace('.%(ext)s', ''),
-                os.path.join(output_dir, video_id),
-                os.path.join(output_dir, f"youtube_{video_id}"),
-                os.path.join(output_dir, f"video_{unique_id}"),
-            ]
-            
-            possible_extensions = ['.mp4', '.mkv', '.webm', '.avi', '.m4v', '.mov']
-            
-            for template in possible_templates:
-                for ext in possible_extensions:
-                    candidate = template + ext
-                    if os.path.exists(candidate) and os.path.isfile(candidate):
-                        downloaded_file = candidate
-                        logger.info(f"Found file with template {template} + {ext}: {candidate}")
-                        break
-                if downloaded_file:
-                    break
-            
-            # Method 2: Search by pattern in output directory
-            if not downloaded_file:
-                patterns = [
-                    f"youtube_{video_id}",
-                    f"video_{unique_id}",
-                    video_id,
-                    "youtube_",
-                    "video_"
-                ]
-                
-                try:
-                    files_in_dir = os.listdir(output_dir)
-                    logger.info(f"Files in directory: {files_in_dir}")
-                    
-                    for pattern in patterns:
-                        for file in files_in_dir:
-                            if (file.startswith(pattern) and 
-                                not file.endswith('.part') and 
-                                any(file.lower().endswith(ext) for ext in possible_extensions)):
-                                candidate = os.path.join(output_dir, file)
-                                if os.path.isfile(candidate):
-                                    downloaded_file = candidate
-                                    logger.info(f"Found file by pattern '{pattern}': {candidate}")
-                                    break
-                        if downloaded_file:
-                            break
-                except Exception as e:
-                    logger.warning(f"Error listing directory: {e}")
-            
-            # Method 3: Find any video file in directory (last resort)
-            if not downloaded_file:
-                logger.info("Searching for any video file in directory...")
-                try:
-                    for file in os.listdir(output_dir):
-                        if any(file.lower().endswith(ext) for ext in possible_extensions):
-                            candidate = os.path.join(output_dir, file)
-                            if os.path.isfile(candidate) and not file.endswith('.part'):
-                                downloaded_file = candidate
-                                logger.info(f"Found video file: {candidate}")
-                                break
-                except Exception as e:
-                    logger.warning(f"Error searching for video files: {e}")
-            
-            if not downloaded_file or not os.path.exists(downloaded_file):
-                logger.error(f"Downloaded file not found. Searched in: {output_dir}")
-                logger.error(f"Video ID: {video_id}")
-                logger.error(f"Unique ID: {unique_id}")
-                logger.error(f"Possible templates: {possible_templates}")
-                raise FileNotFoundError("Downloaded file not found after exhaustive search")
-            
-            logger.info(f"YouTube video downloaded: {downloaded_file}")
-            return downloaded_file
-            
-    except Exception as e:
-        logger.error(f"YouTube download failed: {str(e)}")
-        
-        # Provide more specific error messages
-        if "Video unavailable" in str(e):
-            raise ValueError("This video is unavailable or private. Please check the URL.")
-        elif "Sign in" in str(e):
-            raise ValueError("This video requires sign-in. Please use a public video.")
-        elif "copyright" in str(e).lower():
-            raise ValueError("This video has copyright restrictions and cannot be downloaded.")
-        elif "DNS" in str(e) or "resolve" in str(e):
-            raise ConnectionError("Network connection failed. Please check your internet connection.")
-        else:
-            # Clean up any partial downloads
-            try:
-                base_path = output_path.replace('.%(ext)s', '')
-                for ext in ['.mp4', '.mkv', '.webm', '.avi', '.part']:
-                    candidate = base_path + ext
-                    if os.path.exists(candidate):
-                        os.remove(candidate)
-                        logger.info(f"Cleaned up partial download: {candidate}")
-            except Exception as cleanup_error:
-                logger.warning(f"Could not clean up partial downloads: {cleanup_error}")
-            
-            raise
-
-def get_video_info(url):
-    """Get basic info about YouTube video without downloading"""
-    try:
-        import yt_dlp
-        
-        ydl_opts = {
-            'quiet': True,
-            'no_warnings': True,
-            'nocheckcertificate': True,
-            'ignoreerrors': True,
-        }
-        
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            info = ydl.extract_info(url, download=False)
-            if info is None:
-                logger.error("Could not extract video information")
-                return None
-                
-            return {
-                'title': info.get('title', 'Unknown'),
-                'duration': info.get('duration', 0),
-                'uploader': info.get('uploader', 'Unknown'),
-                'view_count': info.get('view_count', 0)
-            }
-    except Exception as e:
-        logger.error(f"Failed to get video info: {str(e)}")
-        return None