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

endoreg_db/models/data_file/import_classes/raw_video.py

@@ -1,343 +0,0 @@
-from django.db import models
-from pathlib import Path
-from collections import defaultdict, Counter
-
-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
-
-import shutil
-import os
-import subprocess
-
-from ..metadata import VideoMeta, SensitiveMeta
-
-class RawVideoFile(models.Model):
-    uuid = models.UUIDField()
-    file = models.FileField(upload_to="raw_data/")
-    
-    sensitive_meta = models.OneToOneField(
-        "SensitiveMeta", on_delete=models.CASCADE, blank=True, null=True
-    ) 
-
-    center = models.ForeignKey("Center", on_delete=models.CASCADE)
-    processor = models.ForeignKey(
-        "EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True
-    )
-    video_meta = models.OneToOneField(
-        "VideoMeta", on_delete=models.CASCADE, blank=True, null=True
-    )
-    original_file_name = models.CharField(max_length=255)
-    video_hash = models.CharField(max_length=255, unique=True)
-    uploaded_at = models.DateTimeField(auto_now_add=True)
-
-    # Frame Extraction States
-    state_frames_required = models.BooleanField(default=True)
-    state_frames_extracted = models.BooleanField(default=False)
-
-    # Video
-    ## Prediction
-    state_initial_prediction_required = models.BooleanField(default=True)
-    state_initial_prediction_completed = models.BooleanField(default=False)
-    state_initial_prediction_import_required = models.BooleanField(default=True)
-    state_initial_prediction_import_completed = models.BooleanField(default=False)
-    ## OCR
-    state_ocr_required = models.BooleanField(default=True)
-    state_ocr_completed = models.BooleanField(default=False)
-    ## Validation
-    state_outside_validated = models.BooleanField(default=False)
-    state_ocr_result_validated = models.BooleanField(default=False)
-
-    state_sensitive_data_retrieved = models.BooleanField(default=False)
-
-    # Dataset complete?
-    state_histology_required = models.BooleanField(blank=True, null=True)
-    state_histology_available = models.BooleanField(default=False)
-    state_follow_up_intervention_required = models.BooleanField(blank=True, null=True)
-    state_follow_up_intervention_available = models.BooleanField(default=False)
-    state_dataset_complete = models.BooleanField(default=False)
-
-    # Finalizing for Upload
-    state_anonym_video_required = models.BooleanField(default=True)
-    state_anonym_video_performed = models.BooleanField(default=False)
-    state_original_reports_deleted = models.BooleanField(default=False)
-    state_original_video_deleted = models.BooleanField(default=False)
-    state_finalized = models.BooleanField(default=False)
-
-    frame_dir = models.CharField(max_length=255)
-    prediction_dir = models.CharField(max_length=255)
-
-    @classmethod
-    def create_from_file(
-        cls,
-        file_path: Path,
-        video_dir: Path,
-        center_name: str,
-        processor_name: str,
-        frame_dir_parent: Path,
-        save: bool = True,
-    ):
-        from endoreg_db.models import Center, EndoscopyProcessor
-
-        print(f"Creating RawVideoFile from {file_path}")
-        original_file_name = file_path.name
-        # Rename and and move
-
-        new_file_name, uuid = get_uuid_filename(file_path)
-        framedir: Path = frame_dir_parent / str(uuid)
-
-        if not framedir.exists():
-            framedir.mkdir(parents=True, exist_ok=True)
-
-        if not video_dir.exists():
-            video_dir.mkdir(parents=True, exist_ok=True)
-
-        video_hash = get_video_hash(file_path)
-
-        center = Center.objects.get(name=center_name)
-        assert center is not None, "Center must exist"
-
-        processor = EndoscopyProcessor.objects.get(name=processor_name)
-        assert processor is not None, "Processor must exist"
-
-        new_filepath = video_dir / new_file_name
-
-        print(f"Moving {file_path} to {new_filepath}")
-        shutil.move(file_path.resolve().as_posix(), new_filepath.resolve().as_posix())
-        print(f"Moved to {new_filepath}")
-
-        # Make sure file was transferred correctly and hash is correct
-        if not new_filepath.exists():
-            print(f"File {file_path} was not transferred correctly to {new_filepath}")
-            return None
-
-        new_hash = get_video_hash(new_filepath)
-        if new_hash != video_hash:
-            print(f"Hash of file {file_path} is not correct")
-            return None
-
-        # make sure that no other file with the same hash exists
-        if cls.objects.filter(video_hash=video_hash).exists():
-            # log and print warnint
-            print(f"File with hash {video_hash} already exists")
-            return None
-
-        else:
-            print(center)
-            # Create a new instance of RawVideoFile
-            raw_video_file = cls(
-                uuid=uuid,
-                file=new_filepath.resolve().as_posix(),
-                center=center,
-                processor=processor,
-                original_file_name=original_file_name,
-                video_hash=video_hash,
-                frame_dir=framedir.as_posix(),
-            )
-
-            # Save the instance to the database
-            raw_video_file.save()
-
-            return raw_video_file
-
-    def __str__(self):
-        return self.file.name
-
-    def get_endo_roi(self):
-        endo_roi = self.video_meta.get_endo_roi()
-        return endo_roi
-
-    # video meta should be created when video file is created
-    def save(self, *args, **kwargs):
-        if self.video_meta is None:
-            center = self.center
-            processor = self.processor
-            self.video_meta = VideoMeta.objects.create(
-                center=center, processor=processor
-            )
-            self.video_meta.initialize_ffmpeg_meta(self.file.path)
-        super(RawVideoFile, self).save(*args, **kwargs)
-
-    def extract_frames(
-        self,
-        quality: int = 2,
-        frame_dir: Path = None,
-        overwrite: bool = False,
-        ext="jpg",
-    ):
-        """
-        Extract frames from the video file and save them to the frame_dir.
-        For this, ffmpeg must be available in in the current environment.
-        """
-        if frame_dir is None:
-            frame_dir = Path(self.frame_dir)
-        else:
-            frame_dir = Path(frame_dir)
-
-        if not frame_dir.exists():
-            frame_dir.mkdir(parents=True, exist_ok=True)
-
-        if not overwrite and len(list(frame_dir.glob("*.jpg"))) > 0:
-            print(f"Frames already extracted for {self.file.name}")
-            return
-
-        video_path = Path(self.file.path).resolve().as_posix()
-
-        frame_path_string = frame_dir.resolve().as_posix()
-        command = [
-            "ffmpeg",
-            "-i",
-            video_path,  #
-            "-q:v",
-            str(quality),
-            os.path.join(frame_path_string, f"frame_%07d.{ext}"),
-        ]
-
-        # Ensure FFmpeg is available
-        if not shutil.which("ffmpeg"):
-            raise EnvironmentError(
-                "FFmpeg could not be found. Ensure it is installed and in your PATH."
-            )
-
-        # Extract frames from the video file
-        # Execute the command
-        result = subprocess.run(command, capture_output=True, text=True)
-        if result.returncode != 0:
-            raise Exception(f"Error extracting frames: {result.stderr}")
-
-        self.state_frames_extracted = True
-
-        return f"Frames extracted to {frame_dir} ({frame_path_string}) with quality {quality}"
-
-    def delete_frames(self):
-        """
-        Delete frames extracted from the video file.
-        """
-        frame_dir = Path(self.frame_dir)
-        if frame_dir.exists():
-            shutil.rmtree(frame_dir)
-            self.state_frames_extracted = False
-            self.save()
-            return f"Frames deleted from {frame_dir}"
-        else:
-            return f"No frames to delete for {self.file.name}"
-
-    def get_frame_path(self, n: int = 0):
-        """
-        Get the path to the n-th frame extracted from the video file.
-        Note that the frame numbering starts at 1 in our naming convention.
-        """
-        # Adjust index
-        n = n + 1
-
-        frame_dir = Path(self.frame_dir)
-        return frame_dir / f"frame_{n:07d}.jpg"
-    
-    def get_frame_paths(self):
-        if not self.state_frames_extracted:
-            return None
-        frame_dir = Path(self.frame_dir)
-        paths = [p for p in frame_dir.glob('*')]
-        indices = [int(p.stem.split("_")[1]) for p in paths]
-        path_index_tuples = list(zip(paths, indices))
-        # sort ascending by index
-        path_index_tuples.sort(key=lambda x: x[1])
-        paths, indices = zip(*path_index_tuples)
-
-        return paths
-
-    def get_prediction_dir(self):
-        return Path(self.prediction_dir)
-
-    def get_predictions_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("predictions").with_suffix(suffix)
-    
-    def get_smooth_predictions_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("smooth_predictions").with_suffix(suffix)
-    
-    def get_binary_predictions_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("binary_predictions").with_suffix(suffix)
-    
-    def get_raw_sequences_path(self, suffix = ".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("raw_sequences").with_suffix(suffix)
-
-    def get_filtered_sequences_path(self, suffix=".json"):
-        pred_dir = self.get_prediction_dir()
-        return pred_dir.joinpath("filtered_sequences").with_suffix(suffix)
-
-    def extract_text_information(self, frame_fraction: float = 0.001):
-        """
-        Extract text information from the video file.
-        Makes sure that frames are extracted and then processes the frames.
-        gets all frames from frame_dir and selects a fraction of them to process (at least 1)
-        """
-        if not self.state_frames_extracted:
-            print(f"Frames not extracted for {self.file.name}")
-            return None
-
-        processor = self.processor
-
-        frame_dir = Path(self.frame_dir)
-        frames = list(frame_dir.glob("*"))
-        n_frames = len(frames)
-        n_frames_to_process = max(1, int(frame_fraction * n_frames))
-
-        # Select evenly spaced frames
-        frames = frames[:: n_frames // n_frames_to_process]
-
-        # extract text from each frame and store the value to
-        # defaultdict of lists.
-        # Then, extract the most frequent value from each list
-        # Finally, return the dictionary of most frequent values
-
-        # Create a defaultdict to store the extracted text from each ROI
-        rois_texts = defaultdict(list)
-
-        print(f"Processing {n_frames_to_process} frames from {self.file.name}")
-        # Process frames
-        for frame_path in frames[:n_frames_to_process]:
-            extracted_texts = extract_text_from_rois(frame_path, processor)
-            for roi, text in extracted_texts.items():
-                rois_texts[roi].append(text)
-
-        # Get the most frequent text values for each ROI using Counter
-        for key in rois_texts.keys():
-            counter = Counter([text for text in rois_texts[key] if text])
-            rois_texts[key] = counter.most_common(1)[0][0] if counter else None
-
-        return rois_texts
-
-    def update_text_metadata(self, ocr_frame_fraction=0.001):
-        print(f"Updating metadata for {self.file.name}")
-        texts = self.extract_text_information(ocr_frame_fraction)
-
-        self.sensitive_meta = SensitiveMeta.create_from_dict(texts)
-        self.state_sensitive_data_retrieved = True
-        self.save()
-
-        # Resulting dict depends on defined ROIs for this processor type!
-
-    def update_video_meta(self):
-        video_meta = self.video_meta
-        video_path = Path(self.file.path)
-
-        if video_meta is None:
-            video_meta = VideoMeta.create_from_video(video_path)
-            self.video_meta = video_meta
-            self.save()
-
-        else:
-            video_meta.update_meta(video_path)
-
-    def get_fps(self):
-        if self.video_meta is None:
-            self.update_video_meta()
-
-        if self.video_meta.ffmpeg_meta is None:
-            self.video_meta.initialize_ffmpeg_meta(self.file.path)
-
-        return self.video_meta.get_fps()

endoreg_db/models/data_file/metadata/__init__.py

@@ -1,3 +0,0 @@
-from .sensitive_meta import SensitiveMeta
-from .pdf_meta import PdfMeta, PdfType
-from .video_meta import VideoMeta, FFMpegMeta, VideoImportMeta

endoreg_db/models/data_file/metadata/sensitive_meta.py

@@ -1,31 +0,0 @@
-from django.db import models
-
-class SensitiveMeta(models.Model):
-    examination_date = models.DateField(blank=True, null=True)
-    patient_first_name = models.CharField(max_length=255, blank=True, null=True)
-    patient_last_name = models.CharField(max_length=255, blank=True, null=True)
-    patient_dob = models.DateField(blank=True, null=True)
-    endoscope_type = models.CharField(max_length=255, blank=True, null=True)
-    endoscope_sn = models.CharField(max_length=255, blank=True, null=True)
-
-    @classmethod
-    def create_from_dict(cls, data: dict):
-        # data can contain more fields than the model has
-        field_names = [_.name for _ in cls._meta.fields]
-        selected_data = {k: v for k, v in data.items() if k in field_names}
-
-        return cls.objects.create(**selected_data)
-    
-    def update_from_dict(self, data: dict):
-        # data can contain more fields than the model has
-        field_names = [_.name for _ in self._meta.fields]
-        selected_data = {k: v for k, v in data.items() if k in field_names}
-
-        for k, v in selected_data.items():
-            setattr(self, k, v)
-        
-        self.save()
-    
-    def __str__(self):
-        return f"SensitiveMeta: {self.examination_date} {self.patient_first_name} {self.patient_last_name} (*{self.patient_dob})"
-    

endoreg_db/models/data_file/metadata/video_meta.py

@@ -1,133 +0,0 @@
-from django.db import models
-import ffmpeg
-from pathlib import Path
-
-# import endoreg_center_id from django settings
-from django.conf import settings
-
-# check if endoreg_center_id is set
-if not hasattr(settings, 'ENDOREG_CENTER_ID'):
-    ENDOREG_CENTER_ID = 9999
-else:
-    ENDOREG_CENTER_ID = settings.ENDOREG_CENTER_ID
-
-# VideoMeta
-class VideoMeta(models.Model):
-    processor = models.ForeignKey('EndoscopyProcessor', on_delete=models.CASCADE, blank=True, null=True)
-    endoscope = models.ForeignKey('Endoscope', on_delete=models.CASCADE, blank=True, null=True)
-    center = models.ForeignKey('Center', on_delete=models.CASCADE)
-    import_meta = models.OneToOneField('VideoImportMeta', on_delete=models.CASCADE, blank=True, null=True)
-    ffmpeg_meta = models.OneToOneField('FFMpegMeta', on_delete=models.CASCADE, blank=True, null=True)
-
-    def __str__(self):
-
-        processor_name = self.processor.name if self.processor is not None else "None"
-        endoscope_name = self.endoscope.name if self.endoscope is not None else "None"
-        center_name = self.center.name if self.center is not None else "None"
-
-        result_html = ""
-
-        result_html += f"Processor: {processor_name}<br>"
-        result_html += f"Endoscope: {endoscope_name}<br>"
-        result_html += f"Center: {center_name}<br>"
-
-        return result_html
-    
-    # import meta should be created when video meta is created
-    def save(self, *args, **kwargs):
-        if self.import_meta is None:
-            self.import_meta = VideoImportMeta.objects.create()
-        super(VideoMeta, self).save(*args, **kwargs)
-
-    def initialize_ffmpeg_meta(self, file_path):
-        """Initializes FFMpeg metadata for the video file if not already done."""
-        self.ffmpeg_meta = FFMpegMeta.create_from_file(Path(file_path))
-        self.save()
-
-    def update_meta(self, file_path):
-        """Updates the video metadata from the file."""
-        self.initialize_ffmpeg_meta(file_path)
-        self.save()
-
-    def get_endo_roi(self):
-        endo_roi = self.processor.get_roi_endoscope_image()
-        return endo_roi
-
-    def get_fps(self):
-        if not self.ffmpeg_meta:
-            return None
-    
-        return self.ffmpeg_meta.frame_rate
- 
-
-class FFMpegMeta(models.Model):
-    # Existing fields
-    duration = models.FloatField(blank=True, null=True)
-    width = models.IntegerField(blank=True, null=True)
-    height = models.IntegerField(blank=True, null=True)
-    frame_rate = models.FloatField(blank=True, null=True)
-    
-    # New fields for comprehensive information
-    video_codec = models.CharField(max_length=50, blank=True, null=True)
-    audio_codec = models.CharField(max_length=50, blank=True, null=True)
-    audio_channels = models.IntegerField(blank=True, null=True)
-    audio_sample_rate = models.IntegerField(blank=True, null=True)
-
-    # Existing __str__ method can be updated to include new fields
-
-    @classmethod
-    def create_from_file(cls, file_path: Path):
-        """Creates an FFMpegMeta instance from a video file using ffmpeg probe."""
-        try:
-            probe = ffmpeg.probe(file_path.resolve().as_posix())
-        except: # ffmpeg.Error as e:
-            # print(e.stderr)
-            print(f"Error while probing {file_path}")
-            return None
-
-        video_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'video'), None)
-        audio_streams = [stream for stream in probe['streams'] if stream['codec_type'] == 'audio']
-
-        # Check for the existence of a video stream
-        if video_stream is None:
-            print(f"No video stream found in {file_path}")
-            return None
-
-        # Extract and store video metadata
-        metadata = {
-            'duration': float(video_stream.get('duration', 0)),
-            'width': int(video_stream.get('width', 0)),
-            'height': int(video_stream.get('height', 0)),
-            'frame_rate': float(next(iter(video_stream.get('avg_frame_rate', '').split('/')), 0)),
-            'video_codec': video_stream.get('codec_name', ''),
-        }
-
-        # If there are audio streams, extract and store audio metadata from the first stream
-        if audio_streams:
-            first_audio_stream = audio_streams[0]
-            metadata.update({
-                'audio_codec': first_audio_stream.get('codec_name', ''),
-                'audio_channels': int(first_audio_stream.get('channels', 0)),
-                'audio_sample_rate': int(first_audio_stream.get('sample_rate', 0)),
-            })
-
-        # Create and return the FFMpegMeta instance
-        return cls.objects.create(**metadata)
-
-class VideoImportMeta(models.Model):
-
-    video_anonymized = models.BooleanField(default=False)
-    video_patient_data_detected = models.BooleanField(default=False)
-    outside_detected = models.BooleanField(default=False)
-    patient_data_removed = models.BooleanField(default=False)
-    outside_removed = models.BooleanField(default=False)
-
-    def __str__(self):
-        result_html = ""
-
-        result_html += f"Video anonymized: {self.video_anonymized}<br>"
-        result_html += f"Video patient data detected: {self.video_patient_data_detected}<br>"
-        result_html += f"Outside detected: {self.outside_detected}<br>"
-        result_html += f"Patient data removed: {self.patient_data_removed}<br>"
-        result_html += f"Outside removed: {self.outside_removed}<br>"
-        return result_html

endoreg_db/models/data_file/report_file.py

@@ -1,89 +0,0 @@
-from django.db import models
-from ..center import Center
-import hashlib
-from datetime import date, time
-
-class ReportFile(models.Model):
-    pdf = models.FileField(upload_to="raw_report_pdfs", blank=True, null=True)
-    pdf_hash = models.CharField(max_length=255, unique=True)
-    center = models.ForeignKey(Center, on_delete=models.CASCADE)
-    meta = models.JSONField(blank=True, null=True)
-    text = models.TextField(blank=True, null=True)
-    text_anonymized = models.TextField(blank=True, null=True)
-    patient = models.ForeignKey("Patient", on_delete=models.CASCADE, blank=True, null=True)
-    examiner = models.ForeignKey("Examiner", on_delete=models.CASCADE, blank=True, null=True)
-    date = models.DateField(blank=True, null=True)
-    time = models.TimeField(blank=True, null=True)
-
-    def get_pdf_hash(self):
-        #FIXME should use endoreg_db.utils.get_pdf_hash in future
-        pdf = self.pdf
-        pdf_hash = None
-
-        if pdf:
-            # Open the file in binary mode and read its contents
-            with pdf.open(mode='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
-
-    def initialize_metadata_in_db(self, report_meta=None):
-        if not report_meta:
-            report_meta = self.meta
-        self.set_examination_date_and_time(report_meta)
-        self.patient, created = self.get_or_create_patient(report_meta)
-        self.examiner, created = self.get_or_create_examiner(report_meta)
-        self.save()    
-
-    def get_or_create_patient(self, report_meta=None):
-        from ..persons import Patient
-        if not report_meta:
-            report_meta = self.meta
-        patient_first_name = report_meta['patient_first_name']
-        patient_last_name = report_meta['patient_last_name']
-        patient_dob = report_meta['patient_dob']
-
-        patient, created = Patient.objects.get_or_create(
-            first_name=patient_first_name,
-            last_name=patient_last_name,
-            dob=patient_dob
-        )
-
-        return patient, created
-    
-    def get_or_create_examiner(self, report_meta= None):
-        from ..persons import Examiner
-        if not report_meta:
-            report_meta = self.meta
-        examiner_first_name = report_meta['examiner_first_name']
-        examiner_last_name = report_meta['examiner_last_name']
-        examiner_center = self.center
-
-        examiner, created = Examiner.objects.get_or_create(
-            first_name=examiner_first_name,
-            last_name=examiner_last_name,
-            center=examiner_center
-        )
-
-        return examiner, created
-        
-    def set_examination_date_and_time(self, report_meta=None):
-        if not report_meta:
-            report_meta = self.meta
-        examination_date_str = report_meta['examination_date']
-        examination_time_str = report_meta['examination_time']
-
-        if examination_date_str:
-            # TODO: get django DateField compatible date from string (e.g. "2021-01-01")
-            self.date = date.fromisoformat(examination_date_str)
-        if examination_time_str:
-            # TODO: get django TimeField compatible time from string (e.g. "12:00")
-            self.time = time.fromisoformat(examination_time_str)
-        
-
-

endoreg_db/models/data_file/video/__init__.py

@@ -1,7 +0,0 @@
-from .video import (
-    Video,
-    LegacyVideo,
-)
-from ..metadata import (
-    VideoImportMeta,
-)

endoreg_db/models/data_file/video/import_meta.py

@@ -1,25 +0,0 @@
-# from django.db import models
-
-# class VideoImportMeta(models.Model):
-#     processor = models.ForeignKey('EndoscopyProcessor', on_delete=models.CASCADE)
-#     endoscope = models.ForeignKey('Endoscope', on_delete=models.CASCADE, blank=True, null=True)
-#     center = models.ForeignKey('Center', on_delete=models.CASCADE)
-#     video_anonymized = models.BooleanField(default=False)
-#     video_patient_data_detected = models.BooleanField(default=False)
-#     outside_detected = models.BooleanField(default=False)
-#     patient_data_removed = models.BooleanField(default=False)
-#     outside_removed = models.BooleanField(default=False)
-
-#     def __str__(self):
-#         result_html = ""
-
-#         result_html += f"Processor: {self.processor.name}<br>"
-#         result_html += f"Endoscope: {self.endoscope.name}<br>"
-#         result_html += f"Center: {self.center.name}<br>"
-#         result_html += f"Video anonymized: {self.video_anonymized}<br>"
-#         result_html += f"Video patient data detected: {self.video_patient_data_detected}<br>"
-#         result_html += f"Outside detected: {self.outside_detected}<br>"
-#         result_html += f"Patient data removed: {self.patient_data_removed}<br>"
-#         result_html += f"Outside removed: {self.outside_removed}<br>"
-#         return result_html
-    

endoreg_db/models/data_file/video/video.py

@@ -1,25 +0,0 @@
-from ..base_classes import AbstractVideo
-from django.db import models
-
-from endoreg_db.models.data_file.frame import Frame
-from endoreg_db.models.data_file.frame import LegacyFrame
-
-BATCH_SIZE = 1000
-
-class Video(AbstractVideo):
-    import_meta = models.OneToOneField('VideoImportMeta', on_delete=models.CASCADE, blank=True, null=True)
-    def get_video_model(self):
-        return Video
-
-    def get_frame_model(self):
-        return Frame
-
-
-class LegacyVideo(AbstractVideo):
-    file = models.FileField(upload_to="legacy_videos", blank=True, null=True)
-
-    def get_video_model(self):
-        return LegacyVideo
-
-    def get_frame_model(self):
-        return LegacyFrame