endoreg-db 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

endoreg_db/management/commands/_load_model_template.py

@@ -1,41 +1,41 @@
-from django.conf import settings
-from django.core.management.base import BaseCommand
-from reports.models import Intervention, InterventionType  # Replace 'your_app_name' with the actual app name
-import os
-from reports.dataloader_utils import load_model_data
-
-SOURCE_DIR = None # e.g. settings.DATA_DIR_INTERVENTION
-
-IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-]
-
-IMPORT_METADATA = {
-    # "": { # same as model name in "import models", e.g. "Intervention"
-    #     "dir": os.path.join(SOURCE_DIR,""), # e.g. "interventions"
-    #     "model": None, # e.g. Intervention
-    #     "foreign_keys": [], # e.g. ["intervention_types"]
-    #     "foreign_key_models": [] # e.g. [InterventionType]
-    # },
-}
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_MODELS:
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data(
-                self,
-                model_name,
-                _metadata,
-                verbose
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from reports.models import Intervention, InterventionType  # Replace 'your_app_name' with the actual app name
+import os
+from reports.dataloader_utils import load_model_data
+
+SOURCE_DIR = None # e.g. settings.DATA_DIR_INTERVENTION
+
+IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
+]
+
+IMPORT_METADATA = {
+    # "": { # same as model name in "import models", e.g. "Intervention"
+    #     "dir": os.path.join(SOURCE_DIR,""), # e.g. "interventions"
+    #     "model": None, # e.g. Intervention
+    #     "foreign_keys": [], # e.g. ["intervention_types"]
+    #     "foreign_key_models": [] # e.g. [InterventionType]
+    # },
+}
+
+class Command(BaseCommand):
+    help = """Load all .yaml files in the data/intervention directory
+    into the Intervention and InterventionType model"""
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Display verbose output',
+        )
+
+    def handle(self, *args, **options):
+        verbose = options['verbose']
+        for model_name in IMPORT_MODELS:
+            _metadata = IMPORT_METADATA[model_name]
+            load_model_data(
+                self,
+                model_name,
+                _metadata,
+                verbose
             )

endoreg_db/management/commands/delete_all.py

@@ -1,18 +1,18 @@
-from django.core.management.base import BaseCommand
-from django.apps import apps
-from django.db import transaction
-
-class Command(BaseCommand):
-    help = 'Deletes all objects from all models in the "endoreg_db" app.'
-
-    def handle(self, *args, **options):
-        app_models = apps.get_models()
-        app_models = [model for model in app_models if "endoreg_db" in model._meta.app_label]  # Filter models by the "endoreg_db" app
-        for model in app_models:
-            with transaction.atomic():  # Use a separate transaction for each model
-                try:
-                    model.objects.all().delete()
-                    self.stdout.write(self.style.SUCCESS(f'Successfully deleted all objects in {model._meta.db_table}'))
-                except Exception as e:
-                    # This catches exceptions and continues with the next model
-                    self.stdout.write(self.style.ERROR(f'Error deleting objects in {model._meta.db_table}: {e}'))
+from django.core.management.base import BaseCommand
+from django.apps import apps
+from django.db import transaction
+
+class Command(BaseCommand):
+    help = 'Deletes all objects from all models in the "endoreg_db" app.'
+
+    def handle(self, *args, **options):
+        app_models = apps.get_models()
+        app_models = [model for model in app_models if "endoreg_db" in model._meta.app_label]  # Filter models by the "endoreg_db" app
+        for model in app_models:
+            with transaction.atomic():  # Use a separate transaction for each model
+                try:
+                    model.objects.all().delete()
+                    self.stdout.write(self.style.SUCCESS(f'Successfully deleted all objects in {model._meta.db_table}'))
+                except Exception as e:
+                    # This catches exceptions and continues with the next model
+                    self.stdout.write(self.style.ERROR(f'Error deleting objects in {model._meta.db_table}: {e}'))

endoreg_db/management/commands/delete_legacy_images.py

@@ -1,19 +1,19 @@
-# django command to delete all LegacyImage objects
-
-from django.core.management.base import BaseCommand, CommandError
-from endoreg_db.models import LegacyImage
-from tqdm import tqdm
-
-class Command(BaseCommand):
-    help = 'Deletes all LegacyImage objects including the linked files (legacy_image.image)'
-
-    def handle(self, *args, **options):
-        legacy_images = LegacyImage.objects.all()
-
-        for legacy_image in tqdm(legacy_images):
-            legacy_image.image.delete()
-            legacy_image.delete()
-
-        self.stdout.write(self.style.SUCCESS('Successfully deleted all LegacyImage objects and linked image files'))
-
-
+# django command to delete all LegacyImage objects
+
+from django.core.management.base import BaseCommand, CommandError
+from endoreg_db.models import LegacyImage
+from tqdm import tqdm
+
+class Command(BaseCommand):
+    help = 'Deletes all LegacyImage objects including the linked files (legacy_image.image)'
+
+    def handle(self, *args, **options):
+        legacy_images = LegacyImage.objects.all()
+
+        for legacy_image in tqdm(legacy_images):
+            legacy_image.image.delete()
+            legacy_image.delete()
+
+        self.stdout.write(self.style.SUCCESS('Successfully deleted all LegacyImage objects and linked image files'))
+
+

endoreg_db/management/commands/delete_legacy_videos.py

@@ -1,17 +1,17 @@
-# Django command to fetch all LegacyVideo objects, delete the associated file and delete the object from the database
-
-from endoreg_db.models.data_file.video import LegacyVideo
-from tqdm import tqdm
-from django.core.management.base import BaseCommand
-
-class Command(BaseCommand):
-    """
-    Deletes all LegacyVideos in the database.
-    """
-    help = 'Deletes all LegacyVideos in the database.'
-
-    def handle(self, *args, **options):
-        videos = LegacyVideo.objects.all()
-        for video in tqdm(videos):
-            video.file.delete()
+# Django command to fetch all LegacyVideo objects, delete the associated file and delete the object from the database
+
+from endoreg_db.models.data_file.video import LegacyVideo
+from tqdm import tqdm
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    """
+    Deletes all LegacyVideos in the database.
+    """
+    help = 'Deletes all LegacyVideos in the database.'
+
+    def handle(self, *args, **options):
+        videos = LegacyVideo.objects.all()
+        for video in tqdm(videos):
+            video.file.delete()
             video.delete()

endoreg_db/management/commands/extract_legacy_video_frames.py

@@ -1,18 +1,18 @@
-# Django Command to:
-# fetch all LegacyVideos and extract frames from them 
-# track progress for all videos and for each video with tqdm
-
-from endoreg_db.models.data_file.video import LegacyVideo
-from tqdm import tqdm
-from django.core.management.base import BaseCommand
-
-class Command(BaseCommand):
-    """
-    Extracts frames from all LegacyVideos in the database.
-    """
-    help = 'Extracts frames from all LegacyVideos in the database.'
-
-    def handle(self, *args, **options):
-        videos = LegacyVideo.objects.all()
-        for video in tqdm(videos):
-            video.extract_all_frames()
+# Django Command to:
+# fetch all LegacyVideos and extract frames from them 
+# track progress for all videos and for each video with tqdm
+
+from endoreg_db.models.data_file.video import LegacyVideo
+from tqdm import tqdm
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    """
+    Extracts frames from all LegacyVideos in the database.
+    """
+    help = 'Extracts frames from all LegacyVideos in the database.'
+
+    def handle(self, *args, **options):
+        videos = LegacyVideo.objects.all()
+        for video in tqdm(videos):
+            video.extract_all_frames()

endoreg_db/management/commands/fetch_legacy_image_dataset.py

@@ -1,32 +1,32 @@
-# command to fetch the legacy dataset and save it to a json file.
-from django.core.management.base import BaseCommand, CommandError
-from endoreg_db.queries import generate_legacy_dataset_output 
-import json
-
-LABELSET_NAME = "multilabel_classification"
-LABELSET_VERSION = 0
-
-class Command(BaseCommand):
-    help = 'Fetches the legacy dataset and saves it to a jsonl file'
-
-    def handle(self, *args, **options):
-        output, labelset = generate_legacy_dataset_output(LABELSET_NAME, LABELSET_VERSION)
-        # output is a list of dicts, each dict is an image
-        labels_in_order = labelset.get_labels_in_order()
-
-        # write to file
-        with open('legacy_dataset.jsonl', 'w') as f:
-            for img_dict in output:
-                f.write(json.dumps(img_dict) + '\n')
-
-
-        _dict = {
-            "labels": [label.name for label in labels_in_order],
-            "name": LABELSET_NAME,
-            "version": LABELSET_VERSION
-        }
-
-        with open('legacy_dataset_info.json', 'w') as f:
-            f.write(json.dumps(_dict))
-
-        self.stdout.write(self.style.SUCCESS('Successfully fetched and saved the legacy dataset'))
+# command to fetch the legacy dataset and save it to a json file.
+from django.core.management.base import BaseCommand, CommandError
+from endoreg_db.queries import generate_legacy_dataset_output 
+import json
+
+LABELSET_NAME = "multilabel_classification"
+LABELSET_VERSION = 0
+
+class Command(BaseCommand):
+    help = 'Fetches the legacy dataset and saves it to a jsonl file'
+
+    def handle(self, *args, **options):
+        output, labelset = generate_legacy_dataset_output(LABELSET_NAME, LABELSET_VERSION)
+        # output is a list of dicts, each dict is an image
+        labels_in_order = labelset.get_labels_in_order()
+
+        # write to file
+        with open('legacy_dataset.jsonl', 'w') as f:
+            for img_dict in output:
+                f.write(json.dumps(img_dict) + '\n')
+
+
+        _dict = {
+            "labels": [label.name for label in labels_in_order],
+            "name": LABELSET_NAME,
+            "version": LABELSET_VERSION
+        }
+
+        with open('legacy_dataset_info.json', 'w') as f:
+            f.write(json.dumps(_dict))
+
+        self.stdout.write(self.style.SUCCESS('Successfully fetched and saved the legacy dataset'))

endoreg_db/management/commands/fix_auth_permission.py

@@ -1,20 +1,20 @@
-from django.core.management.base import BaseCommand
-from django.contrib.auth.models import Permission
-from django.contrib.contenttypes.models import ContentType
-from django.apps import apps
-
-class Command(BaseCommand):
-    help = 'Sets up default permissions for each model in the app.'
-
-    def handle(self, *args, **options):
-        for model in apps.get_models():
-            content_type = ContentType.objects.get_for_model(model)
-            permissions = ['view', 'add', 'change', 'delete']
-            for perm in permissions:
-                codename = f'{perm}_{model._meta.model_name}'
-                name = f'Can {perm} {model._meta.verbose_name}'
-                Permission.objects.get_or_create(
-                    codename=codename,
-                    defaults={'name': name, 'content_type': content_type},
-                )
-            self.stdout.write(self.style.SUCCESS(f'Set up permissions for {model._meta.verbose_name}'))
+from django.core.management.base import BaseCommand
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.apps import apps
+
+class Command(BaseCommand):
+    help = 'Sets up default permissions for each model in the app.'
+
+    def handle(self, *args, **options):
+        for model in apps.get_models():
+            content_type = ContentType.objects.get_for_model(model)
+            permissions = ['view', 'add', 'change', 'delete']
+            for perm in permissions:
+                codename = f'{perm}_{model._meta.model_name}'
+                name = f'Can {perm} {model._meta.verbose_name}'
+                Permission.objects.get_or_create(
+                    codename=codename,
+                    defaults={'name': name, 'content_type': content_type},
+                )
+            self.stdout.write(self.style.SUCCESS(f'Set up permissions for {model._meta.verbose_name}'))

endoreg_db/management/commands/import_legacy_images.py

@@ -1,94 +1,94 @@
-# command expects a directory as an argument
-# directory should contain a img_dicts.jsonl file, a settings.json and an "images" directory
-# images should be in jpeg format
-# reads the img_dicts.jsonl file and creates a new database entry for each image
-# img_dicts contains a line for each image in the following format:
-# {"id": 30604292, "path": "images/30604292.jpg", "labels": ["appendix", "polyp"]}
-
-# import_settings.json example:
-# {
-#     "annotator": "legacy",
-#     "labelset_name": "multilabel_classification",
-#     "labelset_version": 0
-# }
-
-import os
-import json
-from tqdm import tqdm
-from django.core.management.base import BaseCommand
-from endoreg_db.models import LegacyImage, LabelSet, Label, ImageClassificationAnnotation
-from django.core.files import File
-from uuid import uuid4
-
-class Command(BaseCommand):
-    """
-    Imports images from a directory into the database
-
-    Usage:
-        python manage.py import_legacy_images <directory>
-    """
-    help = 'Imports images from a directory into the database'
-
-    def add_arguments(self, parser):
-        parser.add_argument('directory', type=str)
-
-    def handle(self, *args, **options):
-        directory = options['directory']
-        if not os.path.isdir(directory):
-            raise Exception(f"Directory {directory} does not exist")
-
-        # read settings.json
-        with open(os.path.join(directory, 'import_settings.json'), 'r') as f:
-            settings = json.load(f)
-
-        # read img_dicts.jsonl
-        with open(os.path.join(directory, 'img_dicts.jsonl'), 'r') as f:
-            img_dicts = [json.loads(line) for line in f.readlines()]
-
-        # get labelset
-        labelset_name = settings['labelset_name']
-        labelset_version = settings['labelset_version']
-        try:
-            labelset = LabelSet.objects.get(name=labelset_name, version=labelset_version)
-        except LabelSet.DoesNotExist:
-            raise Exception(f"No labelset found with the name {labelset_name} and version {labelset_version}")
-
-
-        # get labels in dict to lookup by name
-        labels = {label.name: label for label in labelset.labels.all()}
-
-        # create images and image_classification_annotations
-        for img_dict in tqdm(img_dicts):
-
-            # Open the image file
-            with open(os.path.join(directory, img_dict['path']), 'rb') as f:
-                # Create the Django File object
-                django_file = File(f)
-                
-                # Extract only the filename
-                filename = os.path.basename(img_dict['path'])
-                img_suffix = os.path.splitext(filename)[1]
-                # assign uuid as new filename
-                filename = str(uuid4()) + img_suffix
-                
-
-                # Create a new LegacyImage instance and save the image
-                image = LegacyImage(image=filename, suffix=img_suffix)
-                image.image.save(filename, django_file, save=True)
-
-                image_annotations = []
-                for label_name, label in labels.items():
-                    if label_name in img_dict['labels']:
-                        value = True
-                    else:
-                        value = False
-
-                    image_annotations.append(ImageClassificationAnnotation(
-                        legacy_image=image,
-                        label=label,
-                        value=value,
-                        annotator=settings['annotator']
-                    ))
-
-                ImageClassificationAnnotation.objects.bulk_create(image_annotations)
-
+# command expects a directory as an argument
+# directory should contain a img_dicts.jsonl file, a settings.json and an "images" directory
+# images should be in jpeg format
+# reads the img_dicts.jsonl file and creates a new database entry for each image
+# img_dicts contains a line for each image in the following format:
+# {"id": 30604292, "path": "images/30604292.jpg", "labels": ["appendix", "polyp"]}
+
+# import_settings.json example:
+# {
+#     "annotator": "legacy",
+#     "labelset_name": "multilabel_classification",
+#     "labelset_version": 0
+# }
+
+import os
+import json
+from tqdm import tqdm
+from django.core.management.base import BaseCommand
+from endoreg_db.models import LegacyImage, LabelSet, Label, ImageClassificationAnnotation
+from django.core.files import File
+from uuid import uuid4
+
+class Command(BaseCommand):
+    """
+    Imports images from a directory into the database
+
+    Usage:
+        python manage.py import_legacy_images <directory>
+    """
+    help = 'Imports images from a directory into the database'
+
+    def add_arguments(self, parser):
+        parser.add_argument('directory', type=str)
+
+    def handle(self, *args, **options):
+        directory = options['directory']
+        if not os.path.isdir(directory):
+            raise Exception(f"Directory {directory} does not exist")
+
+        # read settings.json
+        with open(os.path.join(directory, 'import_settings.json'), 'r') as f:
+            settings = json.load(f)
+
+        # read img_dicts.jsonl
+        with open(os.path.join(directory, 'img_dicts.jsonl'), 'r') as f:
+            img_dicts = [json.loads(line) for line in f.readlines()]
+
+        # get labelset
+        labelset_name = settings['labelset_name']
+        labelset_version = settings['labelset_version']
+        try:
+            labelset = LabelSet.objects.get(name=labelset_name, version=labelset_version)
+        except LabelSet.DoesNotExist:
+            raise Exception(f"No labelset found with the name {labelset_name} and version {labelset_version}")
+
+
+        # get labels in dict to lookup by name
+        labels = {label.name: label for label in labelset.labels.all()}
+
+        # create images and image_classification_annotations
+        for img_dict in tqdm(img_dicts):
+
+            # Open the image file
+            with open(os.path.join(directory, img_dict['path']), 'rb') as f:
+                # Create the Django File object
+                django_file = File(f)
+                
+                # Extract only the filename
+                filename = os.path.basename(img_dict['path'])
+                img_suffix = os.path.splitext(filename)[1]
+                # assign uuid as new filename
+                filename = str(uuid4()) + img_suffix
+                
+
+                # Create a new LegacyImage instance and save the image
+                image = LegacyImage(image=filename, suffix=img_suffix)
+                image.image.save(filename, django_file, save=True)
+
+                image_annotations = []
+                for label_name, label in labels.items():
+                    if label_name in img_dict['labels']:
+                        value = True
+                    else:
+                        value = False
+
+                    image_annotations.append(ImageClassificationAnnotation(
+                        legacy_image=image,
+                        label=label,
+                        value=value,
+                        annotator=settings['annotator']
+                    ))
+
+                ImageClassificationAnnotation.objects.bulk_create(image_annotations)
+