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

endoreg_db/serializers/prediction.py

@@ -1,15 +1,15 @@
-from rest_framework import serializers
-from endoreg_db.models import (
-    ImageClassificationPrediction,
-    LegacyVideoPredictionMeta
-)
-
-class ImageClassificationPredictionSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ImageClassificationPrediction
-        fields = '__all__'
-
-class LegacyVideoPredictionMetaSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyVideoPredictionMeta
-        fields = '__all__'
+from rest_framework import serializers
+from endoreg_db.models import (
+    ImageClassificationPrediction,
+    LegacyVideoPredictionMeta
+)
+
+class ImageClassificationPredictionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ImageClassificationPrediction
+        fields = '__all__'
+
+class LegacyVideoPredictionMetaSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LegacyVideoPredictionMeta
+        fields = '__all__'

endoreg_db/serializers/report_file.py

@@ -1,7 +1,7 @@
-from rest_framework import serializers
-from endoreg_db.models import ReportFile
-
-class ReportFileSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = ReportFile
-        fields = '__all__'
+from rest_framework import serializers
+from endoreg_db.models import ReportFile
+
+class ReportFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ReportFile
+        fields = '__all__'

endoreg_db/serializers/video.py

@@ -1,27 +1,27 @@
-from rest_framework import serializers
-from endoreg_db.models import Video, LegacyVideo, VideoImportMeta, LegacyLabelVideoSegment, LabelVideoSegment
-
-class VideoSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Video
-        fields = '__all__'
-
-class LegacyVideoSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyVideo
-        fields = '__all__'
-
-class VideoImportMetaSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = VideoImportMeta
-        fields = '__all__'
-
-class LabelVideoSegmentSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LabelVideoSegment
-        fields = '__all__'
-
-class LegacyLabelVideoSegmentSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyLabelVideoSegment
-        fields = '__all__'
+from rest_framework import serializers
+from endoreg_db.models import Video, LegacyVideo, VideoImportMeta, LegacyLabelVideoSegment, LabelVideoSegment
+
+class VideoSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Video
+        fields = '__all__'
+
+class LegacyVideoSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LegacyVideo
+        fields = '__all__'
+
+class VideoImportMetaSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = VideoImportMeta
+        fields = '__all__'
+
+class LabelVideoSegmentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LabelVideoSegment
+        fields = '__all__'
+
+class LegacyLabelVideoSegmentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LegacyLabelVideoSegment
+        fields = '__all__'

endoreg_db/tests.py

@@ -1,3 +1,3 @@
-from django.test import TestCase
-
-# Create your tests here.
+from django.test import TestCase
+
+# Create your tests here.

endoreg_db/utils/cropping.py

@@ -1,29 +1,29 @@
-from PIL import Image
-
-def crop_and_insert(image:Image, x, y, h, w, bg_color=(255, 255, 255)):
-    """
-    Crops a region from an inverted grayscale image and inserts it into a white image of the same size as the original.
-    
-    Parameters:
-    - fp: File path or a file object of the original image.
-    - x, y: The top-left coordinates of the rectangle to be cropped.
-    - h, w: The height and width of the rectangle to be cropped.
-    
-    Returns:
-    A PIL Image object containing the original image with the specified region replaced.
-    """
-    # Load the original image
-    original_image = image
-    
-    # Crop the specified region from the inverted image
-    crop_rectangle = (x, y, x + w, y + h)
-    cropped_content = original_image.crop(crop_rectangle)
-    
-    # Create a new white image of the same size as the original image
-    white_background = Image.new('RGB', original_image.size, bg_color)
-    
-    # Paste the cropped content onto the white image at the specified location
-    white_background.paste(cropped_content, (x, y))
-    
-    # The final image can be displayed or saved as needed
+from PIL import Image
+
+def crop_and_insert(image:Image, x, y, h, w, bg_color=(255, 255, 255)):
+    """
+    Crops a region from an inverted grayscale image and inserts it into a white image of the same size as the original.
+    
+    Parameters:
+    - fp: File path or a file object of the original image.
+    - x, y: The top-left coordinates of the rectangle to be cropped.
+    - h, w: The height and width of the rectangle to be cropped.
+    
+    Returns:
+    A PIL Image object containing the original image with the specified region replaced.
+    """
+    # Load the original image
+    original_image = image
+    
+    # Crop the specified region from the inverted image
+    crop_rectangle = (x, y, x + w, y + h)
+    cropped_content = original_image.crop(crop_rectangle)
+    
+    # Create a new white image of the same size as the original image
+    white_background = Image.new('RGB', original_image.size, bg_color)
+    
+    # Paste the cropped content onto the white image at the specified location
+    white_background.paste(cropped_content, (x, y))
+    
+    # The final image can be displayed or saved as needed
     return white_background

endoreg_db/utils/dataloader.py

@@ -1,185 +1,92 @@
-import os
-import yaml
-from django.core.exceptions import ObjectDoesNotExist
-
-def load_model_data_from_yaml(command, model_name, metadata, verbose):
-    """
-    Load model data from YAML files.
-    
-    Args:
-        command: Command object for stdout writing.
-        model_name: Name of the model being loaded.
-        metadata: Metadata including directory and foreign key information.
-        verbose: Boolean indicating whether to print verbose output.
-    """
-    if verbose:
-        command.stdout.write(f"Start loading {model_name}")
-    model = metadata["model"]
-    dir_path = metadata["dir"]
-    foreign_keys = metadata["foreign_keys"]
-    foreign_key_models = metadata["foreign_key_models"]
-
-    for file in [f for f in os.listdir(dir_path) if f.endswith('.yaml')]:
-        with open(os.path.join(dir_path, file), 'r') as file:
-            yaml_data = yaml.safe_load(file)
-        
-        load_data_with_foreign_keys(command, model, yaml_data, foreign_keys, foreign_key_models, verbose)
-
-def load_data_with_foreign_keys(command, model, yaml_data, foreign_keys, foreign_key_models, verbose):
-    """
-    Load data handling foreign keys and many-to-many relationships.
-    
-    Args:
-        command: Command object for stdout writing.
-        model: The Django model for the data.
-        yaml_data: Data loaded from YAML.
-        foreign_keys: List of foreign keys.
-        foreign_key_models: Corresponding models for the foreign keys.
-        verbose: Boolean indicating whether to print verbose output.
-    """
-    for entry in yaml_data:
-        fields = entry.get('fields', {})
-        name = fields.pop('name', None)
-        m2m_relationships = {}  # Store many-to-many relationships
-
-        # Handle foreign keys and many-to-many relationships
-        for fk_field, fk_model in zip(foreign_keys, foreign_key_models):
-            target_keys = fields.pop(fk_field, None)
-            
-            # Ensure the foreign key exists
-            if target_keys is None:
-                if verbose:
-                    command.stdout.write(command.style.WARNING(f"Foreign key {fk_field} not found in fields"))
-                continue  # Skip if no foreign key provided
-
-            # Process many-to-many fields or foreign keys
-            if isinstance(target_keys, list):  # Assume many-to-many relationship
-                related_objects = []
-                for key in target_keys:
-                    obj, created = fk_model.objects.get_or_create(name=key)
-                    if created and verbose:
-                        command.stdout.write(command.style.SUCCESS(f"Created {fk_model.__name__} {key}"))
-                    related_objects.append(obj)
-                m2m_relationships[fk_field] = related_objects
-            else:  # Single foreign key relationship
-                try:
-                    obj = fk_model.objects.get_by_natural_key(target_keys)
-                except ObjectDoesNotExist:
-                    if verbose:
-                        command.stdout.write(command.style.WARNING(f"{fk_model.__name__} with key {target_keys} not found"))
-                    continue
-                fields[fk_field] = obj
-
-        # Create or update the main object
-        obj, created = model.objects.update_or_create(defaults=fields, name=name)
-        if created and verbose:
-            command.stdout.write(command.style.SUCCESS(f'Created {model.__name__} {name}'))
-        elif verbose:
-            command.stdout.write(command.style.WARNING(f'Skipped {model.__name__} {name}, already exists'))
-
-        # Set many-to-many relationships
-        for field_name, related_objs in m2m_relationships.items():
-            getattr(obj, field_name).set(related_objs)
-
-
-# def load_model_data_from_yaml(
-#         command,
-#         model_name,
-#         metadata,
-#         verbose,
-#     ):
-
-#     if verbose:
-#         command.stdout.write(f"Start Loading {model_name}")
-#     model = metadata["model"]
-#     dir = metadata["dir"]
-#     foreign_keys = metadata["foreign_keys"]
-#     foreign_key_models = metadata["foreign_key_models"]
-
-#     for file in [f for f in os.listdir(dir) if f.endswith('.yaml')]:
-#         with open(os.path.join(dir, file), 'r') as f:
-#             yaml_data = yaml.safe_load(f)
-        
-#         load_data_with_foreign_keys(
-#             command,
-#             model,
-#             yaml_data,
-#             foreign_keys,
-#             foreign_key_models,
-#             verbose
-#         )
-
-# def load_data_with_foreign_keys(command, model, yaml_data, foreign_keys, foreign_key_models, verbose):
-#             # Since pathology types is a ManyToMany field, we need to hack arount
-#             for entry in yaml_data:
-#                 fields = entry.get('fields', {})
-#                 name = fields.pop('name', None)
-#                 many_to_many_tuples = []
-#                 foreign_key_tuples = zip(foreign_keys, foreign_key_models)
-#                 for foreign_key, foreign_key_model in foreign_key_tuples:
-#                     # target_natural_key = fields.pop(foreign_key, None)
-#                     # get the target natural key, if it exists, should not alter fields
-#                     target_natural_key = fields.get(foreign_key, None)
-#                     assert target_natural_key, f"Foreign Key {foreign_key} not found in fields {fields}"
-   
-#                     if (foreign_key == "first_names") or (foreign_key == "last_names"):
-#                         if isinstance(target_natural_key, list):
-#                             # For first_names and last_names, the field is a Many to Many field
-#                             # if names dont exist yet, we create them
-#                             fk_objects = []
-#                             for __name in target_natural_key:
-#                                 obj, created = foreign_key_model.objects.get_or_create(name=__name)
-#                                 if created:
-#                                     command.stdout.write(command.style.SUCCESS(f'Created {foreign_key_model.__name__} {__name}'))
-#                                 # fk_objects.append(obj)
-
-#                             fk_tuple = (foreign_key, fk_objects)
-#                             many_to_many_tuples.append(fk_tuple)
-#                         continue
-
-#                     if isinstance(target_natural_key, list):
-#                         # the field is a Many to X field.
-#                         fk_objects = [foreign_key_model.objects.get_by_natural_key(_) for _ in target_natural_key]
-#                         fk_tuple = (foreign_key, fk_objects)
-#                         many_to_many_tuples.append(fk_tuple)
-#                         continue
-#                     # Use the natural key to look up the related object
-#                     try:
-#                         obj = foreign_key_model.objects.get_by_natural_key(target_natural_key)
-#                     except:
-#                         # commandline log that the object was not found
-#                         command.stdout.write(command.style.WARNING(f'Object {foreign_key_model.__name__} {target_natural_key} not found'))
-#                         # commandline log entry
-#                         command.stdout.write(command.style.WARNING(_log))
-#                         # try to create by name if name is available
-#                         # create defaults dict from fields using the models fields
-#                         _field_names = [_.name for _ in foreign_key_model._meta.fields]
-#                         _defaults = {k: v for k, v in fields.items() if (k in _field_names) and v}
-                        
-#                         if target_natural_key:
-#                         # commandlie log
-#                             command.stdout.write(command.style.SUCCESS(f'Creating {foreign_key_model.__name__} {name} with defaults {_defaults}'))
-#                             obj, created = model.objects.get_or_create(
-#                                 name = target_natural_key,
-#                                 defaults=_defaults
-#                             )
-#                     # Assign the related object to the field
-#                     fields[foreign_key] = obj
-
-#                 if name:
-#                     try:
-#                         obj, created = model.objects.get_or_create(name=name, defaults=fields)
-#                     except:
-#                         # commandlinelog to print name, fields, target foreign key
-#                         command.stdout.write(command.style.WARNING(f'Object {model.__name__} {name} not found'))
-#                 else:
-#                     obj, created = model.objects.get_or_create(**fields)
-#                 if many_to_many_tuples:
-
-#                     for fk, fk_objects in many_to_many_tuples:
-#                         getattr(obj, fk).set(fk_objects)
-
-#                 if created and verbose:
-#                     command.stdout.write(command.style.SUCCESS(f'Created {model.__name__} {name}'))
-#                 elif verbose:
-#                     command.stdout.write(command.style.WARNING(f'Skipped {model.__name__} {name}, already exists'))
+import os
+import yaml
+from django.core.exceptions import ObjectDoesNotExist
+
+def load_model_data_from_yaml(command, model_name, metadata, verbose):
+    """
+    Load model data from YAML files.
+    
+    Args:
+        command: Command object for stdout writing.
+        model_name: Name of the model being loaded.
+        metadata: Metadata including directory and foreign key information.
+        verbose: Boolean indicating whether to print verbose output.
+    """
+    if verbose:
+        command.stdout.write(f"Start loading {model_name}")
+    model = metadata["model"]
+    dir_path = metadata["dir"]
+    foreign_keys = metadata["foreign_keys"]
+    foreign_key_models = metadata["foreign_key_models"]
+
+    _files = [f for f in os.listdir(dir_path) if f.endswith('.yaml')]
+    # sort
+    _files.sort()
+    for file in _files:
+        with open(os.path.join(dir_path, file), 'r') as file:
+            yaml_data = yaml.safe_load(file)
+        
+        load_data_with_foreign_keys(command, model, yaml_data, foreign_keys, foreign_key_models, verbose)
+
+def load_data_with_foreign_keys(command, model, yaml_data, foreign_keys, foreign_key_models, verbose):
+    """
+    Load data handling foreign keys and many-to-many relationships.
+    
+    Args:
+        command: Command object for stdout writing.
+        model: The Django model for the data.
+        yaml_data: Data loaded from YAML.
+        foreign_keys: List of foreign keys.
+        foreign_key_models: Corresponding models for the foreign keys.
+        verbose: Boolean indicating whether to print verbose output.
+    """
+    for entry in yaml_data:
+        fields = entry.get('fields', {})
+        name = fields.pop('name', None)
+        m2m_relationships = {}  # Store many-to-many relationships
+        print(entry)
+
+        # Handle foreign keys and many-to-many relationships
+        for fk_field, fk_model in zip(foreign_keys, foreign_key_models):
+            print(fk_field, fk_model)
+            target_keys = fields.pop(fk_field, None)
+            
+            # Ensure the foreign key exists
+            if target_keys is None:
+                if verbose:
+                    command.stdout.write(command.style.WARNING(f"Foreign key {fk_field} not found in fields"))
+                continue  # Skip if no foreign key provided
+
+            # Process many-to-many fields or foreign keys
+            if isinstance(target_keys, list):  # Assume many-to-many relationship
+                related_objects = []
+                for key in target_keys:
+                    obj, created = fk_model.objects.get_or_create(name=key)
+                    if created and verbose:
+                        command.stdout.write(command.style.SUCCESS(f"Created {fk_model.__name__} {key}"))
+                    related_objects.append(obj)
+                m2m_relationships[fk_field] = related_objects
+            else:  # Single foreign key relationship
+                try:
+                    if model == "endoreg_db.case_template_rule":
+                        print(fk_model, target_keys)
+                    obj = fk_model.objects.get_by_natural_key(target_keys)
+                except ObjectDoesNotExist:
+                    if verbose:
+                        command.stdout.write(command.style.WARNING(f"{fk_model.__name__} with key {target_keys} not found"))
+                    continue
+                fields[fk_field] = obj
+    
+        # Create or update the main object
+        if name is None:
+            obj, created = model.objects.get_or_create(**fields)
+        else:
+            obj, created = model.objects.update_or_create(defaults=fields, name=name)
+        if created and verbose:
+            command.stdout.write(command.style.SUCCESS(f'Created {model.__name__} {name}'))
+        elif verbose:
+            command.stdout.write(command.style.WARNING(f'Skipped {model.__name__} {name}, already exists'))
+
+        # Set many-to-many relationships
+        for field_name, related_objs in m2m_relationships.items():
+            getattr(obj, field_name).set(related_objs)

endoreg_db/utils/file_operations.py

@@ -1,30 +1,30 @@
-import shutil
-from pathlib import Path
-from endoreg_db.utils.uuid import get_uuid
-
-def get_uuid_filename(file:Path) -> tuple[str, str]:
-    """
-    Returns a new filename with a uuid
-    """
-    # Get the file extension
-    file_extension = file.suffix
-    # Generate a new file name
-    uuid = get_uuid()
-    new_file_name = f"{uuid}{file_extension}"
-    return new_file_name, uuid
-    
-def rename_file_uuid(old_file:Path):
-    """
-    Rename a file by assigning a uuid while preserving file extension. Returns new filepath and uuid
-    """
-    # Get the file extension
-    file_extension = old_file.suffix
-    # Generate a new file name
-    uuid = get_uuid()
-    new_file_name = f"{uuid}{file_extension}"
-
-    # Rename the file
-    new_file = old_file.with_name(new_file_name)
-    shutil.move(old_file.resolve().as_posix(), new_file.resolve().as_posix())
-
-    return new_file, uuid
+import shutil
+from pathlib import Path
+from endoreg_db.utils.uuid import get_uuid
+
+def get_uuid_filename(file:Path) -> tuple[str, str]:
+    """
+    Returns a new filename with a uuid
+    """
+    # Get the file extension
+    file_extension = file.suffix
+    # Generate a new file name
+    uuid = get_uuid()
+    new_file_name = f"{uuid}{file_extension}"
+    return new_file_name, uuid
+    
+def rename_file_uuid(old_file:Path):
+    """
+    Rename a file by assigning a uuid while preserving file extension. Returns new filepath and uuid
+    """
+    # Get the file extension
+    file_extension = old_file.suffix
+    # Generate a new file name
+    uuid = get_uuid()
+    new_file_name = f"{uuid}{file_extension}"
+
+    # Rename the file
+    new_file = old_file.with_name(new_file_name)
+    shutil.move(old_file.resolve().as_posix(), new_file.resolve().as_posix())
+
+    return new_file, uuid

endoreg_db/utils/hashs.py

@@ -1,34 +1,34 @@
-import hashlib
-from pathlib import Path
-
-def get_video_hash(video_path):
-    """
-    Get the hash of a video file.
-    """
-    # Open the video file in read-binary mode:
-    with open(video_path, 'rb') as f:
-        # Create the hash object, passing in the video contents for hashing:
-        hash_object = hashlib.sha256(f.read())
-        # Get the hexadecimal representation of the hash
-        video_hash = hash_object.hexdigest()
-        assert len(video_hash) <= 255, "Hash length exceeds 255 characters"
-
-    return video_hash
-
-def get_pdf_hash(pdf_path:Path):
-    """
-    Get the hash of a pdf file.
-    """
-    pdf_hash = None
-
-    # Open the file in binary mode and read its contents
-    with open(pdf_path, 'rb') as f:
-        pdf_contents = f.read()
-        # Create a hash object using SHA-256 algorithm
-
-    hash_object = hashlib.sha256(pdf_contents, usedforsecurity=False)
-    # Get the hexadecimal representation of the hash
-    pdf_hash = hash_object.hexdigest()
-    assert len(pdf_hash) <= 255, "Hash length exceeds 255 characters"
-
+import hashlib
+from pathlib import Path
+
+def get_video_hash(video_path):
+    """
+    Get the hash of a video file.
+    """
+    # Open the video file in read-binary mode:
+    with open(video_path, 'rb') as f:
+        # Create the hash object, passing in the video contents for hashing:
+        hash_object = hashlib.sha256(f.read())
+        # Get the hexadecimal representation of the hash
+        video_hash = hash_object.hexdigest()
+        assert len(video_hash) <= 255, "Hash length exceeds 255 characters"
+
+    return video_hash
+
+def get_pdf_hash(pdf_path:Path):
+    """
+    Get the hash of a pdf file.
+    """
+    pdf_hash = None
+
+    # Open the file in binary mode and read its contents
+    with open(pdf_path, 'rb') as f:
+        pdf_contents = f.read()
+        # Create a hash object using SHA-256 algorithm
+
+    hash_object = hashlib.sha256(pdf_contents, usedforsecurity=False)
+    # Get the hexadecimal representation of the hash
+    pdf_hash = hash_object.hexdigest()
+    assert len(pdf_hash) <= 255, "Hash length exceeds 255 characters"
+
     return pdf_hash