endoreg-db 0.8.9.2__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/utils/file_operations.py

@@ -1,34 +1,46 @@
-import shutil
-from pathlib import Path
-from endoreg_db.utils.uuid import get_uuid
+import hashlib
 import os
+from pathlib import Path
 
-def get_uuid_filename(file:Path) -> tuple[str, str]:
+
+def get_content_hash_filename(file: Path) -> tuple[str, str]:
     """
-    Returns a new filename with a uuid
+    Returns a new filename with a uuid - This is the content hash -
+    it is used to identify a raw video before processing when no other
+    reliable info exists.
+    It gets stored in processing_history model.
     """
     # Get the file extension
     file_extension = file.suffix
     # Generate a new file name
-    uuid = get_uuid()
+    uuid = sha256_file(file)
     new_file_name = f"{uuid}{file_extension}"
     return new_file_name, uuid
-    
-def rename_file_uuid(old_file:Path):
+
+
+def sha256_file(path: Path, chunk_size: int = 1024 * 1024) -> str:
     """
-    Rename a file by assigning a uuid while preserving file extension. Returns new filepath and uuid
+    Compute a SHA-256 hash of the file contents in a streaming manner.
+
+    Args:
+        path: Path to the file on disk.
+        chunk_size: Size of the chunks to read (default: 1MB).
+
+    Returns:
+        Hexadecimal SHA-256 digest (64 characters).
     """
-    # Get the file extension
-    file_extension = old_file.suffix
-    # Generate a new file name
-    uuid = get_uuid()
-    new_file_name = f"{uuid}{file_extension}"
+    h = hashlib.sha256()
+    path_obj = Path(path)
+
+    with path_obj.open("rb") as f:
+        while True:
+            chunk = f.read(chunk_size)
+            if not chunk:
+                break
+            h.update(chunk)
 
-    # Rename the file
-    new_file = old_file.with_name(new_file_name)
-    shutil.move(old_file.as_posix(), new_file.as_posix())
+    return h.hexdigest()
 
-    return new_file, uuid
 
 def copy_with_progress(src: str, dst: str, buffer_size=1024 * 1024):
     """

endoreg_db/utils/fix_video_path_direct.py

@@ -8,54 +8,57 @@ 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 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]
+                if "_" in filename:
+                    uuid_part = filename.split("_")[0]
                 else:
-                    uuid_part = filename.split('.')[0]
-                
+                    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)
+                    "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%'")
+        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']:
+        for table in ["endoreg_db_videofile", "videofile", "video_file"]:
             try:
                 cursor.execute(f"SELECT COUNT(*) FROM {table}")
                 count = cursor.fetchone()[0]
@@ -65,24 +68,24 @@ def fix_video_paths_direct(db_path, storage_dir):
                     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("\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
@@ -90,30 +93,32 @@ def fix_video_paths_direct(db_path, storage_dir):
             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("\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:")
+
+            if current_raw_file != file_info["relative_path"]:
+                print("\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))
+                    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")
@@ -125,17 +130,28 @@ def fix_video_paths_direct(db_path, storage_dir):
             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)')
+    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)
+    fix_video_paths_direct(args.db_path, args.storage_dir)