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

endoreg_db/import_files/context/validate_directories.py

@@ -0,0 +1,56 @@
+import logging
+from pathlib import Path
+from typing import Iterable
+from endoreg_db.utils.paths import (
+    ANONYM_REPORT_DIR,
+    ANONYM_VIDEO_DIR,
+    IMPORT_REPORT_DIR,
+    IMPORT_VIDEO_DIR,
+    SENSITIVE_REPORT_DIR,
+    SENSITIVE_VIDEO_DIR,
+)
+
+dirs = [
+    ANONYM_REPORT_DIR,
+    ANONYM_VIDEO_DIR,
+    IMPORT_REPORT_DIR,
+    IMPORT_VIDEO_DIR,
+    SENSITIVE_REPORT_DIR,
+    SENSITIVE_VIDEO_DIR,
+]
+
+
+logger = logging.getLogger(__name__)
+
+
+def validate_directories(dirs: Iterable[Path] = dirs) -> bool:
+    """
+    Ensure all directories in `dirs` exist.
+    Missing directories are created automatically.
+
+    Args:
+        dirs: Iterable of Path objects representing directories.
+
+    Returns:
+        bool: True if all directories exist or were created successfully,
+              False if any directory could not be created.
+    """
+    ok = True
+
+    for d in dirs:
+        try:
+            if not d.exists():
+                logger.info(f"Directory missing, creating: {d}")
+                d.mkdir(parents=True, exist_ok=True)
+
+            if not d.is_dir():
+                logger.error(f"Path exists but is not a directory: {d}")
+                ok = False
+
+        except Exception as e:
+            logger.error(f"Failed to create or validate directory '{d}': {e}")
+            ok = False
+
+    return ok
+
+validate_directories(dirs)

endoreg_db/import_files/file_storage/__init__.py

@@ -0,0 +1,15 @@
+# storage/__init__.py
+
+from . import create_report_file
+from . import create_video_file
+from . import sensitive_meta_storage
+from . import state_management
+from . import storage
+
+__all__ = [
+    "create_report_file",
+    "create_video_file",
+    "sensitive_meta_storage",
+    "state_management",
+    "storage",
+]

endoreg_db/import_files/file_storage/create_report_file.py

@@ -0,0 +1,76 @@
+# endoreg_db/import_files/storage/create_report_file.py
+import logging
+from typing import Tuple
+
+from endoreg_db.import_files.context.import_context import ImportContext
+from endoreg_db.models.media import RawPdfFile
+from endoreg_db.models.media.processing_history.processing_history import ProcessingHistory
+from endoreg_db.import_files.context.ensure_center import ensure_center
+logger = logging.getLogger(__name__)
+
+
+def create_or_retrieve_report_file(
+    ctx: ImportContext,
+) -> Tuple[RawPdfFile, bool]:
+    """
+    Create a new or retrieve an existing RawPdfFile for the given context.
+
+    Returns:
+        pdf             : RawPdfFile instance
+        needs_processing: True if the pipeline should run for this file
+                          (no successful history yet for this object/file_type key)
+    """
+    file_path = ctx.file_path
+    center_name = ctx.center_name
+    delete_source = ctx.delete_source
+    file_type = ctx.file_type  # logical key for history; can be None
+
+    # 1) Determine the RawPdfFile instance to work with
+    if ctx.current_report is not None:
+        pdf = ctx.current_report
+        logger.info("Using existing RawPdfFile from context: pk=%s", pdf.pk)
+    else:
+        logger.info("Creating new RawPdfFile from %s for center %s", file_path, center_name)
+        
+        pdf = RawPdfFile.create_from_file_initialized(
+            file_path=file_path,
+            center_name=center_name,
+            delete_source=delete_source,
+        )
+        
+        center = ensure_center(pdf, ctx.center_name)
+        
+        logger.info(f"Successfully set up report file from {center.name}")
+
+
+
+    # 3) Check if we already have a successful history entry for this object+file_type
+    has_success_history = ProcessingHistory.has_history_for_object(
+        obj=pdf,
+        success=True,
+    )
+
+    if has_success_history:
+        logger.info(
+            "RawPdfFile %s already has successful processing history (file_type=%s) - short-circuiting",
+            getattr(pdf, str(pdf.file_path)),
+            file_type,
+        )
+        # No need to run the pipeline again
+        return pdf, False
+
+    # 4) No successful history yet → ensure there is a history entry marking it as "in progress"/failed
+    ProcessingHistory.get_or_create_for_object(
+        obj=pdf,
+        # At this point we haven't finished anonymization; treat as not-success yet.
+        success=False,
+    )
+
+    logger.info(
+        "Report instance ready for processing: pk=%s, file_type=%s (needs_processing=True)",
+        pdf.pk,
+        file_type,
+    )
+
+    # Signal to the caller that the anonymization pipeline should run
+    return pdf, True

endoreg_db/import_files/file_storage/create_video_file.py

@@ -0,0 +1,75 @@
+# endoreg_db/import_files/storage/create_video_file.py
+import logging
+from typing import Tuple
+
+from django.db import IntegrityError
+
+from endoreg_db.import_files.context.import_context import ImportContext
+from endoreg_db.import_files.context.ensure_center import ensure_center
+from endoreg_db.models.media import VideoFile
+from endoreg_db.models.media.processing_history.processing_history import ProcessingHistory
+from endoreg_db.utils.hashs import get_video_hash
+
+logger = logging.getLogger(__name__)
+
+
+def create_or_retrieve_video_file(
+    ctx: ImportContext,
+) -> Tuple[VideoFile, bool]:
+    """
+    Create a new or retrieve an existing VideoFile for the given context.
+
+    Returns:
+        video     : VideoFile instance
+        retry     : whether we are re-processing an existing file
+    """
+    file_path = ctx.file_path
+    center_name = ctx.center_name
+    processor_name = ctx.processor_name
+    delete_source = ctx.delete_source
+    file_type = ctx.file_type
+
+    # 1) Determine the VideoFile instance to work with
+    if ctx.current_video is not None:
+        video = ctx.current_video
+        logger.info("Using existing VideoFIle from context: pk =%s", video.pk)
+    else:
+        logger.info("Creating new VideoFIle from %s for center %s", file_path, center_name)
+        video = VideoFile.create_from_file_initialized(
+            file_path=file_path,
+            center_name=center_name,
+            processor_name=processor_name,
+            delete_source=delete_source,
+        )
+        center = ensure_center(video, ctx.center_name)
+        
+        logger.info(f"Successfully set up report file from {center.name}")
+    # 3) Check if we already have a successful history entry for this object+file_type        
+    has_success_history = ProcessingHistory.has_history_for_object(
+        obj=video,
+        success=True,
+    )
+
+    if has_success_history:
+        logger.info(
+            "VideoFile %s already has successful processing history. (file_type:%s) - short-circuiting",
+            getattr(video, str(video.active_file_path)),
+            file_type,
+    )
+    
+    # 4) No successful history yet → ensure there is a history entry marking it as "in progress"/failed
+    ProcessingHistory.get_or_create_for_object(
+        obj=video,
+        success=False
+    )
+    
+    
+    logger.info(
+        "Video instance ready for processing: pk=%s, file_type=%s (needs_processing=True)",
+        video.pk,
+        file_type,
+    )
+    
+    # Signal to the caller that the anonymization pipeline should run
+    return video, True
+

endoreg_db/import_files/file_storage/sensitive_meta_storage.py

@@ -0,0 +1,39 @@
+# endoreg_db/import_files/storage/sensitive_meta_storage.py
+from typing import Union, Dict, Any
+
+from endoreg_db.models.media import RawPdfFile, VideoFile
+from endoreg_db.models.metadata import SensitiveMeta
+from endoreg_db.import_files.processing.sensitive_meta_adapter import (
+    normalize_lx_sensitive_meta,
+)
+from endoreg_db.import_files.context.default_sensitive_meta import default_sensitive_meta
+from logging import getLogger
+from lx_anonymizer.sensitive_meta_interface import SensitiveMeta as LxSM
+#
+
+logger = getLogger(__name__)
+
+def sensitive_meta_storage(
+    sensitive_meta: LxSM,
+    instance: Union[RawPdfFile, VideoFile],
+) -> bool:
+    """
+    Merge lx_anonymizer.SensitiveMeta into instance.sensitive_meta in the DB.
+
+    - Normalizes the dataclass into the dict format expected by the model logic
+    - Delegates to SensitiveMeta.update_from_dict() (which already calls logic.update_*)
+    """
+    local_meta = instance.sensitive_meta  # Django SensitiveMeta model instance
+    if not isinstance(local_meta, SensitiveMeta):
+        # If sensitice meta doesnt exist yet, ensure it
+        local_meta = default_sensitive_meta(instance)
+    assert isinstance(local_meta, SensitiveMeta)
+
+    try:
+        payload = normalize_lx_sensitive_meta(sensitive_meta)
+        local_meta.update_from_dict(payload)  # this calls your big logic.update_*
+    except Exception as e:
+        logger.error(f"{e}")
+        return False
+
+    return True