New DICOM study import script

install/requirements/requirements.txt

@@ -11,6 +11,7 @@ nose
 numpy
 protobuf>=3.0.0
 pybids==0.17.0
+pydicom
 pyright
 pytest
 python-dateutil

pyproject.toml

@@ -20,6 +20,7 @@ include = [
     "python/tests",
     "python/lib/db",
     "python/lib/exception",
+    "python/lib/import_dicom_study",
     "python/lib/util",
     "python/lib/config_file.py",
     "python/lib/env.py",
@@ -28,6 +29,8 @@ include = [
     "python/lib/make_env.py",
     "python/lib/scanner.py",
     "python/lib/validate_subject_info.py",
+    "python/scripts/import_dicom_study.py",
+    "python/scripts/summarize_dicom_study.py",
 ]
 typeCheckingMode = "strict"
 reportMissingTypeStubs = "none"

python/lib/db/queries/dicom_archive.py

@@ -52,27 +52,6 @@ def delete_dicom_archive_file_series(db: Database, dicom_archive: DbDicomArchive
         .where(DbDicomArchiveSeries.archive_id == dicom_archive.id))
 
 
-def get_dicom_archive_series_with_file_info(
-    db: Database,
-    series_uid: str,
-    series_number: int,
-    echo_time: float | None,
-    sequence_name: str | None,
-):
-    """
-    Get a DICOM archive series from the database using its file information, or raise an exception
-    if no DICOM archive series is found.
-    """
-
-    query = select(DbDicomArchiveSeries) \
-        .where(DbDicomArchiveSeries.series_uid    == series_uid) \
-        .where(DbDicomArchiveSeries.series_number == series_number) \
-        .where(DbDicomArchiveSeries.echo_time     == echo_time) \
-        .where(DbDicomArchiveSeries.sequence_name == sequence_name)
-
-    return db.execute(query).scalar_one()
-
-
 def try_get_dicom_archive_series_with_series_uid_echo_time(
     db: Database,
     series_uid: str,

python/lib/import_dicom_study/dicom_database.py

@@ -0,0 +1,144 @@
+from datetime import datetime
+from functools import cmp_to_key
+
+from sqlalchemy.orm import Session as Database
+
+from lib.db.models.dicom_archive import DbDicomArchive
+from lib.db.models.dicom_archive_file import DbDicomArchiveFile
+from lib.db.models.dicom_archive_series import DbDicomArchiveSeries
+from lib.db.queries.dicom_archive import delete_dicom_archive_file_series
+from lib.import_dicom_study.import_log import DicomStudyImportLog, write_dicom_study_import_log_to_string
+from lib.import_dicom_study.summary_type import DicomStudySummary
+from lib.import_dicom_study.summary_write import compare_dicom_files, compare_dicom_series, write_dicom_study_summary
+from lib.util.iter import count, flatten
+
+
+def insert_dicom_archive(
+    db: Database,
+    dicom_summary: DicomStudySummary,
+    dicom_import_log: DicomStudyImportLog,
+    archive_location: str,
+):
+    """
+    Insert a DICOM archive in the database.
+    """
+
+    dicom_archive = DbDicomArchive()
+    populate_dicom_archive(dicom_archive, dicom_summary, dicom_import_log, archive_location)
+    dicom_archive.date_first_archived = datetime.now()
+    db.add(dicom_archive)
+    db.commit()
+    insert_files_series(db, dicom_archive, dicom_summary)
+    return dicom_archive
+
+
+def update_dicom_archive(
+    db: Database,
+    dicom_archive: DbDicomArchive,
+    dicom_summary: DicomStudySummary,
+    dicom_import_log: DicomStudyImportLog,
+    archive_location: str,
+):
+    """
+    Update a DICOM archive in the database.
+    """
+
+    # Delete the associated database DICOM files and series.
+    delete_dicom_archive_file_series(db, dicom_archive)
+
+    # Update the database record with the new DICOM information.
+    populate_dicom_archive(dicom_archive, dicom_summary, dicom_import_log, archive_location)
+    db.commit()
+
+    # Insert the new DICOM files and series.
+    insert_files_series(db, dicom_archive, dicom_summary)
+
+
+def populate_dicom_archive(
+    dicom_archive: DbDicomArchive,
+    dicom_summary: DicomStudySummary,
+    dicom_import_log: DicomStudyImportLog,
+    archive_location: str,
+):
+    """
+    Populate a DICOM archive database object with information from its DICOM summary and DICOM
+    study import log.
+    """
+
+    dicom_archive.study_uid                = dicom_summary.info.study_uid
+    dicom_archive.patient_id               = dicom_summary.info.patient.id
+    dicom_archive.patient_name             = dicom_summary.info.patient.name
+    dicom_archive.patient_birthdate        = dicom_summary.info.patient.birth_date
+    dicom_archive.patient_sex              = dicom_summary.info.patient.sex
+    dicom_archive.neuro_db_center_name     = None
+    dicom_archive.center_name              = dicom_summary.info.institution or ''
+    dicom_archive.last_update              = None
+    dicom_archive.date_acquired            = dicom_summary.info.scan_date
+    dicom_archive.date_last_archived       = datetime.now()
+    dicom_archive.acquisition_count        = len(dicom_summary.dicom_series_files)
+    dicom_archive.dicom_file_count         = count(flatten(dicom_summary.dicom_series_files.values()))
+    dicom_archive.non_dicom_file_count     = len(dicom_summary.other_files)
+    dicom_archive.md5_sum_dicom_only       = dicom_import_log.tarball_md5_sum
+    dicom_archive.md5_sum_archive          = dicom_import_log.archive_md5_sum
+    dicom_archive.creating_user            = dicom_import_log.creator_name
+    dicom_archive.sum_type_version         = dicom_import_log.summary_version
+    dicom_archive.tar_type_version         = dicom_import_log.archive_version
+    dicom_archive.source_location          = dicom_import_log.source_path
+    dicom_archive.archive_location         = archive_location
+    dicom_archive.scanner_manufacturer     = dicom_summary.info.scanner.manufacturer
+    dicom_archive.scanner_model            = dicom_summary.info.scanner.model
+    dicom_archive.scanner_serial_number    = dicom_summary.info.scanner.serial_number
+    dicom_archive.scanner_software_version = dicom_summary.info.scanner.software_version
+    dicom_archive.session_id               = None
+    dicom_archive.upload_attempt           = 0
+    dicom_archive.create_info              = write_dicom_study_import_log_to_string(dicom_import_log)
+    dicom_archive.acquisition_metadata     = write_dicom_study_summary(dicom_summary)
+    dicom_archive.date_sent                = None
+    dicom_archive.pending_transfer         = False
+
+
+def insert_files_series(db: Database, dicom_archive: DbDicomArchive, dicom_summary: DicomStudySummary):
+    """
+    Insert the DICOM files and series related to a DICOM archive in the database.
+    """
+
+    # Sort the DICOM series and files to insert them in the correct order.
+    dicom_series_list = list(dicom_summary.dicom_series_files.keys())
+    dicom_series_list.sort(key=cmp_to_key(compare_dicom_series))
+
+    for dicom_series in dicom_series_list:
+        dicom_files = dicom_summary.dicom_series_files[dicom_series]
+        dicom_files.sort(key=cmp_to_key(compare_dicom_files))
+
+        dicom_series = DbDicomArchiveSeries(
+            archive_id         = dicom_archive.id,
+            series_number      = dicom_series.series_number,
+            series_description = dicom_series.series_description,
+            sequence_name      = dicom_series.sequence_name,
+            echo_time          = dicom_series.echo_time,
+            repetition_time    = dicom_series.repetition_time,
+            inversion_time     = dicom_series.inversion_time,
+            slice_thickness    = dicom_series.slice_thickness,
+            phase_encoding     = dicom_series.phase_encoding,
+            number_of_files    = len(dicom_files),
+            series_uid         = dicom_series.series_uid,
+            modality           = dicom_series.modality,
+        )
+
+        # Populate the DICOM series ID.
+        db.add(dicom_series)
+        db.commit()
+
+        for dicom_file in dicom_files:
+            db.add(DbDicomArchiveFile(
+                archive_id         = dicom_archive.id,
+                series_number      = dicom_file.series_number,
+                file_number        = dicom_file.file_number,
+                echo_number        = dicom_file.echo_number,
+                series_description = dicom_file.series_description,
+                md5_sum            = dicom_file.md5_sum,
+                file_name          = dicom_file.file_name,
+                series_id          = dicom_series.id,
+            ))
+
+    db.commit()

python/lib/import_dicom_study/import_log.py

@@ -0,0 +1,76 @@
+import os
+import socket
+from dataclasses import dataclass
+from datetime import datetime
+
+from lib.import_dicom_study.text_dict import DictWriter
+
+
+@dataclass
+class DicomStudyImportLog:
+    """
+    Information about the past import of a DICOM study.
+    """
+
+    source_path: str
+    target_path: str
+    creator_host: str
+    creator_os: str
+    creator_name: str
+    archive_date: str
+    summary_version: int
+    archive_version: int
+    tarball_md5_sum: str
+    zipball_md5_sum: str
+    archive_md5_sum: str
+
+
+def write_dicom_study_import_log_to_string(import_log: DicomStudyImportLog):
+    """
+    Serialize a DICOM study import log into a string.
+    """
+
+    return DictWriter([
+        ("Taken from dir",                   import_log.source_path),
+        ("Archive target location",          import_log.target_path),
+        ("Name of creating host",            import_log.creator_host),
+        ("Name of host OS",                  import_log.creator_os),
+        ("Created by user",                  import_log.creator_name),
+        ("Archived on",                      import_log.archive_date),
+        ("dicomSummary version",             import_log.summary_version),
+        ("dicomTar version",                 import_log.archive_version),
+        ("md5sum for DICOM tarball",         import_log.tarball_md5_sum),
+        ("md5sum for DICOM tarball gzipped", import_log.zipball_md5_sum),
+        ("md5sum for complete archive",      import_log.archive_md5_sum),
+    ]).write()
+
+
+def write_dicom_study_import_log_to_file(import_log: DicomStudyImportLog, file_path: str):
+    """
+    Serialize a DICOM study import log into a text file.
+    """
+
+    string = write_dicom_study_import_log_to_string(import_log)
+    with open(file_path, "w") as file:
+        file.write(string)
+
+
+def make_dicom_study_import_log(source: str, target: str, tarball_md5_sum: str, zipball_md5_sum: str):
+    """
+    Create a DICOM study import log from the provided arguments about a DICOM study, as well as the
+    current execution environment.
+    """
+
+    return DicomStudyImportLog(
+        source,
+        target,
+        socket.gethostname(),
+        os.uname().sysname,
+        os.environ["USER"],
+        datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S"),
+        2,
+        2,
+        tarball_md5_sum,
+        zipball_md5_sum,
+        "Provided in database only",
+    )