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

endoreg_db/models/media/pdf/report_file.py

@@ -1,7 +1,9 @@
-from ...utils import DOCUMENT_DIR, STORAGE_DIR
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
+from ...utils import DOCUMENT_DIR, STORAGE_DIR
+
 if TYPE_CHECKING:
     from ...administration import (
         Center,
@@ -12,17 +14,21 @@ if TYPE_CHECKING:
     )
     from ...metadata import SensitiveMeta
 
+
 class DocumentTypeManager(models.Manager):
     """
     Custom manager for DocumentType.
     """
+
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class DocumentType(models.Model):
     """
     Represents the type of a document.
     """
+
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True, null=True)
 
@@ -33,21 +39,23 @@ class DocumentType(models.Model):
 
     def __str__(self):
         return str(self.name)
-    
+
     class Meta:
         verbose_name = "Document Type"
         verbose_name_plural = "Document Types"
 
+
 class AbstractDocument(models.Model):
     """
     Abstract base class for documents.
     """
+
     meta = models.JSONField(blank=True, null=True)
     text = models.TextField(blank=True, null=True)
     date = models.DateField(blank=True, null=True)
     time = models.TimeField(blank=True, null=True)
     file = models.FileField(
-        upload_to=DOCUMENT_DIR.relative_to(STORAGE_DIR),
+        upload_to=DOCUMENT_DIR.relative_to(STORAGE_DIR).as_posix(),
         blank=True,
         null=True,
     )
@@ -67,22 +75,19 @@ class AbstractDocument(models.Model):
     )
 
     if TYPE_CHECKING:
-        center: "Center"
-        type: "DocumentType"
+        center: models.ForeignKey["Center|None"]
+        type: models.ForeignKey["DocumentType|None"]
 
     class Meta:
         abstract = True
 
 
-    
-
 class AbstractExaminationReport(AbstractDocument):
     """
     Abstract base class for examination reports.
     """
-    patient = models.ForeignKey(
-        "Patient", on_delete=models.DO_NOTHING, blank=True, null=True
-    )
+
+    patient = models.ForeignKey("Patient", on_delete=models.DO_NOTHING, blank=True, null=True)
 
     patient_examination = models.ForeignKey(
         "PatientExamination",
@@ -96,25 +101,18 @@ class AbstractExaminationReport(AbstractDocument):
         blank=True,
     )
 
-    sensitive_meta = models.ForeignKey(
-        "SensitiveMeta",
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True
-    )
+    sensitive_meta = models.ForeignKey("SensitiveMeta", on_delete=models.SET_NULL, null=True, blank=True)
 
     if TYPE_CHECKING:
-        center: "Center"
-        type: "DocumentType"
-        patient: "Patient"
-        patient_examination: "PatientExamination"
-        sensitive_meta: "SensitiveMeta"
-
+        center: models.ForeignKey["Center|None"]
+        type: models.ForeignKey["DocumentType|None"]
+        patient: models.ForeignKey["Patient|None"]
+        patient_examination: models.ForeignKey["PatientExamination|None"]
+        sensitive_meta: models.ForeignKey["SensitiveMeta|None"]
 
     class Meta:
         abstract = True
 
-    
     def get_or_create_examiner(self, examiner_first_name, examiner_last_name):
         raise NotImplementedError("Subclasses must implement this method.")
 
@@ -122,10 +120,8 @@ class AbstractExaminationReport(AbstractDocument):
         raise NotImplementedError("Subclasses must implement this method.")
 
 
-
 class AnonymExaminationReport(AbstractExaminationReport):
-
-    def get_or_create_examiner(self, examiner_first_name:str, examiner_last_name:str):
+    def get_or_create_examiner(self, examiner_first_name: str, examiner_last_name: str):
         from ...administration.person import Examiner
 
         examiner_center = self.center
@@ -139,7 +135,7 @@ class AnonymExaminationReport(AbstractExaminationReport):
         return examiner, created
 
     def set_examination_date_and_time(self, report_meta=None):
-        #TODO
+        # TODO
         if not report_meta:
             report_meta = self.meta
         # examination_date_str = report_meta["examination_date"]
@@ -152,11 +148,11 @@ class AnonymExaminationReport(AbstractExaminationReport):
         #     # TODO: get django TimeField compatible time from string (e.g. "12:00")
         #     self.time = time.fromisoformat(examination_time_str)
 
+
 class AnonymHistologyReport(AbstractExaminationReport):
     """
     Represents a histology report.
     """
 
-
     def get_or_create_examiner(self, examiner_first_name, examiner_last_name):
         raise NotImplementedError("Subclasses must implement this method.")

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