endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/utils/extract_specific_frames.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+import shutil
+
+def extract_selected_frames(
+    video_path: Path,
+    frame_numbers: list,
+    output_dir: Path,
+    fps: int = 50,
+    quality: int = 2,
+    ext: str = "png"
+):
+    """
+    Extract specific frames from a video using the same quality logic as the original extractor.
+
+    This will:
+    - Convert frame numbers to timestamps using the provided FPS.
+    - Overwrite any existing frames for a clean run.
+    - Save frames with consistent formatting (zero-padded).
+
+    Args:
+        video_path (Path): Path to the input video.
+        frame_numbers (list): List of frame numbers to extract.
+        output_dir (Path): Where to save the frames.
+        fps (int): Frames per second of the video.
+        quality (int): Quality setting (2 is default).
+        ext (str): File extension for output (e.g., 'png/jpg').
+    """
+    # Optional: Clean up old frames before extraction
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for frame_number in frame_numbers:
+        # Convert frame number to timestamp in seconds
+        timestamp_sec = frame_number / fps
+
+        # Build output filename
+        output_file = output_dir / f"frame_{str(frame_number).zfill(7)}.{ext}"
+
+        # Extract and save the frame
+        extract_single_frame(
+            input_path=str(video_path),
+            timestamp=timestamp_sec,
+            output_path=str(output_file),
+            quality=quality,
+            ext=ext
+        )
+import subprocess
+from pathlib import Path
+
+def extract_single_frame(input_path: str, timestamp: float, output_path: str, quality: int = 2, ext: str = "png"):
+    """
+    Extract a single frame from a video using ffmpeg.
+
+    Args:
+        input_path (str): Path to the video file.
+        timestamp (float): Time in seconds to extract the frame.
+        output_path (str): Where to save the extracted frame.
+        quality (int): pnj quality (2 = high, 31 = low).
+        ext (str): File extension (e.g., 'jpg').
+    """
+    cmd = [
+        "ffmpeg",
+        "-loglevel", "error",
+        "-ss", f"{timestamp:.3f}",
+        "-i", str(input_path),
+        "-frames:v", "1",
+        "-q:v", str(quality),
+        str(output_path)
+    ]
+
+    subprocess.run(cmd, check=True)

endoreg_db/utils/file_operations.py

@@ -0,0 +1,58 @@
+import shutil
+from pathlib import Path
+from endoreg_db.utils.uuid import get_uuid
+import os
+
+def get_uuid_filename(file:Path) -> tuple[str, str]:
+    """
+    Returns a new filename with a uuid
+    """
+    # Get the file extension
+    file_extension = file.suffix
+    # Generate a new file name
+    uuid = get_uuid()
+    new_file_name = f"{uuid}{file_extension}"
+    return new_file_name, uuid
+    
+def rename_file_uuid(old_file:Path):
+    """
+    Rename a file by assigning a uuid while preserving file extension. Returns new filepath and uuid
+    """
+    # Get the file extension
+    file_extension = old_file.suffix
+    # Generate a new file name
+    uuid = get_uuid()
+    new_file_name = f"{uuid}{file_extension}"
+
+    # Rename the file
+    new_file = old_file.with_name(new_file_name)
+    shutil.move(old_file.as_posix(), new_file.as_posix())
+
+    return new_file, uuid
+
+def copy_with_progress(src: str, dst: str, buffer_size=1024 * 1024):
+    """
+    Make a copy of a file with progress bar.
+
+    Args:
+        src (str): Source file path.
+        dst (str): Destination file path.
+        buffer_size (int): Buffer size for copying.
+    """
+    # Ensure the destination directory exists
+    os.makedirs(os.path.dirname(dst), exist_ok=True)
+    total_size = os.path.getsize(src)
+    copied_size = 0
+
+    with open(src, "rb") as fsrc, open(dst, "wb") as fdst:
+        while True:
+            buf = fsrc.read(buffer_size)
+            if not buf:
+                break
+            fdst.write(buf)
+            copied_size += len(buf)
+            progress = copied_size / total_size * 100
+            print(f"\rProgress: {progress:.2f}%", end="")
+
+    # Print newline once copying is finished so the next log starts on a new line
+    print()

endoreg_db/utils/fix_video_path_direct.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+Direct fix for video file path issues without complex Django setup.
+"""
+
+import sqlite3
+from pathlib import Path
+import os
+import argparse
+
+def fix_video_paths_direct(db_path, storage_dir):
+    """Fix video file paths directly in SQLite database."""
+    
+    db_path = Path(db_path)
+    storage_dir = Path(storage_dir)
+    
+    print("🔧 DIRECT VIDEO PATH FIX")
+    print("=" * 40)
+    
+    if not db_path.exists():
+        print(f"❌ Database not found at {db_path}")
+        return
+    
+    # Find actual video files
+    print("1. Scanning for video files...")
+    actual_files = {}
+    for pattern in ['**/*.mp4', '**/*.avi', '**/*.mov', '**/*.mkv']:
+        for file_path in storage_dir.glob(pattern):
+            if file_path.is_file() and file_path.stat().st_size > 0:
+                filename = file_path.name
+                if '_' in filename:
+                    uuid_part = filename.split('_')[0]
+                else:
+                    uuid_part = filename.split('.')[0]
+                
+                relative_path = file_path.relative_to(storage_dir)
+                actual_files[uuid_part] = {
+                    'absolute_path': str(file_path),
+                    'relative_path': str(relative_path),
+                    'size_mb': file_path.stat().st_size / (1024*1024)
+                }
+    
+    print(f"Found {len(actual_files)} video files")
+    
+    # Connect to database and check video records
+    print("\n2. Checking database records...")
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # Find video file table (might be different names)
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE '%video%'")
+        tables = cursor.fetchall()
+        print(f"Found video tables: {[t[0] for t in tables]}")
+        
+        # Check for VideoFile records
+        video_table = None
+        for table in ['endoreg_db_videofile', 'videofile', 'video_file']:
+            try:
+                cursor.execute(f"SELECT COUNT(*) FROM {table}")
+                count = cursor.fetchone()[0]
+                if count > 0:
+                    video_table = table
+                    print(f"Using table: {table} ({count} records)")
+                    break
+            except sqlite3.OperationalError:
+                continue
+        
+        if not video_table:
+            print("❌ No video table found in database")
+            return
+        
+        # Get video record 5
+        cursor.execute(f"SELECT id, uuid, raw_file FROM {video_table} WHERE id = 5")
+        record = cursor.fetchone()
+        
+        if not record:
+            print("❌ Video ID 5 not found in database")
+            return
+        
+        video_id, uuid_str, current_raw_file = record
+        print(f"\n3. Video ID 5 details:")
+        print(f"   UUID: {uuid_str}")
+        print(f"   Current raw_file: {current_raw_file}")
+        
+        # Check if current file exists
+        if current_raw_file:
+            current_full_path = storage_dir / current_raw_file
+            file_exists = current_full_path.exists()
+            print(f"   File exists: {file_exists}")
+            if not file_exists:
+                print(f"   Full path checked: {current_full_path}")
+        
+        # Find matching file
+        if uuid_str in actual_files:
+            file_info = actual_files[uuid_str]
+            print(f"\n4. Found matching file:")
+            print(f"   Path: {file_info['absolute_path']}")
+            print(f"   Size: {file_info['size_mb']:.1f} MB")
+            print(f"   Relative path: {file_info['relative_path']}")
+            
+            if current_raw_file != file_info['relative_path']:
+                print(f"\n5. 🔧 FIXING PATH:")
+                print(f"   FROM: {current_raw_file}")
+                print(f"   TO:   {file_info['relative_path']}")
+                
+                # Update the database with transaction safety
+                try:
+                    cursor.execute(f"UPDATE {video_table} SET raw_file = ? WHERE id = ?", 
+                                   (file_info['relative_path'], video_id))
+                    conn.commit()
+                    print("✅ Database updated successfully!")
+                except Exception as e:
+                    conn.rollback()
+                    print(f"❌ Failed to update database: {e}")
+                
+                print("\n6. 🎯 NEXT STEPS:")
+                print("   1. Restart your Django development server")
+                print("   2. Test video streaming in the frontend")
+                print("   3. Check browser developer tools for any remaining errors")
+            else:
+                print("\n✅ Path is already correct in database")
+        else:
+            print(f"\n❌ No matching file found for UUID {uuid_str}")
+            print("Available UUIDs in storage:")
+            for uuid_key in list(actual_files.keys())[:5]:
+                print(f"   - {uuid_key}")
+        
+        conn.close()
+        
+    except Exception as e:
+        print(f"❌ Database error: {e}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Direct fix for video file path issues in SQLite DB.")
+    parser.add_argument('--db-path', type=str, default=os.environ.get('ENDOREG_DB_PATH', './db.sqlite3'),
+                        help='Path to the SQLite database file (default: ./db.sqlite3 or $ENDOREG_DB_PATH)')
+    parser.add_argument('--storage-dir', type=str, default=os.environ.get('ENDOREG_STORAGE_DIR', './storage'),
+                        help='Path to the storage directory (default: ./storage or $ENDOREG_STORAGE_DIR)')
+    args = parser.parse_args()
+    fix_video_paths_direct(args.db_path, args.storage_dir)