endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/models/media/pdf/report_reader/report_reader_config.py

@@ -1,30 +1,14 @@
 # ReportReaderConfig Class
-# Description: This class is used to store the configuration of the ReportReader
-
-# PATIENT_INFO_LINE_FLAG = "Patient: "
-# ENDOSCOPE_INFO_LINE_FLAG = "Gerät: "
-# EXAMINER_INFO_LINE_FLAG = "1. Unters.:"
-# CUT_OFF_BELOW_LINE_FLAG = "________________"
-
-
-# CUT_OFF_ABOVE_LINE_FLAGS = [
-#     ENDOSCOPE_INFO_LINE_FLAG,
-#     EXAMINER_INFO_LINE_FLAG,
-# ]
-
-# CUT_OFF_BELOW_LINE_FLAGS = [
-#         CUT_OFF_BELOW_LINE_FLAG
-#     ]
+from typing import TYPE_CHECKING, cast
 
 from django.db import models
 
-
-from typing import TYPE_CHECKING
 if TYPE_CHECKING:
-    from .report_reader_flag import ReportReaderFlag
-    from ....administration.person import FirstName, LastName
     from ....administration.center import Center
+    from ....administration.person import FirstName, LastName
     from ....metadata import PdfType
+    from .report_reader_flag import ReportReaderFlag
+
 
 class ReportReaderConfig(models.Model):
     """
@@ -33,45 +17,45 @@ class ReportReaderConfig(models.Model):
     Stores locale, name lists, date format, and flags used to identify key information lines
     and text sections to ignore.
     """
+
     locale = models.CharField(default="de_DE", max_length=10)
-    first_names = models.ManyToManyField('FirstName', related_name='report_reader_configs')
-    last_names = models.ManyToManyField('LastName', related_name='report_reader_configs')
-    text_date_format = models.CharField(default = "%d.%m.%Y", max_length=10)
-    patient_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name='report_reader_configs_patient_info_line', on_delete=models.CASCADE)
-    endoscope_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name='report_reader_configs_endoscope_info_line', on_delete=models.CASCADE)
-    examiner_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name='report_reader_configs_examiner_info_line', on_delete=models.CASCADE)
-    cut_off_below = models.ManyToManyField("ReportReaderFlag", related_name='report_reader_configs_cut_off_below')
-    cut_off_above = models.ManyToManyField("ReportReaderFlag", related_name='report_reader_configs_cut_off_above')
-    
+    first_names = models.ManyToManyField("FirstName", related_name="report_reader_configs")
+    last_names = models.ManyToManyField("LastName", related_name="report_reader_configs")
+    text_date_format = models.CharField(default="%d.%m.%Y", max_length=10)
+    patient_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name="report_reader_configs_patient_info_line", on_delete=models.CASCADE)
+    endoscope_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name="report_reader_configs_endoscope_info_line", on_delete=models.CASCADE)
+    examiner_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name="report_reader_configs_examiner_info_line", on_delete=models.CASCADE)
+    cut_off_below = models.ManyToManyField("ReportReaderFlag", related_name="report_reader_configs_cut_off_below")
+    cut_off_above = models.ManyToManyField("ReportReaderFlag", related_name="report_reader_configs_cut_off_above")
+
     if TYPE_CHECKING:
-        first_names: models.QuerySet["FirstName"]
-        last_names: models.QuerySet["LastName"]
-        patient_info_line_flag: "ReportReaderFlag"
-        endoscope_info_line_flag: "ReportReaderFlag"
-        examiner_info_line_flag: "ReportReaderFlag"
-        cut_off_below: models.QuerySet["ReportReaderFlag"]
-        cut_off_above: models.QuerySet["ReportReaderFlag"]
-    
+        patient_info_line_flag = models.ForeignKey["ReportReaderFlag"]
+        endoscope_info_line_flag = models.ForeignKey["ReportReaderFlag"]
+        examiner_info_line_flag = models.ForeignKey["ReportReaderFlag"]
+
+        first_names = cast(models.manager.RelatedManager["FirstName"], first_names)
+        last_names = cast(models.manager.RelatedManager["LastName"], last_names)
+        cut_off_below = cast(models.manager.RelatedManager["ReportReaderFlag"], cut_off_below)
+        cut_off_above = cast(models.manager.RelatedManager["ReportReaderFlag"], cut_off_above)
 
     def __str__(self):
         """Returns a string representation including the locale and primary key."""
         _str = f"ReportReaderConfig: {self.locale} (id: {self.pk}\n"
         return _str
-    
-    def update_names_by_center(self, center:"Center", save = True):
+
+    def update_names_by_center(self, center: "Center", save=True):
         """Updates the first and last name lists based on the names associated with a Center."""
         self.first_names.set(center.first_names.all())
         self.last_names.set(center.last_names.all())
         if save:
             self.save()
 
-    def update_flags_by_pdf_type(self, pdf_type:"PdfType", save = True):
+    def update_flags_by_pdf_type(self, pdf_type: "PdfType", save=True):
         """Updates the line identification flags based on a specific PdfType."""
-        self.patient_info_line_flag = pdf_type.patient_info_line_flag
-        self.endoscope_info_line_flag = pdf_type.endoscope_info_line_flag
-        self.examiner_info_line_flag = pdf_type.examiner_info_line_flag
-        self.cut_off_below.set(pdf_type.cut_off_below.all())
-        self.cut_off_above.set(pdf_type.cut_off_above.all())
+        self.patient_info_line_flag = pdf_type.patient_info_line
+        self.endoscope_info_line_flag = pdf_type.endoscope_info_line
+        self.examiner_info_line_flag = pdf_type.examiner_info_line
+        self.cut_off_below.set(pdf_type.cut_off_below_lines.all())
+        self.cut_off_above.set(pdf_type.cut_off_above_lines.all())
         if save:
             self.save()
-

endoreg_db/models/media/pdf/report_reader/report_reader_flag.py

@@ -1,20 +1,36 @@
-# Django model for the report reader flag
-# have name and value
-# name is natural key
+from typing import TYPE_CHECKING
 
 from django.db import models
 
+if TYPE_CHECKING:
+    from endoreg_db.models import ReportReaderConfig
+
+
 class ReportReaderFlagManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class ReportReaderFlag(models.Model):
     objects = ReportReaderFlagManager()
     name = models.CharField(max_length=255, unique=True)
     value = models.CharField(max_length=255)
-    
+
+    if TYPE_CHECKING:
+
+        @property
+        def report_reader_configs_patient_info_line(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_endoscope_info_line(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_examiner_info_line(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_cut_off_below(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_cut_off_above(self) -> models.QuerySet["ReportReaderConfig"]: ...
+
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
-        return self.name
+        return self.name

endoreg_db/models/media/video/__init__.py

@@ -1,6 +1,7 @@
 from .video_file import VideoFile
 from .video_metadata import VideoMetadata
 from .video_processing import VideoProcessingHistory
+
 __all__ = [
     "VideoFile",
     "VideoMetadata",

endoreg_db/models/media/video/create_from_file.py

@@ -1,20 +1,21 @@
-import shutil
 import logging
+import shutil
 import uuid
+from importlib import import_module
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional, Type
 
 # Import the new exceptions from the correct path
 from endoreg_db.exceptions import InsufficientStorageError, TranscodingError
-from ...utils import VIDEO_DIR, TMP_VIDEO_DIR
-from importlib import import_module
+
+from ...utils import TMP_VIDEO_DIR, VIDEO_DIR
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
 
-from ....utils.video.ffmpeg_wrapper import transcode_videofile_if_required
-from ....utils.hashs import get_video_hash
 from ....utils.file_operations import get_uuid_filename
+from ....utils.hashs import get_video_hash
+from ....utils.video.ffmpeg_wrapper import transcode_videofile_if_required
 
 logger = logging.getLogger(__name__)
 
@@ -22,33 +23,31 @@ logger = logging.getLogger(__name__)
 def check_storage_capacity(src_path: Path, dst_root: Path, safety_margin: float = 1.2) -> None:
     """
     Check if there's enough storage space before starting operations.
-    
+
     Args:
         src_path: Source file path
         dst_root: Destination root directory
         safety_margin: Safety factor (1.2 = 20% extra space required)
-        
+
     Raises:
         InsufficientStorageError: If insufficient storage space
     """
     try:
         src_size = src_path.stat().st_size
         required_space = int(src_size * safety_margin)
-        
+
         # Check free space on destination
         free_space = shutil.disk_usage(dst_root).free
-        
+
         if free_space < required_space:
             raise InsufficientStorageError(
-                f"Insufficient storage space. Required: {required_space/1e9:.1f} GB, "
-                f"Available: {free_space/1e9:.1f} GB on {dst_root}",
+                f"Insufficient storage space. Required: {required_space / 1e9:.1f} GB, Available: {free_space / 1e9:.1f} GB on {dst_root}",
                 required_space=required_space,
-                available_space=free_space
+                available_space=free_space,
             )
-            
-        logger.info(f"Storage check passed: {free_space/1e9:.1f} GB available, "
-                   f"{required_space/1e9:.1f} GB required")
-                   
+
+        logger.info(f"Storage check passed: {free_space / 1e9:.1f} GB available, {required_space / 1e9:.1f} GB required")
+
     except OSError as e:
         logger.warning(f"Could not check storage capacity: {e}")
         # Don't fail the operation, just log the warning
@@ -57,14 +56,14 @@ def check_storage_capacity(src_path: Path, dst_root: Path, safety_margin: float
 def atomic_copy_with_fallback(src_path: Path, dst_path: Path) -> bool:
     """
     Atomically copy file from src to dst, preserving the source file.
-    
+
     Args:
         src_path: Source file path
         dst_path: Destination file path
-        
+
     Returns:
         True if successful
-        
+
     Raises:
         InsufficientStorageError: If not enough space for the operation
         OSError: For other file system errors
@@ -73,18 +72,17 @@ def atomic_copy_with_fallback(src_path: Path, dst_path: Path) -> bool:
         # Check space before copy
         src_size = src_path.stat().st_size
         free_space = shutil.disk_usage(dst_path.parent).free
-        
+
         if free_space < src_size * 1.1:  # 10% safety margin
             raise InsufficientStorageError(
-                f"Insufficient space for copy operation. Required: {src_size/1e9:.1f} GB, "
-                f"Available: {free_space/1e9:.1f} GB",
+                f"Insufficient space for copy operation. Required: {src_size / 1e9:.1f} GB, Available: {free_space / 1e9:.1f} GB",
                 required_space=src_size,
-                available_space=free_space
+                available_space=free_space,
             )
-        
+
         # Use a temporary name during copy for atomicity
-        temp_dst = dst_path.with_suffix(dst_path.suffix + '.tmp')
-        
+        temp_dst = dst_path.with_suffix(dst_path.suffix + ".tmp")
+
         try:
             shutil.copy2(str(src_path), str(temp_dst))
             temp_dst.rename(dst_path)
@@ -95,7 +93,7 @@ def atomic_copy_with_fallback(src_path: Path, dst_path: Path) -> bool:
             if temp_dst.exists():
                 temp_dst.unlink(missing_ok=True)
             raise
-    
+
     except Exception as e:
         logger.error(f"Copy operation failed: {src_path} -> {dst_path}: {e}")
         raise
@@ -104,14 +102,14 @@ def atomic_copy_with_fallback(src_path: Path, dst_path: Path) -> bool:
 def atomic_move_with_fallback(src_path: Path, dst_path: Path) -> bool:
     """
     Atomically move file from src to dst, with fallback to copy+remove.
-    
+
     Args:
         src_path: Source file path
         dst_path: Destination file path
-        
+
     Returns:
         True if successful
-        
+
     Raises:
         InsufficientStorageError: If not enough space for the operation
         OSError: For other file system errors
@@ -127,32 +125,31 @@ def atomic_move_with_fallback(src_path: Path, dst_path: Path) -> bool:
                 logger.debug("Cross-device move detected, falling back to copy+remove")
             else:
                 raise
-        
+
         # Check space before cross-filesystem copy
         src_size = src_path.stat().st_size
         free_space = shutil.disk_usage(dst_path.parent).free
-        
+
         if free_space < src_size * 1.1:  # 10% safety margin
             raise InsufficientStorageError(
-                f"Insufficient space for copy operation. Required: {src_size/1e9:.1f} GB, "
-                f"Available: {free_space/1e9:.1f} GB",
+                f"Insufficient space for copy operation. Required: {src_size / 1e9:.1f} GB, Available: {free_space / 1e9:.1f} GB",
                 required_space=src_size,
-                available_space=free_space
+                available_space=free_space,
             )
-        
+
         # Fallback to copy+remove for cross-filesystem moves
         logger.info(f"Copying file (cross-filesystem): {src_path} -> {dst_path}")
-        
+
         # Use a temporary name during copy for atomicity
-        temp_dst = dst_path.with_suffix(dst_path.suffix + '.tmp')
-        
+        temp_dst = dst_path.with_suffix(dst_path.suffix + ".tmp")
+
         try:
             shutil.copy2(str(src_path), str(temp_dst))
             temp_dst.rename(dst_path)
             src_path.unlink()  # Remove source only after successful copy
             logger.debug(f"Copy+remove successful: {src_path} -> {dst_path}")
             return True
-            
+
         except OSError as e:
             # Clean up temp file on failure
             if temp_dst.exists():
@@ -160,12 +157,10 @@ def atomic_move_with_fallback(src_path: Path, dst_path: Path) -> bool:
             # Re-raise with better context
             if e.errno == 28:  # No space left on device
                 raise InsufficientStorageError(
-                    f"No space left on device during copy: {e}",
-                    required_space=src_path.stat().st_size,
-                    available_space=shutil.disk_usage(dst_path.parent).free
+                    f"No space left on device during copy: {e}", required_space=src_path.stat().st_size, available_space=shutil.disk_usage(dst_path.parent).free
                 )
             raise
-            
+
     except Exception as e:
         logger.error(f"Failed to move {src_path} -> {dst_path}: {e}")
         raise
@@ -195,11 +190,11 @@ def _create_from_file(
     video_dir: Path = VIDEO_DIR,
     save: bool = True,
     delete_source: bool = False,
-    **kwargs
+    **kwargs,
 ) -> "VideoFile":
     """
     Creates a VideoFile instance from a given video file path with improved error handling.
-    
+
     Raises:
         InsufficientStorageError: When not enough disk space
         TranscodingError: When video transcoding fails
@@ -208,7 +203,7 @@ def _create_from_file(
     """
     from endoreg_db.models.administration.center.center import Center
     from endoreg_db.models.medical.hardware import EndoscopyProcessor
-    
+
     original_file_name = file_path.name
     original_suffix = file_path.suffix
     final_storage_path = None
@@ -223,23 +218,20 @@ def _create_from_file(
         resolved_storage_root = _get_path(data_paths, "storage", storage_root_default)
         storage_root = Path(resolved_storage_root)
         storage_root.mkdir(parents=True, exist_ok=True)
-        
+
         # Check storage capacity before starting any work
         check_storage_capacity(file_path, storage_root)
 
         # 1. Transcode if necessary
         logger.debug("Checking transcoding requirement for %s", file_path)
-        temp_transcode_dir = TMP_VIDEO_DIR / 'transcoding'
+        temp_transcode_dir = TMP_VIDEO_DIR / "transcoding"
         temp_transcode_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # Use a unique name for the potential transcoded file
         temp_transcoded_output_path = temp_transcode_dir / f"{uuid.uuid4()}{original_suffix}"
 
         try:
-            transcoded_file_path = transcode_videofile_if_required(
-                input_path=file_path,
-                output_path=temp_transcoded_output_path
-            )
+            transcoded_file_path = transcode_videofile_if_required(input_path=file_path, output_path=temp_transcoded_output_path)
             if transcoded_file_path is None:
                 raise TranscodingError(f"Transcoding check/process failed for {file_path}")
         except Exception as e:
@@ -257,7 +249,7 @@ def _create_from_file(
         if cls_model.check_hash_exists(video_hash=video_hash):
             existing_video = cls_model.objects.get(video_hash=video_hash)
             logger.warning("Video with hash %s already exists (UUID: %s)", video_hash, existing_video.uuid)
-            
+
             # Check if the existing video has a valid file
             existing_raw_path = existing_video.get_raw_file_path()
             if existing_video.has_raw and existing_raw_path and existing_raw_path.exists():
@@ -355,4 +347,4 @@ def _create_from_file(
         if transcoded_file_path and transcoded_file_path != file_path and transcoded_file_path.exists():
             logger.warning("Cleaning up orphaned transcoded file: %s", transcoded_file_path)
             transcoded_file_path.unlink(missing_ok=True)
-        raise RuntimeError(f"Video processing failed: {e}") from e
+        raise RuntimeError(f"Video processing failed: {e}") from e

endoreg_db/models/media/video/pipe_2.py

@@ -1,16 +1,16 @@
-from itertools import filterfalse
 import logging
 from typing import TYPE_CHECKING
-from django.db import transaction
 
+from django.db import transaction
 
 # Configure logging
-logger = logging.getLogger(__name__) # Changed from "video_file"
+logger = logging.getLogger(__name__)  # Changed from "video_file"
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile, VideoState
 
-def _pipe_2(video_file:"VideoFile") -> bool:
+
+def _pipe_2(video_file: "VideoFile") -> bool:
     """
     Process the given video file through pipeline 2 operations which include frame extraction,
     anonymization of the video, and deletion of sensitive meta data.
@@ -70,11 +70,10 @@ def _pipe_2(video_file:"VideoFile") -> bool:
                 logger.info("Pipe 2: Anonymization complete.")
         else:
             logger.info("Pipe 2: Video already anonymized.")
-        
 
         # --- Part 3: Final DB operations (now in its own atomic transaction) ---
         with transaction.atomic():
-            video_file.refresh_from_db() # Ensure we have the latest video_file state for these ops
+            video_file.refresh_from_db()  # Ensure we have the latest video_file state for these ops
 
             # Set sensitive_meta_processed True atomically
             state: "VideoState" = video_file.get_or_create_state()
@@ -86,8 +85,8 @@ def _pipe_2(video_file:"VideoFile") -> bool:
                 try:
                     sm_pk = video_file.sensitive_meta.pk
                     video_file.sensitive_meta.delete()
-                    video_file.sensitive_meta = None # Important after SET_NULL
-                    video_file.save(update_fields=['sensitive_meta']) # Persist the null relation
+                    video_file.sensitive_meta = None  # Important after SET_NULL
+                    video_file.save(update_fields=["sensitive_meta"])  # Persist the null relation
                     logger.info("Pipe 2: Deleted sensitive meta object (PK: %s).", sm_pk)
                 except Exception as e:
                     logger.error("Pipe 2: Failed to delete sensitive meta object: %s", e, exc_info=True)
@@ -102,4 +101,4 @@ def _pipe_2(video_file:"VideoFile") -> bool:
         # This will catch exceptions from I/O operations if they raise,
         # or from the final transaction block, or any other unhandled error.
         logger.error(f"Pipe 2 failed for video {video_file.uuid} with unhandled exception: {e}", exc_info=True)
-        return False
+        return False