dbdicom 0.3.6__tar.gz → 0.3.8__tar.gz

{dbdicom-0.3.6/src/dbdicom.egg-info → dbdicom-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbdicom
-Version: 0.3.6
+Version: 0.3.8
 Summary: A pythonic interface for reading and writing DICOM databases
 Author-email: Steven Sourbron <s.sourbron@sheffield.ac.uk>, Ebony Gunwhy <e.gunwhy@sheffield.ac.uk>
 Project-URL: Homepage, https://openmiblab.github.io/dbdicom/

{dbdicom-0.3.6 → dbdicom-0.3.8}/pyproject.toml

@@ -7,7 +7,7 @@ requires = ['setuptools>=61.2']
 
 [project]
 name = "dbdicom"
-version = "0.3.6"
+version = "0.3.8"
 dependencies = [ 
     "tqdm",
     "importlib-resources",

{dbdicom-0.3.6 → dbdicom-0.3.8}/src/dbdicom/api.py

@@ -1,10 +1,18 @@
+import os
+import shutil
+import zipfile
+from pathlib import Path
 from typing import Union
+from tqdm import tqdm
+
 
 import vreg
 
 from dbdicom.dbd import DataBaseDicom
 
 
+
+
 def open(path:str) -> DataBaseDicom:
     """Open a DICOM database
 
@@ -190,19 +198,20 @@ def move(from_entity:list, to_entity:list):
     dbd.delete(from_entity)
     dbd.close()
 
-def split_series(series:list, attr:Union[str, tuple])->dict:
+def split_series(series:list, attr:Union[str, tuple], key=None)->list:
     """
     Split a series into multiple series
     
     Args:
         series (list): series to split.
-        attr (str or tuple): dicom attribute to split the series by.  
+        attr (str or tuple): dicom attribute to split the series by. 
+        key (function): split by by key(attr) 
     Returns:
-        dict: dictionary with keys the unique values found (ascending) 
-        and as values the series corresponding to that value.     
+        list: list of two-element tuples, where the first element is
+        is the value and the second element is the series corresponding to that value.      
     """
     dbd = open(series[0])
-    split_series = dbd.split_series(series, attr)
+    split_series = dbd.split_series(series, attr, key)
     dbd.close()
     return split_series
 
@@ -363,10 +372,74 @@ def unique(pars:list, entity:list) -> dict:
     return u
 
 
+def archive(path, archive_path):
+    dbd = open(path)
+    dbd.archive(archive_path)
+    dbd.close()
+
+
+def restore(archive_path, path):
+    _copy_and_extract_zips(archive_path, path)
+    dbd = open(path)
+    dbd.close()
 
 
+def _copy_and_extract_zips(src_folder, dest_folder):
+    if not os.path.exists(dest_folder):
+        os.makedirs(dest_folder)
 
+    # First pass: count total files
+    total_files = sum(len(files) for _, _, files in os.walk(src_folder))
 
-if __name__=='__main__':
+    with tqdm(total=total_files, desc="Copying and extracting") as pbar:
+        for root, dirs, files in os.walk(src_folder):
+            rel_path = os.path.relpath(root, src_folder)
+            dest_path = os.path.join(dest_folder, rel_path)
+            os.makedirs(dest_path, exist_ok=True)
 
+            for file in files:
+                src_file_path = os.path.join(root, file)
+                dest_file_path = os.path.join(dest_path, file)
+
+                if file.lower().endswith('.zip'):
+                    try:
+                        zip_dest_folder = dest_file_path[:-4]
+                        with zipfile.ZipFile(src_file_path, 'r') as zip_ref:
+                            zip_ref.extractall(zip_dest_folder)
+                        #tqdm.write(f"Extracted ZIP: {src_file_path}")
+                        #_flatten_folder(zip_dest_folder) # still needed?
+                    except zipfile.BadZipFile:
+                        tqdm.write(f"Bad ZIP file skipped: {src_file_path}")
+                else:
+                    shutil.copy2(src_file_path, dest_file_path)
+
+                pbar.update(1)
+
+
+def _flatten_folder(root_folder):
+    for dirpath, dirnames, filenames in os.walk(root_folder, topdown=False):
+        for filename in filenames:
+            src_path = os.path.join(dirpath, filename)
+            dst_path = os.path.join(root_folder, filename)
+            
+            # If file with same name exists, optionally rename or skip
+            if os.path.exists(dst_path):
+                base, ext = os.path.splitext(filename)
+                counter = 1
+                while os.path.exists(dst_path):
+                    dst_path = os.path.join(root_folder, f"{base}_{counter}{ext}")
+                    counter += 1
+
+            shutil.move(src_path, dst_path)
+
+        # Remove empty subdirectories (but skip the root folder)
+        if dirpath != root_folder:
+            try:
+                os.rmdir(dirpath)
+            except OSError:
+                print(f"Could not remove {dirpath} — not empty or in use.")
+
+
+
+if __name__=='__main__':
     pass

{dbdicom-0.3.6 → dbdicom-0.3.8}/src/dbdicom/dataset.py

@@ -344,10 +344,24 @@ def format_value(value, VR=None, tag=None):
             #return value[:64]
     if VR == 'TM':
         return variables.seconds_to_str(value)
+    if VR == 'DA':
+        if not is_valid_dicom_date(value):
+            return '99991231'
     
     return value
 
 
+
+def is_valid_dicom_date(da_str: str) -> bool:
+    if not isinstance(da_str, str) or len(da_str) != 8 or not da_str.isdigit():
+        return False
+    try:
+        datetime.strptime(da_str, "%Y%m%d")
+        return True
+    except ValueError:
+        return False
+
+
 def check_value(value, tag):
 
     # If the change below is made (TM, DA, DT) then this needs to 

{dbdicom-0.3.6 → dbdicom-0.3.8}/src/dbdicom/dbd.py

@@ -2,6 +2,8 @@ import os
 from datetime import datetime
 import json
 from typing import Union
+import zipfile
+import re
 
 from tqdm import tqdm
 import numpy as np
@@ -650,37 +652,43 @@ class DataBaseDicom():
         self.delete(from_entity)
         return self
     
-    def split_series(self, series:list, attr:Union[str, tuple]) -> dict:
+    def split_series(self, series:list, attr:Union[str, tuple], key=None) -> list:
         """
         Split a series into multiple series
         
         Args:
             series (list): series to split.
             attr (str or tuple): dicom attribute to split the series by. 
+            key (function): split by by key(attr)
         Returns:
-            dict: dictionary with keys the unique values found (ascending) 
-            and as values the series corresponding to that value.         
+            list: list of two-element tuples, where the first element is
+            is the value and the second element is the series corresponding to that value.         
         """
 
         # Find all values of the attr and list files per value
         all_files = register.files(self.register, series)
-        files = {}
+        files = []
+        values = []
         for f in tqdm(all_files, desc=f'Reading {attr}'):
             ds = dbdataset.read_dataset(f)
             v = dbdataset.get_values(ds, attr)
-            if v in files:
-                files[v].append(f)
+            if key is not None:
+                v = key(v)
+            if v in values:
+                index = values.index(v)
+                files[index].append(f)
             else:
-                files[v] = [f]
+                values.append(v)
+                files.append([f])
 
         # Copy the files for each value (sorted) to new series
-        values = sorted(list(files.keys()))
-        split_series = {}
-        for v in tqdm(values, desc='Writing new series'):
+        split_series = []
+        for index, v in tqdm(enumerate(values), desc='Writing new series'):
             series_desc = series[-1] if isinstance(series, str) else series[-1][0]
-            series_v = series[:3] + [f'{series_desc}_{attr}_{v}']
-            self._files_to_series(files[v], series_v)
-            split_series[v] = series_v
+            series_desc = clean_folder_name(f'{series_desc}_{attr}_{v}')
+            series_v = series[:3] + [(series_desc, 0)]
+            self._files_to_series(files[index], series_v)
+            split_series.append((v, series_v))
         return split_series
 
 
@@ -880,6 +888,57 @@ class DataBaseDicom():
         register.add_instance(self.register, attr, rel_path)
 
 
+    def archive(self, archive_path):
+        # TODO add flat=True option for zipping at patient level
+        for pt in tqdm(self.register, desc='Archiving '):
+            for st in pt['studies']:
+                zip_dir = os.path.join(
+                    archive_path,
+                    f"Patient__{pt['PatientID']}", 
+                    f"Study__{st['StudyID']}__{st['StudyDescription']}", 
+                )
+                os.makedirs(zip_dir, exist_ok=True)
+                for sr in st['series']:
+                    try:
+                        zip_file = os.path.join(
+                            zip_dir, 
+                            f"Series__{sr['SeriesNumber']}__{sr['SeriesDescription']}.zip",
+                        )
+                        with zipfile.ZipFile(zip_file, 'w') as zipf:
+                            for rel_path in sr['instances'].values():
+                                file = os.path.join(self.path, rel_path)
+                                zipf.write(file, arcname=os.path.basename(file))
+                    except Exception as e:
+                        raise RuntimeError(
+                            f"Error extracting series {sr['SeriesDescription']} "
+                            f"in study {st['StudyDescription']} of patient {pt['PatientID']}."
+                        )
+
+
+
+
+def clean_folder_name(name, replacement="", max_length=255):
+    # Strip leading/trailing whitespace
+    name = name.strip()
+
+    # Replace invalid characters (Windows, macOS, Linux-safe)
+    illegal_chars = r'[<>:"/\\|?*\[\]\x00-\x1F\x7F]'
+    name = re.sub(illegal_chars, replacement, name)
+
+    # Replace reserved Windows names
+    reserved = {
+        "CON", "PRN", "AUX", "NUL",
+        *(f"COM{i}" for i in range(1, 10)),
+        *(f"LPT{i}" for i in range(1, 10))
+    }
+    name_upper = name.upper().split(".")[0]  # Just base name
+    if name_upper in reserved:
+        name = f"{name}_folder"
+
+    # Truncate to max length (common max: 255 bytes)
+    return name[:max_length] or "folder"
+
+
 
 def infer_slice_spacing(vols):
     # In case spacing between slices is not (correctly) encoded in 

{dbdicom-0.3.6 → dbdicom-0.3.8/src/dbdicom.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbdicom
-Version: 0.3.6
+Version: 0.3.8
 Summary: A pythonic interface for reading and writing DICOM databases
 Author-email: Steven Sourbron <s.sourbron@sheffield.ac.uk>, Ebony Gunwhy <e.gunwhy@sheffield.ac.uk>
 Project-URL: Homepage, https://openmiblab.github.io/dbdicom/