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

endoreg_db/utils/permissions.py

@@ -7,7 +7,8 @@ the DEBUG setting and other environment configurations.
 
 from django.conf import settings
 from rest_framework.permissions import IsAuthenticated, AllowAny, BasePermission
-#from rest_framework.decorators import permission_classes as drf_permission_classes
+
+# from rest_framework.decorators import permission_classes as drf_permission_classes
 from functools import wraps
 import logging
 import os
@@ -18,20 +19,20 @@ logger = logging.getLogger(__name__)
 class DynamicAuthPermission:
     """
     Permission class that adapts based on environment settings.
-    
+
     - In DEBUG mode: Allows access without authentication
     - In production (DEBUG=False): Requires authentication
     """
-    
+
     @staticmethod
     def get_permission_classes():
         """
         Returns appropriate permission classes based on current settings.
-        
+
         Returns:
             list: Permission classes to use
         """
-        if getattr(settings, 'DEBUG', False):
+        if getattr(settings, "DEBUG", False):
             logger.info("DEBUG mode detected - allowing unauthenticated access")
             return [AllowAny]
         else:
@@ -42,19 +43,23 @@ class DynamicAuthPermission:
 def dynamic_permission_classes(force_auth=None):
     """
     Decorator that applies permission classes based on environment settings.
-    
+
     Args:
-        force_auth (bool, optional): 
+        force_auth (bool, optional):
             - True: Always require authentication regardless of DEBUG
-            - False: Always allow access regardless of DEBUG  
+            - False: Always allow access regardless of DEBUG
             - None: Use environment-based logic (default)
     """
+
     def decorator(view_func):
-        from rest_framework.decorators import permission_classes as drf_permission_classes
+        from rest_framework.decorators import (
+            permission_classes as drf_permission_classes,
+        )
+
         @wraps(view_func)
         def wrapper(*args, **kwargs):
             return view_func(*args, **kwargs)
-        
+
         # Determine permission classes
         if force_auth is True:
             permission_cls = [IsAuthenticated]
@@ -64,22 +69,24 @@ def dynamic_permission_classes(force_auth=None):
             logger.info(f"View {view_func.__name__} - forced public access")
         else:
             permission_cls = DynamicAuthPermission.get_permission_classes()
-            logger.info(f"View {view_func.__name__} - dynamic permissions: {permission_cls}")
-        
+            logger.info(
+                f"View {view_func.__name__} - dynamic permissions: {permission_cls}"
+            )
+
         # Apply the permission classes decorator
         return drf_permission_classes(permission_cls)(wrapper)
-    
+
     return decorator
 
 
 def get_auth_required():
     """
     Simple function to check if authentication is required in current environment.
-    
+
     Returns:
         bool: True if authentication is required, False otherwise
     """
-    return not getattr(settings, 'DEBUG', False)
+    return not getattr(settings, "DEBUG", False)
 
 
 def is_debug_mode():
@@ -89,17 +96,22 @@ def is_debug_mode():
     """
     truthy = {"1", "true", "yes", "on"}
     env_debug = str(os.environ.get("DJANGO_DEBUG", "false")).lower() in truthy
-    settings_debug = bool(getattr(settings, 'DEBUG', False))
+    settings_debug = bool(getattr(settings, "DEBUG", False))
     pytest_active = "PYTEST_CURRENT_TEST" in os.environ
     result = settings_debug or env_debug or pytest_active
-    logger.info(f"is_debug_mode: env={env_debug}, settings={settings_debug}, pytest={pytest_active}, result={result}")
+    logger.info(
+        f"is_debug_mode: env={env_debug}, settings={settings_debug}, pytest={pytest_active}, result={result}"
+    )
     return result
 
+
 # Compute default permission classes each call to avoid stale values during tests
 
+
 def get_debug_permissions():
     return [AllowAny] if is_debug_mode() else [IsAuthenticated]
 
+
 # Export a name for convenience, but prefer calling get_debug_permissions() in views
 DEBUG_PERMISSIONS = get_debug_permissions()
 ALWAYS_AUTH_PERMISSIONS = [IsAuthenticated]
@@ -117,15 +129,15 @@ class EnvironmentAwarePermission(BasePermission):
     Custom permission class that can be used directly in DRF views.
     Honors both Django settings.DEBUG and DJANGO_DEBUG env var.
     """
-    
+
     def has_permission(self, request, view):
         """
         Check if the request has permission.
-        
+
         Args:
             request: The Django request object
             view: The DRF view
-            
+
         Returns:
             bool: True if permission granted, False otherwise
         """
@@ -133,12 +145,16 @@ class EnvironmentAwarePermission(BasePermission):
             logger.debug(f"DEBUG mode - granting access to {view.__class__.__name__}")
             return True
         # In production, require authentication
-        is_authenticated = bool(getattr(request, 'user', None) and request.user.is_authenticated)
-        logger.debug(f"Production mode - authentication check for {view.__class__.__name__}: {is_authenticated}")
+        is_authenticated = bool(
+            getattr(request, "user", None) and request.user.is_authenticated
+        )
+        logger.debug(
+            f"Production mode - authentication check for {view.__class__.__name__}: {is_authenticated}"
+        )
         return is_authenticated
-    
+
     def has_object_permission(self, request, view, obj):
         """
         Object-level permission check.
         """
-        return self.has_permission(request, view)
+        return self.has_permission(request, view)

endoreg_db/utils/pipelines/process_video_dir.py

@@ -1,14 +1,16 @@
-from endoreg_db.models import (
-    VideoFile, Center, EndoscopyProcessor, AiModel, ModelMeta,
-    LabelVideoSegment, SensitiveMeta
-)
+import logging
+import os
 from pathlib import Path
+from django.core.management import call_command
 from icecream import ic
 from tqdm import tqdm
-import os
-from django.core.management import call_command
-import logging
-from django.core.exceptions import ObjectDoesNotExist
+from endoreg_db.utils.file_operations import sha256_file
+from endoreg_db.models import (
+    AiModel,
+    LabelVideoSegment,
+    ModelMeta,
+    VideoFile,
+)
 
 logger = logging.getLogger(__name__)
 # Usage
@@ -24,11 +26,14 @@ MODEL_WEIGHTS_PATH = "./tests/assets/colo_segmentation_RegNetX800MF_6.safetensor
 ic(DEFAULT_DIR)
 
 
-
-def process_video_dir(video_dir: Path=DEFAULT_DIR, center_name: str = CENTER_NAME, endoscopy_processor_name: str = ENDOSCOPY_PROCESSOR_NAME):
+def process_video_dir(
+    video_dir: Path = DEFAULT_DIR,
+    center_name: str = CENTER_NAME,
+    endoscopy_processor_name: str = ENDOSCOPY_PROCESSOR_NAME,
+):
     """
     Process a directory of video files and create VideoFile objects in the database.
-    
+
     Args:
         video_dir (Path): Path to the directory containing video files.
         center_name (str): Name of the center to associate with the video files.
@@ -50,28 +55,32 @@ def process_video_dir(video_dir: Path=DEFAULT_DIR, center_name: str = CENTER_NAM
             MODEL_WEIGHTS_PATH,
         )
 
-
-
     # Get the center and endoscopy processor objects
 
     # Iterate through all files in the directory
     for file_path in tqdm(video_dir.iterdir()):
         logger.info(f"Processing file: {file_path}")
-        if file_path.is_file() and file_path.suffix in ['.mp4', '.avi', '.mov']:
+        if file_path.is_file() and file_path.suffix in [".mp4", ".avi", ".mov"]:
             # Create a VideoFile object
             video_file = VideoFile.create_from_file_initialized(
                 file_path=file_path,
                 center_name=center_name,
                 processor_name=endoscopy_processor_name,
+                video_hash=sha256_file(file_path),
             )
             logger.warning(f"Processing video file: {video_file}")
             try:
                 success_pipe_1 = video_file.pipe_1(
-                    model_name = MODEL_NAME,
+                    model_name=MODEL_NAME,
+                )
+                assert success_pipe_1, (
+                    f"Pipe 1 failed for video {video_file.video_hash}"
                 )
-                assert success_pipe_1, f"Pipe 1 failed for video {video_file.uuid}"
             except Exception as e:
-                logger.error(f"Pipe 1 failed for video {video_file.uuid}: {e}", exc_info=True)
+                logger.error(
+                    f"Pipe 1 failed for video {video_file.video_hash}: {e}",
+                    exc_info=True,
+                )
                 raise e
 
             video_file.refresh_from_db()
@@ -88,10 +97,14 @@ def process_video_dir(video_dir: Path=DEFAULT_DIR, center_name: str = CENTER_NAM
                         seg_state.save()
                         logger.info(f"Simulated validation for segment {segment.id}")
                     except LabelVideoSegment.state.RelatedObjectDoesNotExist:
-                        logger.warning(f"Cannot simulate validation for segment {segment.id}: Related state object does not exist.")
+                        logger.warning(
+                            f"Cannot simulate validation for segment {segment.id}: Related state object does not exist."
+                        )
                     except Exception as e:
-                        logger.error(f"Error during segment state simulation for segment {segment.id}: {e}", exc_info=True)
-
+                        logger.error(
+                            f"Error during segment state simulation for segment {segment.id}: {e}",
+                            exc_info=True,
+                        )
 
             # Simulate the validation process for the video files sensitive meta obj
             if video_file.sensitive_meta:
@@ -100,12 +113,19 @@ def process_video_dir(video_dir: Path=DEFAULT_DIR, center_name: str = CENTER_NAM
                     sm_state.dob_verified = True
                     sm_state.names_verified = True
                     sm_state.save()
-                    logger.info(f"Simulated validation for sensitive meta of video {video_file.uuid}")
+                    logger.info(
+                        f"Simulated validation for sensitive meta of video {video_file.video_hash}"
+                    )
                 except Exception as e:
-                    logger.error(f"Error during sensitive meta state simulation for video {video_file.uuid}: {e}", exc_info=True)
+                    logger.error(
+                        f"Error during sensitive meta state simulation for video {video_file.video_hash}: {e}",
+                        exc_info=True,
+                    )
 
             else:
-                logger.warning(f"Cannot simulate validation for sensitive meta of video {video_file.uuid}: SensitiveMeta object does not exist (likely due to pipe_1 failure or incomplete text extraction).")
+                logger.warning(
+                    f"Cannot simulate validation for sensitive meta of video {video_file.video_hash}: SensitiveMeta object does not exist (likely due to pipe_1 failure or incomplete text extraction)."
+                )
 
             ######## SIMULATION OF VALIDATION ########
 
@@ -114,7 +134,11 @@ def process_video_dir(video_dir: Path=DEFAULT_DIR, center_name: str = CENTER_NAM
                 try:
                     video_file.pipe_2()
                 except Exception as e:
-                    logger.error(f"Pipe 2 failed for video {video_file.uuid}: {e}", exc_info=True)
+                    logger.error(
+                        f"Pipe 2 failed for video {video_file.video_hash}: {e}",
+                        exc_info=True,
+                    )
             else:
-                logger.warning(f"Skipping Pipe 2 for video {video_file.uuid} because Pipe 1 did not complete successfully.")
-
+                logger.warning(
+                    f"Skipping Pipe 2 for video {video_file.video_hash} because Pipe 1 did not complete successfully."
+                )

endoreg_db/utils/product/sum_emissions.py

@@ -4,7 +4,7 @@ from endoreg_db.models.administration.product.product_material import ProductMat
 from typing import List
 
 
-def sum_emissions(product_materials:List["ProductMaterial"]):
+def sum_emissions(product_materials: List["ProductMaterial"]):
     # sum up the emissions
     emission = 0
     reference_unit = None
@@ -12,9 +12,11 @@ def sum_emissions(product_materials:List["ProductMaterial"]):
         if not reference_unit:
             reference_unit = product_material.unit
         else:
-            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
+            assert reference_unit == product_material.unit, (
+                "ProductMaterial units do not match"
+            )
         em_value, emission_unit = product_material.get_emission()
         assert reference_unit == emission_unit, "ProductMaterial units do not match"
         emission += em_value
 
-    return emission, reference_unit
+    return emission, reference_unit

endoreg_db/utils/product/sum_weights.py

@@ -12,7 +12,9 @@ def sum_weights(product_materials: List["ProductMaterial"]):
         if not reference_unit:
             reference_unit = product_material.unit
         else:
-            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
+            assert reference_unit == product_material.unit, (
+                "ProductMaterial units do not match"
+            )
         weight += product_material.quantity
 
-    return weight, reference_unit
+    return weight, reference_unit

endoreg_db/utils/pydantic_models/__init__.py

@@ -1,6 +1,5 @@
-'''Module for Pydantic models.'''
+"""Module for Pydantic models."""
+
 from .db_config import DbConfig
 
-__all__ = [
-    'DbConfig'
-]
+__all__ = ["DbConfig"]