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

endoreg_db/models/data_file/metadata/__init__.py

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

endoreg_db/models/data_file/metadata/pdf_meta.py

@@ -1,70 +1,70 @@
-from django.db import models
-
-# import endoreg_center_id from django settings
-from django.conf import settings
-
-
-# import File class
-from django.core.files import File
-
-# # 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
-
-class PdfType(models.Model):
-    name = models.CharField(max_length=255)
-
-    patient_info_line = models.ForeignKey(
-        "ReportReaderFlag",
-        related_name="pdf_type_patient_info_line", 
-        on_delete=models.CASCADE
-    )
-    endoscope_info_line = models.ForeignKey(
-        "ReportReaderFlag",
-        related_name="pdf_type_endoscopy_info_line", 
-        on_delete=models.CASCADE,
-    )
-    examiner_info_line = models.ForeignKey(
-        "ReportReaderFlag",
-        related_name="pdf_type_examiner_info_line", 
-        on_delete=models.CASCADE
-    )
-    cut_off_above_lines = models.ManyToManyField(
-        "ReportReaderFlag",
-        related_name="pdf_type_cut_off_above_lines", 
-    )
-    cut_off_below_lines = models.ManyToManyField(
-        "ReportReaderFlag",
-        related_name="pdf_type_cut_off_below_lines", 
-    )
-
-
-    def __str__(self):
-        summary = f"{self.name}"
-        # add lines to summary
-        summary += f"\nPatient Info Line: {self.patient_info_line.value}"
-        summary += f"\nEndoscope Info Line: {self.endoscope_info_line.value}"
-        summary += f"\nExaminer Info Line: {self.examiner_info_line.value}"
-        summary += f"\nCut Off Above Lines: {[_.value for _ in self.cut_off_above_lines.all()]}"
-        summary += f"\nCut Off Below Lines: {[_.value for _ in self.cut_off_below_lines.all()]}"
-    
-        return summary
-
-class PdfMeta(models.Model):
-    pdf_type = models.ForeignKey(PdfType, on_delete=models.CASCADE)
-    date = models.DateField()
-    time = models.TimeField()
-    pdf_hash = models.CharField(max_length=255, unique=True)
-
-    def __str__(self):
-        return self.pdf_hash
-
-    @classmethod
-    def create_from_file(cls, pdf_file):
-        pdf_file = File(pdf_file)
-        pdf_meta = cls(file=pdf_file)
-        pdf_meta.save()
-        return pdf_meta
-
+from django.db import models
+
+# import endoreg_center_id from django settings
+from django.conf import settings
+
+
+# import File class
+from django.core.files import File
+
+# # 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
+
+class PdfType(models.Model):
+    name = models.CharField(max_length=255)
+
+    patient_info_line = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="pdf_type_patient_info_line", 
+        on_delete=models.CASCADE
+    )
+    endoscope_info_line = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="pdf_type_endoscopy_info_line", 
+        on_delete=models.CASCADE,
+    )
+    examiner_info_line = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="pdf_type_examiner_info_line", 
+        on_delete=models.CASCADE
+    )
+    cut_off_above_lines = models.ManyToManyField(
+        "ReportReaderFlag",
+        related_name="pdf_type_cut_off_above_lines", 
+    )
+    cut_off_below_lines = models.ManyToManyField(
+        "ReportReaderFlag",
+        related_name="pdf_type_cut_off_below_lines", 
+    )
+
+
+    def __str__(self):
+        summary = f"{self.name}"
+        # add lines to summary
+        summary += f"\nPatient Info Line: {self.patient_info_line.value}"
+        summary += f"\nEndoscope Info Line: {self.endoscope_info_line.value}"
+        summary += f"\nExaminer Info Line: {self.examiner_info_line.value}"
+        summary += f"\nCut Off Above Lines: {[_.value for _ in self.cut_off_above_lines.all()]}"
+        summary += f"\nCut Off Below Lines: {[_.value for _ in self.cut_off_below_lines.all()]}"
+    
+        return summary
+
+class PdfMeta(models.Model):
+    pdf_type = models.ForeignKey(PdfType, on_delete=models.CASCADE)
+    date = models.DateField()
+    time = models.TimeField()
+    pdf_hash = models.CharField(max_length=255, unique=True)
+
+    def __str__(self):
+        return self.pdf_hash
+
+    @classmethod
+    def create_from_file(cls, pdf_file):
+        pdf_file = File(pdf_file)
+        pdf_meta = cls(file=pdf_file)
+        pdf_meta.save()
+        return pdf_meta
+

endoreg_db/models/data_file/metadata/sensitive_meta.py

@@ -1,31 +1,31 @@
-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})"
-    
+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,132 +1,133 @@
-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(str(file_path))
-        except ffmpeg.Error as e:
-            print(e.stderr)
-            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>"
+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 +1,89 @@
-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)
-        
-
-
+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)
+        
+
+