Fix

app.py

@@ -14,17 +14,12 @@ from modules.booru import create_booru_interface
 from modules.multi_comfy import create_multi_comfy
 from modules.media_handler import handle_single_media_upload, handle_multiple_media_uploads
 
-import logging
-
-logging.basicConfig(level=logging.WARNING)
-logging.getLogger("httpcore").setLevel(logging.WARNING)
-
 """ For GPU install all the requirements.txt and the following:
-pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu126
+pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu126 or any other Torch version
 pip install onnxruntime-gpu
 """
 
-""" It's recommended to create a venv:
+""" It's recommended to create a venv if you want to use it offline:
 python -m venv venv
 venv\Scripts\activate
 pip install ...
@@ -850,4 +845,4 @@ with gr.Blocks(title=TITLE, css=css, theme="Werli/Purple-Crimson-Gradio-Theme",
                 )
     gr.Markdown(NEXT_RESTART)
 
-demo.queue(max_size=5).launch(show_error=True, quiet=True, show_api=False)
+demo.queue(max_size=5).launch(show_error=True, show_api=False)

modules/video_processor.py

@@ -1,206 +1,201 @@
-import os
-import cv2
-import tempfile
-from typing import List, Tuple, Optional
-from PIL import Image
-import logging
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Supported video formats
-SUPPORTED_VIDEO_FORMATS = ['.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v']
-
-def is_video_file(file_path: str) -> bool:
-    """Check if the file is a supported video format."""
-    if not file_path:
-        return False
-    _, ext = os.path.splitext(file_path.lower())
-    return ext in SUPPORTED_VIDEO_FORMATS
-
-def get_video_duration(video_path: str) -> float:
-    """Get the duration of a video in seconds."""
-    try:
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            logger.error(f"Could not open video: {video_path}")
-            return 0.0
-        
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
-        
-        if fps <= 0:
-            logger.warning(f"Invalid FPS for video {video_path}, using fallback method")
-            # Fallback method: get duration directly
-            duration = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
-            # Seek to end to get duration
-            cap.set(cv2.CAP_PROP_POS_AVI_RATIO, 1.0)
-            duration = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
-        else:
-            duration = frame_count / fps
-            
-        cap.release()
-        return max(0.0, duration)  # Ensure non-negative duration
-        
-    except Exception as e:
-        logger.error(f"Error getting video duration for {video_path}: {str(e)}")
-        return 0.0
-
-def extract_frames_from_video(
-    video_path: str, 
-    max_duration: int = 30, 
-    frame_interval: int = 1,
-    output_dir: Optional[str] = None
-) -> List[str]:
-    """
-    Extract frames from a video at specified intervals.
-    
-    Args:
-        video_path: Path to the video file
-        max_duration: Maximum duration to process (seconds)
-        frame_interval: Interval between frames (seconds)
-        output_dir: Directory to save frames (creates temp if None)
-    
-    Returns:
-        List of paths to extracted frame images
-    """
-    if not os.path.exists(video_path):
-        logger.error(f"Video file does not exist: {video_path}")
-        return []
-    
-    if not is_video_file(video_path):
-        logger.error(f"Unsupported video format: {video_path}")
-        return []
-    
-    # Create output directory if not provided
-    if output_dir is None:
-        output_dir = tempfile.mkdtemp(prefix="video_frames_")
-    
-    try:
-        # Get video info
-        duration = get_video_duration(video_path)
-        logger.info(f"Video duration: {duration:.2f} seconds")
-        
-        # Limit duration if necessary
-        process_duration = min(duration, max_duration)
-        logger.info(f"Processing {process_duration:.2f} seconds of video")
-        
-        # Open video
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            logger.error(f"Could not open video: {video_path}")
-            return []
-        
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        if fps <= 0:
-            logger.error(f"Invalid FPS: {fps}")
-            cap.release()
-            return []
-        
-        # Calculate frame positions
-        frame_positions = []
-        current_time = 0
-        while current_time < process_duration:
-            frame_number = int(current_time * fps)
-            frame_positions.append(frame_number)
-            current_time += frame_interval
-        
-        logger.info(f"Extracting {len(frame_positions)} frames")
-        
-        # Extract frames
-        frame_paths = []
-        video_name = os.path.splitext(os.path.basename(video_path))[0]
-        
-        for i, frame_number in enumerate(frame_positions):
-            # Set position to desired frame
-            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
-            
-            ret, frame = cap.read()
-            if not ret:
-                logger.warning(f"Could not read frame {frame_number}")
-                continue
-            
-            # Convert BGR to RGB
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            
-            # Convert to PIL Image
-            pil_image = Image.fromarray(frame_rgb)
-            
-            # Save frame
-            frame_filename = f"{video_name}_frame_{i+1:03d}.png"
-            frame_path = os.path.join(output_dir, frame_filename)
-            pil_image.save(frame_path, 'PNG')
-            frame_paths.append(frame_path)
-            
-            logger.debug(f"Saved frame {i+1}/{len(frame_positions)}: {frame_filename}")
-        
-        cap.release()
-        logger.info(f"Successfully extracted {len(frame_paths)} frames from {video_path}")
-        return frame_paths
-        
-    except Exception as e:
-        logger.error(f"Error extracting frames from {video_path}: {str(e)}")
-        return []
-
-def process_video_upload(video_path: str, max_duration: int = 30, frame_interval: int = 1) -> Tuple[List[str], str]:
-    """
-    Process a video upload and extract frames.
-    
-    Args:
-        video_path: Path to the uploaded video
-        max_duration: Maximum duration to process (seconds)
-        frame_interval: Interval between frames (seconds)
-    
-    Returns:
-        Tuple of (list of frame paths, output directory)
-    """
-    # Create temporary directory for frames
-    output_dir = tempfile.mkdtemp(prefix="video_frames_")
-    
-    # Extract frames
-    frame_paths = extract_frames_from_video(
-        video_path, 
-        max_duration, 
-        frame_interval, 
-        output_dir
-    )
-    
-    return frame_paths, output_dir
-
-def get_video_info(video_path: str) -> dict:
-    """Get detailed information about a video file."""
-    try:
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return {"error": "Could not open video"}
-        
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
-        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        duration = frame_count / fps if fps > 0 else 0
-        
-        cap.release()
-        
-        return {
-            "duration": duration,
-            "fps": fps,
-            "frame_count": frame_count,
-            "width": width,
-            "height": height,
-            "resolution": f"{width}x{height}"
-        }
-        
-    except Exception as e:
-        return {"error": str(e)}
-
-# Export functions
-__all__ = [
-    'is_video_file',
-    'get_video_duration', 
-    'extract_frames_from_video',
-    'process_video_upload',
-    'get_video_info',
-    'SUPPORTED_VIDEO_FORMATS'
-]
+import os
+import cv2
+import tempfile
+from typing import List, Tuple, Optional
+from PIL import Image
+
+# Supported video formats
+SUPPORTED_VIDEO_FORMATS = ['.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v']
+
+def is_video_file(file_path: str) -> bool:
+    """Check if the file is a supported video format."""
+    if not file_path:
+        return False
+    _, ext = os.path.splitext(file_path.lower())
+    return ext in SUPPORTED_VIDEO_FORMATS
+
+def get_video_duration(video_path: str) -> float:
+    """Get the duration of a video in seconds."""
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            print(f"Could not open video: {video_path}")
+            return 0.0
+        
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        
+        if fps <= 0:
+            print(f"Invalid FPS for video {video_path}, using fallback method")
+            # Fallback method: get duration directly
+            duration = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
+            # Seek to end to get duration
+            cap.set(cv2.CAP_PROP_POS_AVI_RATIO, 1.0)
+            duration = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
+        else:
+            duration = frame_count / fps
+            
+        cap.release()
+        return max(0.0, duration)  # Ensure non-negative duration
+        
+    except Exception as e:
+        print(f"Error getting video duration for {video_path}: {str(e)}")
+        return 0.0
+
+def extract_frames_from_video(
+    video_path: str, 
+    max_duration: int = 30, 
+    frame_interval: int = 1,
+    output_dir: Optional[str] = None
+) -> List[str]:
+    """
+    Extract frames from a video at specified intervals.
+    
+    Args:
+        video_path: Path to the video file
+        max_duration: Maximum duration to process (seconds)
+        frame_interval: Interval between frames (seconds)
+        output_dir: Directory to save frames (creates temp if None)
+    
+    Returns:
+        List of paths to extracted frame images
+    """
+    if not os.path.exists(video_path):
+        print(f"Video file does not exist: {video_path}")
+        return []
+    
+    if not is_video_file(video_path):
+        print(f"Unsupported video format: {video_path}")
+        return []
+    
+    # Create output directory if not provided
+    if output_dir is None:
+        output_dir = tempfile.mkdtemp(prefix="video_frames_")
+    
+    try:
+        # Get video info
+        duration = get_video_duration(video_path)
+        print(f"Video duration: {duration:.2f} seconds")
+        
+        # Limit duration if necessary
+        process_duration = min(duration, max_duration)
+        print(f"Processing {process_duration:.2f} seconds of video")
+        
+        # Open video
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            print(f"Could not open video: {video_path}")
+            return []
+        
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        if fps <= 0:
+            print(f"Invalid FPS: {fps}")
+            cap.release()
+            return []
+        
+        # Calculate frame positions
+        frame_positions = []
+        current_time = 0
+        while current_time < process_duration:
+            frame_number = int(current_time * fps)
+            frame_positions.append(frame_number)
+            current_time += frame_interval
+        
+        print(f"Extracting {len(frame_positions)} frames")
+        
+        # Extract frames
+        frame_paths = []
+        video_name = os.path.splitext(os.path.basename(video_path))[0]
+        
+        for i, frame_number in enumerate(frame_positions):
+            # Set position to desired frame
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+            
+            ret, frame = cap.read()
+            if not ret:
+                print(f"Could not read frame {frame_number}")
+                continue
+            
+            # Convert BGR to RGB
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            
+            # Convert to PIL Image
+            pil_image = Image.fromarray(frame_rgb)
+            
+            # Save frame
+            frame_filename = f"{video_name}_frame_{i+1:03d}.png"
+            frame_path = os.path.join(output_dir, frame_filename)
+            pil_image.save(frame_path, 'PNG')
+            frame_paths.append(frame_path)
+            
+            print(f"Saved frame {i+1}/{len(frame_positions)}: {frame_filename}")
+        
+        cap.release()
+        print(f"Successfully extracted {len(frame_paths)} frames from {video_path}")
+        return frame_paths
+        
+    except Exception as e:
+        print(f"Error extracting frames from {video_path}: {str(e)}")
+        return []
+
+def process_video_upload(video_path: str, max_duration: int = 30, frame_interval: int = 1) -> Tuple[List[str], str]:
+    """
+    Process a video upload and extract frames.
+    
+    Args:
+        video_path: Path to the uploaded video
+        max_duration: Maximum duration to process (seconds)
+        frame_interval: Interval between frames (seconds)
+    
+    Returns:
+        Tuple of (list of frame paths, output directory)
+    """
+    # Create temporary directory for frames
+    output_dir = tempfile.mkdtemp(prefix="video_frames_")
+    
+    # Extract frames
+    frame_paths = extract_frames_from_video(
+        video_path, 
+        max_duration, 
+        frame_interval, 
+        output_dir
+    )
+    
+    return frame_paths, output_dir
+
+def get_video_info(video_path: str) -> dict:
+    """Get detailed information about a video file."""
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            return {"error": "Could not open video"}
+        
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        duration = frame_count / fps if fps > 0 else 0
+        
+        cap.release()
+        
+        return {
+            "duration": duration,
+            "fps": fps,
+            "frame_count": frame_count,
+            "width": width,
+            "height": height,
+            "resolution": f"{width}x{height}"
+        }
+        
+    except Exception as e:
+        return {"error": str(e)}
+
+# Export functions
+__all__ = [
+    'is_video_file',
+    'get_video_duration', 
+    'extract_frames_from_video',
+    'process_video_upload',
+    'get_video_info',
+    'SUPPORTED_VIDEO_FORMATS'
+]