migrate to new database abstraction

maximemulder · maximemulder · commit 56a4c42ebfc4 · 2025-04-13T09:36:25.000Z
diff --git a/pyproject.toml b/pyproject.toml
@@ -19,10 +19,10 @@ select = ["E", "F", "I", "N", "UP", "W"]
 include = [
     "python/tests",
     "python/lib/db",
+    "python/lib/imaging_lib",
     "python/lib/import_bids_dataset",
     "python/lib/import_dicom_study",
     "python/lib/util",
-    "python/lib/bids.py",
     "python/lib/config.py",
     "python/lib/config_file.py",
     "python/lib/env.py",
diff --git a/python/lib/db/models/file.py b/python/lib/db/models/file.py
@@ -13,7 +13,7 @@ class DbFile(Base):
 
     id                             : Mapped[int]          = mapped_column('FileID', primary_key=True)
     session_id                     : Mapped[int]          = mapped_column('SessionID', ForeignKey('session.ID'))
-    file_name                      : Mapped[str]          = mapped_column('File')
+    rel_path                       : Mapped[str]          = mapped_column('File')
     series_uid                     : Mapped[str | None]   = mapped_column('SeriesUID')
     echo_time                      : Mapped[float | None] = mapped_column('EchoTime')
     phase_encoding_direction       : Mapped[str | None]   = mapped_column('PhaseEncodingDirection')
@@ -35,6 +35,7 @@ class DbFile(Base):
     acquisition_order_per_modality : Mapped[int | None]   = mapped_column('AcqOrderPerModality')
     acquisition_date               : Mapped[date | None]  = mapped_column('AcquisitionDate')
 
-    session   : Mapped['db_session.DbSession'] = relationship('DbSession', back_populates='files')
-    parameters: Mapped[list['db_parameter_file.DbParameterFile']] \
+    session    : Mapped['db_session.DbSession'] \
+        = relationship('DbSession', back_populates='files')
+    parameters : Mapped[list['db_parameter_file.DbParameterFile']] \
         = relationship('DbParameterFile', back_populates='file')
diff --git a/python/lib/db/models/imaging_file_type.py b/python/lib/db/models/imaging_file_type.py
@@ -0,0 +1,10 @@
+from sqlalchemy.orm import Mapped, mapped_column
+
+from lib.db.base import Base
+
+
+class DbImagingFileType(Base):
+    __tablename__ = 'ImagingFileTypes'
+
+    type        : Mapped[str]        = mapped_column('type', primary_key=True)
+    description : Mapped[str | None] = mapped_column('description')
diff --git a/python/lib/db/models/mri_violation_log.py b/python/lib/db/models/mri_violation_log.py
@@ -43,5 +43,5 @@ class DbMriViolationLog(Base):
         = relationship('DbCandidate', back_populates='violations_log')
     scan_type            : Mapped[Optional['db_mri_scan_type.DbMriScanType']] \
         = relationship('DbMriScanType', back_populates='violations_log')
-    protocol_check_group: Mapped[Optional['db_mri_protocol_check_group.DbMriProtocolCheckGroup']] \
+    protocol_check_group : Mapped[Optional['db_mri_protocol_check_group.DbMriProtocolCheckGroup']] \
         = relationship('DbMriProtocolCheckGroup', back_populates='violations_log')
diff --git a/python/lib/db/models/parameter_file.py b/python/lib/db/models/parameter_file.py
@@ -15,5 +15,7 @@ class DbParameterFile(Base):
     value       : Mapped[str | None] = mapped_column('Value')
     insert_time : Mapped[int]        = mapped_column('InsertTime')
 
-    file: Mapped[list['db_file.DbFile']]              = relationship('DbFile', back_populates='parameters')
-    type: Mapped['db_parameter_type.DbParameterType'] = relationship('DbParameterType', back_populates='parameter_file')
+    file: Mapped['db_file.DbFile'] \
+        = relationship('DbFile', back_populates='parameters')
+    type: Mapped['db_parameter_type.DbParameterType'] \
+        = relationship('DbParameterType', back_populates='parameter_files')
diff --git a/python/lib/db/models/parameter_type.py b/python/lib/db/models/parameter_type.py
@@ -20,5 +20,5 @@ class DbParameterType(Base):
     queryable        : Mapped[bool | None]  = mapped_column('Queryable')
     is_file          : Mapped[bool | None]  = mapped_column('IsFile')
 
-    parameter_file: Mapped[list['db_parameter_file.DbParameterFile']] \
+    parameter_files: Mapped[list['db_parameter_file.DbParameterFile']] \
         = relationship('DbParameterFile', back_populates='type')
diff --git a/python/lib/db/queries/file.py b/python/lib/db/queries/file.py
@@ -40,3 +40,17 @@ def try_get_parameter_value_with_file_id_parameter_name(
         .where(DbParameterType.name == parameter_name)
         .where(DbParameterFile.file_id == file_id)
     ).scalar_one_or_none()
+
+
+def try_get_file_with_hash(db: Database, file_hash: str) -> DbFile | None:
+    """
+    Get an imaging file from the database using its BLAKE2b or MD5 hash, or return `None` if no
+    imaging file is found.
+    """
+
+    return db.execute(select(DbFile)
+        .join(DbFile.parameters)
+        .join(DbParameterFile.type)
+        .where(DbParameterType.name.in_(['file_blake2b_hash', 'md5hash']))
+        .where(DbParameterFile.value == file_hash)
+    ).scalar_one_or_none()
diff --git a/python/lib/db/queries/imaging_file_type.py b/python/lib/db/queries/imaging_file_type.py
@@ -0,0 +1,14 @@
+from collections.abc import Sequence
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session as Database
+
+from lib.db.models.imaging_file_type import DbImagingFileType
+
+
+def get_all_imaging_file_types(db: Database) -> Sequence[DbImagingFileType]:
+    """
+    Get a sequence of all imaging file types from the database.
+    """
+
+    return db.execute(select(DbImagingFileType)).scalars().all()
diff --git a/python/lib/db/queries/mri_scan_type.py b/python/lib/db/queries/mri_scan_type.py
@@ -0,0 +1,15 @@
+from sqlalchemy import select
+from sqlalchemy.orm import Session as Database
+
+from lib.db.models.mri_scan_type import DbMriScanType
+
+
+def try_get_mri_scan_type_with_name(db: Database, name: str) -> DbMriScanType | None:
+    """
+    Get an MRI scan type from the database using its name, or return `None` if no scan type is
+    found.
+    """
+
+    return db.execute(select(DbMriScanType)
+        .where(DbMriScanType.name == name)
+    ).scalar_one_or_none()
diff --git a/python/lib/db/queries/parameter_file.py b/python/lib/db/queries/parameter_file.py
@@ -0,0 +1,16 @@
+from sqlalchemy import select
+from sqlalchemy.orm import Session as Database
+
+from lib.db.models.parameter_file import DbParameterFile
+
+
+def try_get_parameter_file_with_file_id_type_id(db: Database, file_id: int, type_id: int) -> DbParameterFile | None:
+    """
+    Get a file parameter from the database using its file ID and type ID, or return `None` if no
+    file parameter is found.
+    """
+
+    return db.execute(select(DbParameterFile)
+        .where(DbParameterFile.type_id == type_id)
+        .where(DbParameterFile.file_id == file_id)
+    ).scalar_one_or_none()
diff --git a/python/lib/db/queries/parameter_type.py b/python/lib/db/queries/parameter_type.py
@@ -0,0 +1,25 @@
+from collections.abc import Sequence
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session as Database
+
+from lib.db.models.parameter_type import DbParameterType
+
+
+def get_all_parameter_types(db: Database) -> Sequence[DbParameterType]:
+    """
+    Get a sequence of all parameter types from the database.
+    """
+
+    return db.execute(select(DbParameterType)).scalars().all()
+
+
+def get_parameter_type_with_name(db: Database, name: str) -> DbParameterType:
+    """
+    Get a parameter type from the database using its name, or raise an exception if no file
+    parameter is found.
+    """
+
+    return db.execute(select(DbParameterType)
+        .where(DbParameterType.name == name)
+    ).scalar_one()
diff --git a/python/lib/db/queries/project.py b/python/lib/db/queries/project.py
@@ -1,4 +1,3 @@
-
 from sqlalchemy import select
 from sqlalchemy.orm import Session as Database
 
diff --git a/python/lib/dcm2bids_imaging_pipeline_lib/nifti_insertion_pipeline.py b/python/lib/dcm2bids_imaging_pipeline_lib/nifti_insertion_pipeline.py
@@ -7,10 +7,10 @@
 import sys
 
 import lib.exitcode
-from lib.bids import get_bids_json_session_info
 from lib.db.queries.dicom_archive import try_get_dicom_archive_series_with_series_uid_echo_time
 from lib.dcm2bids_imaging_pipeline_lib.base_pipeline import BasePipeline
 from lib.get_session_info import SessionConfigError, get_dicom_archive_session_info
+from lib.imaging_lib.bids import get_bids_json_session_info
 from lib.logging import log_error_exit, log_verbose
 from lib.util.crypto import compute_file_blake2b_hash, compute_file_md5_hash
 
diff --git a/python/lib/imaging_lib/bids.py b/python/lib/imaging_lib/bids.py
@@ -1,6 +1,8 @@
+import re
 from typing import Any
 
 from lib.config import get_patient_id_dicom_header_config
+from lib.db.queries.imaging_file_type import get_all_imaging_file_types
 from lib.env import Env
 from lib.get_session_info import SessionInfo, get_session_info
 from lib.scanner import MriScannerInfo
@@ -36,3 +38,19 @@ def get_bids_json_session_info(env: Env, bids_json: dict[str, Any]) -> SessionIn
     scanner_info = get_bids_json_scanner_info(bids_json)
 
     return get_session_info(env, patient_id, scanner_info)
+
+
+def determine_bids_file_type(env: Env, file_name: str) -> str | None:
+    """
+    Determine the file type of a BIDS file from the database using its name, or return `None` if no
+    corresponding file type is found.
+    """
+
+    imaging_file_types = get_all_imaging_file_types(env.db)
+
+    for imaging_file_type in imaging_file_types:
+        regex = re.escape(imaging_file_type.type) + r'(\.gz)?$'
+        if re.search(regex, file_name):
+            return imaging_file_type.type
+
+    return None
diff --git a/python/lib/imaging_lib/file.py b/python/lib/imaging_lib/file.py
@@ -0,0 +1,39 @@
+import getpass
+
+from lib.db.models.file import DbFile
+from lib.db.models.mri_scan_type import DbMriScanType
+from lib.db.models.session import DbSession
+from lib.env import Env
+
+
+def register_imaging_file(
+    env: Env,
+    file_type: str,
+    file_rel_path: str,
+    session: DbSession,
+    mri_scan_type: DbMriScanType,
+    echo_time: float | None,
+    echo_number: str | None,
+    phase_encoding_direction: str | None,
+) -> DbFile:
+
+    user = getpass.getuser()
+
+    file = DbFile(
+        file_type                = file_type,
+        rel_path                 = file_rel_path,
+        session_id               = session.id,
+        inserted_by_user_id      = user,
+        coordinate_space         = 'native',
+        output_type              = 'native',
+        echo_time                = echo_time,
+        echo_number              = echo_number,
+        phase_encoding_direction = phase_encoding_direction,
+        source_file_id           = None,
+        mri_scan_type_id         = mri_scan_type.id,
+    )
+
+    env.db.add(file)
+    env.db.commit()
+
+    return file
diff --git a/python/lib/imaging_lib/file_parameter.py b/python/lib/imaging_lib/file_parameter.py
@@ -0,0 +1,44 @@
+from datetime import datetime
+from typing import Any
+
+from lib.db.models.file import DbFile
+from lib.db.models.parameter_file import DbParameterFile
+from lib.db.queries.parameter_file import try_get_parameter_file_with_file_id_type_id
+from lib.db.queries.parameter_type import get_parameter_type_with_name
+from lib.env import Env
+
+
+def register_file_parameters(env: Env, file: DbFile, parameter_infos: dict[str, Any]):
+    """
+    Insert or upate some file parameters with the provided parameter names and values.
+    """
+
+    for parameter_name, parameter_value in parameter_infos.items():
+        register_file_parameter(env, file, parameter_name, parameter_value)
+
+
+def register_file_parameter(env: Env, file: DbFile, parameter_name: str, parameter_value: Any):
+    """
+    Insert or upate a file parameter with the provided parameter name and value.
+    """
+
+    if type(parameter_value) is list:
+        parameter_values = map(lambda parameter_value: str(parameter_value), parameter_value)  # type: ignore
+        parameter_value = f"[{', '.join(parameter_values)}]"
+
+    parameter_type = get_parameter_type_with_name(env.db, parameter_name)
+
+    parameter = try_get_parameter_file_with_file_id_type_id(env.db, file.id, parameter_type.id)
+    if parameter is None:
+        parameter = DbParameterFile(
+            type_id     = parameter_type.id,
+            file_id     = file.id,
+            value       = parameter_value,
+            insert_time = datetime.now(),
+        )
+
+        env.db.add(parameter)
+    else:
+        parameter.value = parameter_value
+
+    env.db.commit()
diff --git a/python/lib/imaging_lib/nifti.py b/python/lib/imaging_lib/nifti.py
@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+from typing import cast
+
+import nibabel as nib
+
+
+@dataclass
+class ImageStepParameters:
+    x_step: float
+    y_step: float
+    z_step: float
+
+
+def get_nifti_image_step_parameters(nifti_path: str) -> ImageStepParameters:
+    """
+    Get the step information (xstep, ystep, zstep and number of volumes for a 4D dataset) of a
+    NIfTI image.
+    """
+
+    img = nib.load(nifti_path)  # type: ignore
+
+    # Get the voxel step/time step of the image.
+    zooms = cast(tuple[float, ...], img.header.get_zooms())  # type: ignore
+
+    return ImageStepParameters(
+        x_step = zooms[0],
+        y_step = zooms[1],
+        z_step = zooms[1],
+    )
+
+
+@dataclass
+class ImageLengthParameters:
+    x_space: int
+    y_space: int
+    z_space: int
+    time: int | None
+
+
+def get_nifti_image_length_parameters(nifti_path: str) -> ImageLengthParameters:
+    """
+    Get the length dimensions (x, y, z and time for a 4D dataset) of a NIfTI image.
+    """
+
+    img = nib.load(nifti_path)  # type: ignore
+
+    # Get the voxel/time length array of the image.
+    shape = cast(tuple[int, ...], img.shape)  # type: ignore
+
+    return ImageLengthParameters(
+        x_space = shape[0],
+        y_space = shape[1],
+        z_space = shape[2],
+        time = shape[3] if len(shape) == 4 else None
+    )
diff --git a/python/lib/imaging_lib/nifti_pic.py b/python/lib/imaging_lib/nifti_pic.py
@@ -0,0 +1,52 @@
+import os
+import re
+
+from nilearn import image, plotting
+
+from lib.config import get_data_dir_path_config
+from lib.db.models.file import DbFile
+from lib.env import Env
+
+
+def create_imaging_pic(env: Env, file: DbFile, is_4d_data: bool) -> str:
+    """
+    Creates the preview pic that will show in the imaging browser view session
+    page. This pic will be stored in the data_dir/pic folder
+
+    :param file_info: dictionary with file information (path, file_id, cand_id...)
+        :type file_info: dict
+    :param pic_rel_path: relative path to the pic to use if one provided. Otherwise
+                            create_imaging_pic will automatically generate the pic name
+                            based on the file path of the NIfTI file
+        :type pic_rel_path: str
+
+    :return: path to the created pic
+        :rtype: str
+    """
+
+    data_dir_path = get_data_dir_path_config(env)
+
+    cand_id = file.session.candidate.cand_id
+    file_path = os.path.join(data_dir_path, file.rel_path)
+
+    pic_name = re.sub(r"\.nii(\.gz)?$", f'_{file.id}_check.png', os.path.basename(file.rel_path))
+    pic_rel_path = os.path.join(str(cand_id), pic_name)
+    pic_dir_path = os.path.join(data_dir_path, 'pic', str(cand_id))
+    pic_path = os.path.join(data_dir_path, 'pic', pic_rel_path)
+
+    # create the candID directory where the pic will go if it does not already exist
+    if not os.path.exists(pic_dir_path):
+        os.mkdir(pic_dir_path)
+
+    volume = image.index_img(file_path, 0) if is_4d_data else file_path  # type: ignore
+
+    plotting.plot_anat(  # type: ignore
+        anat_img=volume,
+        output_file=pic_path,
+        display_mode='ortho',
+        black_bg=True,  # type: ignore
+        draw_cross=False,
+        annotate=False,
+    )
+
+    return pic_rel_path
diff --git a/python/lib/imaging_lib/scan_type.py b/python/lib/imaging_lib/scan_type.py
diff --git a/python/lib/import_bids_dataset/imaging.py b/python/lib/import_bids_dataset/imaging.py
diff --git a/python/lib/mri.py b/python/lib/mri.py
diff --git a/python/scripts/bids_import.py b/python/scripts/bids_import.py
diff --git a/python/tests/integration/scripts/test_run_nifti_insertion.py b/python/tests/integration/scripts/test_run_nifti_insertion.py
