endoreg-db 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

endoreg_db/mermaid/anonymized_image_annotation.md

@@ -0,0 +1,20 @@
+```mermaid
+graph TD;
+
+    %% File Handling Process
+    A[**Uploaded File**] -->|Original File Uploaded| B[**Anonymized File**]
+    B -->|File Anonymized & Stored| C[**Anonymous Image Annotation**]
+
+    %% Image Annotation & Processing
+    C -->|Label Assigned| D[**Anonymized Image Label**]
+    C -->|Detected Personal Info Removed| E[**Dropped Name**]
+
+    %% Relationships & Processing
+    E -->|Stored for Record-Keeping| C;
+    D -->|Predefined Labels Used| C;
+
+    %% Example Data (Corrected & Meaningful)
+    X1(["**Example: Uploaded colonoscopy.jpg**"]) -.-> A;
+    X2(["**Example: anonymized_colonoscopy.jpg**"]) -.-> B;
+    X3(["**Example: Label - 'Polyp Detected'**"]) -.-> D;
+    X4(["**Example: Name 'John Doe' removed**"]) -.-> E;

endoreg_db/mermaid/binary_classification_annotation.md

@@ -0,0 +1,50 @@
+```mermaid
+graph TD;
+
+  
+
+%% Step 1: Image Classification (Start)
+
+A[**Image Classification**] -->|Uses| B[**Label**];
+
+  
+
+%% Step 2: Video Segmentation
+
+A -->|Segments Stored In| C[**Video Segmentation**];
+
+  
+
+%% Step 3: Automatic Segmentation Detection
+
+D["**find_segments_in_prediction_array()**"] -->|Detects & Segments| C;
+
+  
+
+%% Step 4: Fetching Unclassified Frames for Annotation
+
+E["get_legacy_binary_classification_annotation_tasks_by_label()"] -->|Finds Frames Needing Annotation| F;
+
+  
+
+%% Step 5: Binary Classification Task Management
+
+F[**Binary Classification Task**] -->|Assigned To| G[**Frame**];
+
+F -->|Assigned To| H[**Legacy Frame**];
+
+F -->|Uses| B;
+
+%% Step 6: Task Completion & Cleanup (End)
+
+I["clear_finished_legacy_tasks()"] -->|Removes Completed Tasks| F;
+
+  
+
+%% Example Data
+
+X1(["Example: Frame classified as 'Polyp Present'"]) -.-> A;
+
+X2(["Example: Video segment marked from 100s to 200s"]) -.-> C;
+
+X3(["Example: 10 unclassified frames found"]) -.-> F;

endoreg_db/mermaid/classification.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Select Finding Location Classification"] --> B["Store in endoreg_db_findinglocationclassification"]
+    B --> C["Retrieve Available Choices"]
+    C --> D["Save Selected Location in endoreg_db_patientfinding_locations"]
+    D --> E["Link Location to Patient Finding via Foreign Key"]
+    E --> F["Finding Location Process Completed"]

endoreg_db/mermaid/examination.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Record Examination"] --> B["Store in endoreg_db_examination"]
+    B --> C["Retrieve Patient ID"]
+    C --> D["Save in endoreg_db_patientexamination with Patient ID"]
+    D --> E["Link Patient to Examination via Foreign Key"]
+    E --> F["Examination Process Completed"]

endoreg_db/mermaid/findings.md

@@ -0,0 +1,7 @@
+```mermaid
+graph TD;
+    
+    A["Start: Identify Medical Finding"] --> B["Store in endoreg_db_finding"]
+    B --> C["Retrieve Patient Examination ID"]
+    C --> D["Save in endoreg_db_patientfinding with Examination ID (Link Finding to Examination via Foreign Key)"]
+    D --> E["Finding Process Completed"]

endoreg_db/mermaid/image_classification.md

@@ -0,0 +1,28 @@
+```mermaid
+graph TD;
+
+    %% Image Classification Process
+    A[**Image Classification Annotation**] -->|Attached to| B[**Frame**];
+    A -->|Attached to| C[**Legacy Frame**];
+    A -->|Attached to| D[**Legacy Image**];
+    A -->|Uses Predefined| E[**Label**];
+
+    %% Video Segmentation Process
+    F[**Abstract Label Video Segment**] -->|Base Class for| G[**Legacy Label Video Segment**];
+    F -->|Base Class for| H[**Label Video Segment**];
+
+    %% Video References
+    G -->|Segmentation of| I[**Legacy Video**];
+    H -->|Segmentation of| J[**Modern Video**];
+
+    %% Metadata & Prediction Handling
+    G -->|Uses Prediction Data| K[**Legacy Video Prediction Meta**];
+    H -->|Uses Prediction Data| L[**Video Prediction Meta**];
+
+    %% Automatic Segmentation Process
+    M["**find_segments_in_prediction_array()**"] -->|Detects & Segments Frames| F;
+
+    %% Example Data
+    X1(["**Example: Frame classified as 'Polyp Present'**"]) -.-> A;
+    X2(["**Example: Segment starts at frame 100, ends at frame 200**"]) -.-> F;
+    X3(["**Example: Legacy Video used for segmentation**"]) -.-> G;

endoreg_db/mermaid/interventions.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Select Intervention"] --> B["Store in endoreg_db_findingintervention"]
+    B --> C["Retrieve Patient Finding ID"]
+    C --> D["Save in endoreg_db_patientfindingintervention"]
+    D --> E["Link Intervention to Patient Finding via Foreign Key"]
+    E --> F["Intervention Process Completed"]

endoreg_db/mermaid/morphology.md

@@ -0,0 +1,8 @@
+```mermaid
+graph TD;
+    
+    A["Start: Select Morphology Classification"] --> B["Store in endoreg_db_findingmorphologyclassification"]
+    B --> C["Retrieve Associated Classification Type"]
+    C --> D["Save in endoreg_db_patientfinding_morphology"]
+    D --> E["Link Morphology to Patient Finding via Foreign Key"]
+    E --> F["Morphology Process Completed"]

endoreg_db/mermaid/patient_creation.md

@@ -0,0 +1,14 @@
+```mermaid
+graph TD;
+    
+    A["Start: Create New Patient (John)"] --> B{"Does the Center Exist?"}
+    
+    B -- Yes --> C["Retrieve Existing Center ID"]
+    B -- No --> D["Create New Medical Center"]
+    
+    D --> E["Retrieve Newly Created Center ID"]
+    C --> F["Save Patient in endoreg_db_patient with Center ID"]
+    E --> F
+    
+    F --> G["Patient Registration Completed"]
+

endoreg_db/mermaid/video_segmentation_annotation.md

@@ -0,0 +1,17 @@
+```mermaid
+graph TD;
+
+    %% Label Management
+    A[**Video Segmentation Label**] -->|Used in| B[**Video Segmentation Annotation**];
+
+    %% Annotation Process
+    B -->|Assigned to| C[**Raw Video File**];
+
+    %% Attributes Breakdown
+    A -->|Has Fields| A1[**Name, Description, Color, Priority**];
+    B -->|Has Fields| B1[**Start Time, Stop Time, Validity**];
+    
+    %% Example Data (Placed Outside for Clarity)
+    X1(["Example: Label - 'Polyp Detected'"]) -.-> A;
+    X2(["Example: Video1.mp4, Start: 10s, Stop: 15s"]) -.-> B;
+

endoreg_db/migrations/0009_requirementoperator_requirementsettype_and_more.py

@@ -0,0 +1,154 @@
+# Generated by Django 5.1.3 on 2025-04-06 23:05
+
+import django.core.files.storage
+import django.core.validators
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('endoreg_db', '0008_remove_reportfile_patient_examination_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='RequirementOperator',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('name_de', models.CharField(blank=True, max_length=100, null=True)),
+                ('name_en', models.CharField(blank=True, max_length=100, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='RequirementSetType',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('name_de', models.CharField(blank=True, max_length=100, null=True)),
+                ('name_en', models.CharField(blank=True, max_length=100, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='RequirementType',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('name_de', models.CharField(blank=True, max_length=100, null=True)),
+                ('name_en', models.CharField(blank=True, max_length=100, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='RiskType',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('name_de', models.CharField(blank=True, max_length=100, null=True)),
+                ('name_en', models.CharField(blank=True, max_length=100, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+            ],
+        ),
+        migrations.RemoveField(
+            model_name='examinationindication',
+            name='classification',
+        ),
+        migrations.AddField(
+            model_name='examinationindication',
+            name='classifications',
+            field=models.ManyToManyField(blank=True, related_name='indications', to='endoreg_db.examinationindicationclassification'),
+        ),
+        migrations.AddField(
+            model_name='examinationindication',
+            name='description',
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='examinationindication',
+            name='expected_interventions',
+            field=models.ManyToManyField(blank=True, related_name='indications', to='endoreg_db.findingintervention'),
+        ),
+        migrations.AddField(
+            model_name='examinationindicationclassification',
+            name='description',
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='examinationindicationclassification',
+            name='examination',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='indication_classifications', to='endoreg_db.examination'),
+        ),
+        migrations.AlterField(
+            model_name='rawpdffile',
+            name='file',
+            field=models.FileField(storage=django.core.files.storage.FileSystemStorage(location='/home/admin/dev/endoreg-db/erc_data'), upload_to='raw_pdf/', validators=[django.core.validators.FileExtensionValidator(allowed_extensions=['pdf'])]),
+        ),
+        migrations.AlterField(
+            model_name='rawvideofile',
+            name='file',
+            field=models.FileField(storage=django.core.files.storage.FileSystemStorage(location='/home/admin/dev/endoreg-db/erc_data'), upload_to='db_raw_videos', validators=[django.core.validators.FileExtensionValidator(allowed_extensions=['mp4'])]),
+        ),
+        migrations.AlterField(
+            model_name='video',
+            name='file',
+            field=models.FileField(storage=django.core.files.storage.FileSystemStorage(location='/home/admin/dev/endoreg-db/erc_data'), upload_to='db_videos', validators=[django.core.validators.FileExtensionValidator(allowed_extensions=['mp4'])]),
+        ),
+        migrations.CreateModel(
+            name='Requirement',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('name_de', models.CharField(blank=True, max_length=100, null=True)),
+                ('name_en', models.CharField(blank=True, max_length=100, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+                ('numeric_value', models.FloatField(blank=True, help_text='Numeric value for the requirement. If not set, the requirement is not used in calculations.', null=True)),
+                ('numeric_value_min', models.FloatField(blank=True, help_text='Minimum numeric value for the requirement. If not set, the requirement is not used in calculations.', null=True)),
+                ('numeric_value_max', models.FloatField(blank=True, help_text='Maximum numeric value for the requirement. If not set, the requirement is not used in calculations.', null=True)),
+                ('string_value', models.CharField(blank=True, help_text='String value for the requirement. If not set, the requirement is not used in calculations.', max_length=100, null=True)),
+                ('string_values', models.TextField(blank=True, help_text=" ','-separated list of string values for the requirement.If not set, the requirement is not used in calculations.", null=True)),
+                ('disease_classification_choices', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.diseaseclassificationchoice')),
+                ('diseases', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.disease')),
+                ('events', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.event')),
+                ('examination_indications', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.examinationindication')),
+                ('examinations', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.examination')),
+                ('finding_interventions', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.findingintervention')),
+                ('finding_location_classification_choices', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.findinglocationclassificationchoice')),
+                ('finding_morphology_classification_choices', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.findingmorphologyclassificationchoice')),
+                ('findings', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.finding')),
+                ('lab_values', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.labvalue')),
+                ('unit', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='required_in', to='endoreg_db.unit')),
+                ('operators', models.ManyToManyField(blank=True, related_name='required_in', to='endoreg_db.requirementoperator')),
+                ('requirement_types', models.ManyToManyField(blank=True, related_name='linked_requirements', to='endoreg_db.requirementtype')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='RequirementSet',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('name_de', models.CharField(blank=True, max_length=100, null=True)),
+                ('name_en', models.CharField(blank=True, max_length=100, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+                ('information_sources', models.ManyToManyField(blank=True, related_name='requirement_sets', to='endoreg_db.informationsource')),
+                ('links_to_sets', models.ManyToManyField(blank=True, related_name='links_from_sets', to='endoreg_db.requirementset')),
+                ('requirements', models.ManyToManyField(blank=True, related_name='requirement_sets', to='endoreg_db.requirement')),
+                ('requirement_set_type', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='requirement_sets', to='endoreg_db.requirementsettype')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Risk',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100, unique=True)),
+                ('name_de', models.CharField(blank=True, max_length=100, null=True)),
+                ('name_en', models.CharField(blank=True, max_length=100, null=True)),
+                ('description', models.TextField(blank=True, null=True)),
+                ('risk_value', models.FloatField(blank=True, help_text='Risk value for the risk. If not set, the risk is not used in calculations.', null=True)),
+                ('risk_type', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='risks', to='endoreg_db.risktype')),
+            ],
+        ),
+    ]

endoreg_db/models/__init__.py

@@ -97,6 +97,19 @@ from .case_template import (
     CaseTemplateRuleValueType,
 )
 
+from .risk import (
+    Risk,
+    RiskType,
+)
+
+from .requirement import (
+    Requirement,
+    RequirementSet,
+    RequirementSetType,
+    RequirementOperator,
+    RequirementType,
+)
+
 # Rules
 from .rules import (
     Rule,
@@ -373,4 +386,11 @@ __all__ = [
     "RawPdfFile",
     "RawVideoFile",
     "VideoSegmentationLabelSet",
+    "RequirementSet",
+    "RequirementSetType",
+    "Requirement",
+    "RequirementOperator",
+    "RequirementType",
+    "Risk",
+    "RiskType",
 ]

endoreg_db/models/ai_model/ai_model.py

@@ -1,22 +1,9 @@
 """
 Django model for AI models.
 """
-
-from pathlib import Path
-import os
 from django.db import models
 from icecream import ic
 
-PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data")))
-
-STORAGE_LOCATION = PSEUDO_DIR
-WEIGHTS_DIR_NAME = "db_model_weights"
-WEIGHTS_DIR = STORAGE_LOCATION / WEIGHTS_DIR_NAME
-
-if not WEIGHTS_DIR.exists():
-    WEIGHTS_DIR.mkdir(parents=True)
-
-
 class AiModelManager(models.Manager):
     """
     Manager for AI models with custom query methods.

endoreg_db/models/ai_model/model_meta.py

@@ -2,7 +2,6 @@
 This module defines the ModelMeta and ModelMetaManager classes for managing AI model metadata.
 """
 
-import os
 from pathlib import Path
 from typing import Optional, TYPE_CHECKING
 import shutil
@@ -10,20 +9,11 @@ import shutil
 from django.db import models
 from django.core.validators import FileExtensionValidator
 from icecream import ic
+from ...utils import WEIGHTS_DIR
 
 if TYPE_CHECKING:
     from endoreg_db.models import LabelSet, AiModel  # pylint: disable=import-outside-toplevel
 
-PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data")))
-
-STORAGE_LOCATION = PSEUDO_DIR
-WEIGHTS_DIR_NAME = "db_model_weights"
-WEIGHTS_DIR = STORAGE_LOCATION / WEIGHTS_DIR_NAME
-
-if not WEIGHTS_DIR.exists():
-    WEIGHTS_DIR.mkdir(parents=True)
-
-
 class ModelMetaManager(models.Manager):
     """
     Custom manager for ModelMeta with additional query methods.
@@ -57,7 +47,7 @@ class ModelMeta(models.Model):
     activation = models.CharField(max_length=255, default="sigmoid")
 
     weights = models.FileField(
-        upload_to=WEIGHTS_DIR_NAME,
+        upload_to=WEIGHTS_DIR.name,
         validators=[FileExtensionValidator(allowed_extensions=["ckpt"])],
         # storage=FileSystemStorage(location=STORAGE_LOCATION.resolve().as_posix()),
         null=True,

endoreg_db/models/data_file/base_classes/abstract_frame.py

@@ -5,12 +5,10 @@ from endoreg_db.models.annotation.image_classification import (
 from endoreg_db.models.label.label import Label
 
 from django.db import models
-from .utils import FRAME_DIR_NAME
 
 if TYPE_CHECKING:
     from endoreg_db.models import Video, RawVideoFile
 
-
 class AbstractFrame(models.Model):
     frame_number = models.IntegerField()
     # Add any other fields you need to store frame-related information

endoreg_db/models/data_file/base_classes/abstract_pdf.py

@@ -26,21 +26,12 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from ..base_classes.utils import (
-    STORAGE_LOCATION,
-)
 
 if TYPE_CHECKING:
     from endoreg_db.models import SensitiveMeta
 
 logger = logging.getLogger("pdf_import")
 
-RAW_PDF_DIR_NAME = "raw_pdf"
-RAW_PDF_DIR = STORAGE_LOCATION / RAW_PDF_DIR_NAME
-
-if not RAW_PDF_DIR.exists():
-    RAW_PDF_DIR.mkdir(parents=True)
-
 
 class AbstractPdfFile(models.Model):
     pdf_hash = models.CharField(max_length=255, unique=True)

endoreg_db/models/data_file/base_classes/abstract_video.py

@@ -1,14 +1,12 @@
 """ """
 
+from django.db import models
 from pathlib import Path
 from collections import defaultdict, Counter
 import shutil
 import os
-import subprocess
 from typing import Optional, List, TYPE_CHECKING, Union
-from django.db import models, transaction
 from icecream import ic
-from tqdm import tqdm
 from endoreg_db.utils.hashs import get_video_hash
 from endoreg_db.utils.file_operations import get_uuid_filename
 from endoreg_db.utils.ocr import extract_text_from_rois
@@ -21,12 +19,11 @@ from ....utils.video import (
 )
 
 from ..metadata import VideoMeta, SensitiveMeta
-from .utils import (
-    STORAGE_LOCATION,
+from ....utils import (
+    STORAGE_DIR,
     VIDEO_DIR,
     FRAME_DIR,
 )
-from .prepare_bulk_frames import prepare_bulk_frames
 
 if TYPE_CHECKING:
     from endoreg_db.models import (
@@ -180,10 +177,10 @@ class AbstractVideoFile(models.Model):
         ic(f"No existing DB entry found, creating new with UUID {uuid}")
 
         try:
-            relative_path = transcoded_file_path.relative_to(STORAGE_LOCATION)
+            relative_path = transcoded_file_path.relative_to(STORAGE_DIR)
         except ValueError as e:
             raise Exception(
-                f"{transcoded_file_path} is outside STORAGE_LOCATION {STORAGE_LOCATION}"
+                f"{transcoded_file_path} is outside STORAGE_DIR {STORAGE_DIR}"
             ) from e
 
         video = cls(
@@ -325,6 +322,8 @@ class AbstractVideoFile(models.Model):
             ModelMeta,
             AiModel,
         )  # pylint: disable=import-outside-toplevel
+        #TODO Create issue to movie this function to the endo-ai module
+        #endoreg-db is our "base" module, so it should not depend "upstream" models
         from endo_ai.predictor.inference_dataset import InferenceDataset  # pylint: disable=import-outside-toplevel
         from endo_ai.predictor.model_loader import MultiLabelClassificationNet
         from endo_ai.predictor.predict import Classifier

endoreg_db/models/data_file/base_classes/utils.py

@@ -7,28 +7,6 @@ from pathlib import Path
 import cv2
 import numpy as np
 
-DJANGO_NAME_SALT = os.environ.get("DJANGO_NAME_SALT", "default_salt")
-
-# Directory stuff
-PSEUDO_DIR = Path(os.environ.get("DJANGO_PSEUDO_DIR", Path("./erc_data")))
-STORAGE_LOCATION = PSEUDO_DIR
-FRAME_DIR_NAME = os.environ.get("DJANGO_FRAME_DIR_NAME", "db_frames")
-RAW_FRAME_DIR_NAME = os.environ.get("DJANGO_RAW_FRAME_DIR_NAME", "db_raw_frames")
-VIDEO_DIR_NAME = os.environ.get("DJANGO_VIDEO_DIR_NAME", "db_videos")
-RAW_VIDEO_DIR_NAME = os.environ.get("DJANGO_RAW_VIDEO_DIR_NAME", "db_raw_videos")
-
-FRAME_DIR = STORAGE_LOCATION / FRAME_DIR_NAME
-VIDEO_DIR = STORAGE_LOCATION / VIDEO_DIR_NAME
-RAW_VIDEO_DIR = STORAGE_LOCATION / RAW_VIDEO_DIR_NAME
-
-TEST_RUN = os.environ.get("TEST_RUN", False)
-TEST_RUN_FRAME_NUMBER = os.environ.get("TEST_RUN_FRAME_NUMBER", 1000)
-
-VIDEO_DIR.mkdir(parents=True, exist_ok=True)
-RAW_VIDEO_DIR.mkdir(parents=True, exist_ok=True)
-
-# AI Stuff
-FRAME_PROCESSING_BATCH_SIZE = os.environ.get("DJANGO_FRAME_PROCESSING_BATCH_SIZE", 10)
 
 
 def anonymize_frame(

endoreg_db/models/data_file/frame.py

@@ -4,7 +4,7 @@ from endoreg_db.models.label.label import Label
 from .base_classes import AbstractFrame
 from django.db import models
 
-from .base_classes.utils import FRAME_DIR_NAME, RAW_FRAME_DIR_NAME
+from ...utils import FRAME_DIR_NAME, RAW_FRAME_DIR_NAME
 
 if TYPE_CHECKING:
     from endoreg_db.models import RawVideoFile, Video

endoreg_db/models/data_file/import_classes/raw_pdf.py

@@ -7,7 +7,6 @@
 
 from django.db import models
 from django.core.files.storage import FileSystemStorage
-from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.core.validators import FileExtensionValidator
 from endoreg_db.utils.file_operations import get_uuid_filename
@@ -25,24 +24,19 @@ import logging
 import shutil
 from pathlib import Path
 
-from ..base_classes.utils import (
-    STORAGE_LOCATION,
+from ....utils import (
+    STORAGE_DIR,
+    RAW_PDF_DIR_NAME,
+    RAW_PDF_DIR,
 )
 
 logger = logging.getLogger("pdf_import")
 
-RAW_PDF_DIR_NAME = "raw_pdf"
-RAW_PDF_DIR = STORAGE_LOCATION / RAW_PDF_DIR_NAME
-
-if not RAW_PDF_DIR.exists():
-    RAW_PDF_DIR.mkdir(parents=True)
-
-
 class RawPdfFile(AbstractPdfFile):
     file = models.FileField(
         upload_to=f"{RAW_PDF_DIR_NAME}/",
         validators=[FileExtensionValidator(allowed_extensions=["pdf"])],
-        storage=FileSystemStorage(location=STORAGE_LOCATION.resolve().as_posix()),
+        storage=FileSystemStorage(location=STORAGE_DIR.resolve().as_posix()),
     )
 
     patient = models.ForeignKey(

endoreg_db/models/data_file/import_classes/raw_video.py

@@ -13,12 +13,14 @@ from django.core.files.storage import FileSystemStorage
 from endoreg_db.utils.validate_endo_roi import validate_endo_roi
 from ..base_classes.utils import (
     anonymize_frame,
-    RAW_VIDEO_DIR_NAME,
-    VIDEO_DIR,
-    STORAGE_LOCATION,
 )
 from ..base_classes.abstract_video import AbstractVideoFile
+from ....utils import (
 
+    RAW_VIDEO_DIR_NAME,
+    VIDEO_DIR,
+    STORAGE_DIR,
+)
 if TYPE_CHECKING:
     # import Queryset
     from django.db.models import QuerySet
@@ -35,7 +37,7 @@ class RawVideoFile(AbstractVideoFile):
     file = models.FileField(
         upload_to=RAW_VIDEO_DIR_NAME,
         validators=[FileExtensionValidator(allowed_extensions=["mp4"])],  # FIXME
-        storage=FileSystemStorage(location=STORAGE_LOCATION.resolve().as_posix()),
+        storage=FileSystemStorage(location=STORAGE_DIR.resolve().as_posix()),
     )
 
     patient = models.ForeignKey(

endoreg_db/models/data_file/video/video.py

@@ -5,9 +5,9 @@ from django.core.files.storage import FileSystemStorage
 from typing import TYPE_CHECKING
 import cv2
 from ..base_classes import AbstractVideoFile
-from ..base_classes.utils import (
+from ....utils import (
     VIDEO_DIR_NAME,
-    STORAGE_LOCATION,
+    STORAGE_DIR,
     FRAME_PROCESSING_BATCH_SIZE,
 )
 
@@ -27,7 +27,7 @@ class Video(AbstractVideoFile):
     file = models.FileField(
         upload_to=VIDEO_DIR_NAME,
         validators=[FileExtensionValidator(allowed_extensions=["mp4"])],  # FIXME
-        storage=FileSystemStorage(location=STORAGE_LOCATION.resolve().as_posix()),
+        storage=FileSystemStorage(location=STORAGE_DIR.resolve().as_posix()),
     )
 
     patient = models.ForeignKey(