RF: move dicom / pydicom imports into own module

Move logic for conditionally importing dicom or pydicom into own module,
and use this module where we are using dicom routines.

Author: matthew-brett

nibabel/dft.py

@@ -26,9 +26,7 @@
 
 from .nifti1 import Nifti1Header
 
-# Shield optional dicom import
-from .optpkg import optional_package
-dicom, have_dicom, _ = optional_package('dicom')
+from .pydicom_compat import pydicom, read_file
 
 logger = logging.getLogger('nibabel.dft')
 
@@ -236,7 +234,7 @@ def __getattribute__(self, name):
         return val
 
     def dicom(self):
-        return dicom.read_file(self.files[0])
+        return read_file(self.files[0])
 
 
 class _db_nochange:
@@ -383,8 +381,8 @@ def _update_dir(c, dir, files, studies, series, storage_instances):
 
 def _update_file(c, path, fname, studies, series, storage_instances):
     try:
-        do = dicom.read_file('%s/%s' % (path, fname))
-    except dicom.filereader.InvalidDicomError:
+        do = read_file('%s/%s' % (path, fname))
+    except pydicom.filereader.InvalidDicomError:
         logger.debug('        not a DICOM file')
         return None
     try:

nibabel/nicom/dicomwrappers.py

@@ -50,10 +50,7 @@ def wrapper_from_file(file_like, *args, **kwargs):
     dcm_w : ``dicomwrappers.Wrapper`` or subclass
        DICOM wrapper corresponding to DICOM data type
     """
-    try:
-        from dicom import read_file
-    except ImportError:
-        from pydicom.dicomio import read_file
+    from ..pydicom_compat import read_file
 
     with ImageOpener(file_like) as fobj:
         dcm_data = read_file(fobj, *args, **kwargs)

nibabel/nicom/tests/test_csareader.py

@@ -14,10 +14,8 @@
 
 from numpy.testing.decorators import skipif
 
-from .test_dicomwrappers import (have_dicom, dicom_test,
-                                 IO_DATA_PATH, DATA, DATA_FILE)
-if have_dicom:
-    from .test_dicomwrappers import pydicom
+from nibabel.pydicom_compat import dicom_test, pydicom
+from .test_dicomwrappers import (IO_DATA_PATH, DATA)
 
 CSA2_B0 = open(pjoin(IO_DATA_PATH, 'csa2_b0.bin'), 'rb').read()
 CSA2_B1000 = open(pjoin(IO_DATA_PATH, 'csa2_b1000.bin'), 'rb').read()

nibabel/nicom/tests/test_dicomreaders.py

@@ -6,8 +6,9 @@
 
 from .. import dicomreaders as didr
 
-from .test_dicomwrappers import (dicom_test,
-                                 EXPECTED_AFFINE,
+from nibabel.pydicom_compat import dicom_test, pydicom
+
+from .test_dicomwrappers import (EXPECTED_AFFINE,
                                  EXPECTED_PARAMS,
                                  IO_DATA_PATH,
                                  DATA)
@@ -41,10 +42,6 @@ def test_passing_kwds():
     # Check that we correctly pass keywords to dicom
     dwi_glob = 'siemens_dwi_*.dcm.gz'
     csa_glob = 'csa*.bin'
-    try:
-        from dicom.filereader import InvalidDicomError
-    except ImportError:
-        from pydicom.filereader import InvalidDicomError
     for func in (didr.read_mosaic_dwi_dir, didr.read_mosaic_dir):
         data, aff, bs, gs = func(IO_DATA_PATH, dwi_glob)
         # This should not raise an error
@@ -60,7 +57,7 @@ def test_passing_kwds():
                       dwi_glob,
                       dicom_kwargs=dict(not_a_parameter=True))
         # These are invalid dicoms, so will raise an error unless force=True
-        assert_raises(InvalidDicomError,
+        assert_raises(pydicom.filereader.InvalidDicomError,
                       func,
                       IO_DATA_PATH,
                       csa_glob)

nibabel/nicom/tests/test_dicomwrappers.py

@@ -9,19 +9,7 @@
 
 import numpy as np
 
-have_dicom = True
-try:
-    import dicom as pydicom
-    read_file = pydicom.read_file
-except ImportError:
-    try:
-        import pydicom
-    except ImportError:
-        have_dicom = False
-    else:
-        from pydicom.dicomio import read_file
-dicom_test = np.testing.dec.skipif(not have_dicom,
-                                   'could not import pydicom')
+from nibabel.pydicom_compat import have_dicom, pydicom, read_file, dicom_test
 
 from .. import dicomwrappers as didw
 from .. import dicomreaders as didr

nibabel/nicom/tests/test_utils.py

@@ -12,8 +12,8 @@
 
 from ..utils import find_private_section
 
-from .test_dicomwrappers import (have_dicom, dicom_test,
-                                 IO_DATA_PATH, DATA, DATA_PHILIPS)
+from nibabel.pydicom_compat import dicom_test, pydicom
+from .test_dicomwrappers import (DATA, DATA_PHILIPS)
 
 
 @dicom_test
@@ -27,11 +27,7 @@ def test_find_private_section_real():
     assert_equal(find_private_section(DATA_PHILIPS, 0x29, 'SIEMENS CSA HEADER'),
                  None)
     # Make fake datasets
-    try:
-        from dicom.dataset import Dataset
-    except ImportError:
-        from pydicom.dataset import Dataset
-    ds = Dataset({})
+    ds = pydicom.dataset.Dataset({})
     ds.add_new((0x11, 0x10), 'LO', b'some section')
     assert_equal(find_private_section(ds, 0x11, 'some section'), 0x1000)
     ds.add_new((0x11, 0x11), 'LO', b'anther section')

nibabel/nifti1.py

@@ -12,6 +12,7 @@
 '''
 from __future__ import division, print_function
 import warnings
+from io import BytesIO
 
 import numpy as np
 import numpy.linalg as npl
@@ -24,6 +25,7 @@
 from . import analyze  # module import
 from .spm99analyze import SpmAnalyzeHeader
 from .casting import have_binary128
+from .pydicom_compat import have_dicom, pydicom as pdcm
 
 # nifti1 flat header definition for Analyze-like first 348 bytes
 # first number in comments indicates offset in file header in bytes
@@ -392,7 +394,7 @@ def __init__(self, code, content, parent_hdr=None):
             self._is_little_endian = parent_hdr.endianness == '<'
         else:
             self._is_little_endian = True
-        if content.__class__ == Dataset:
+        if content.__class__ == pdcm.dataset.Dataset:
             self._is_implicit_VR = False
             self._raw_content = self._mangle(content)
             self._content = content
@@ -404,13 +406,13 @@ def __init__(self, code, content, parent_hdr=None):
             self._content = ds
         else:  # Otherwise, initialize a new dicom dataset
             self._is_implicit_VR = False
-            self._content = Dataset()
+            self._content = pdcm.dataset.Dataset()
 
     def _unmangle_and_verify(self, content, is_implicit_VR, is_little_endian):
         """"Decode and verify dicom dataset"""
         ds = self._unmangle(content, is_implicit_VR, is_little_endian)
         for elem in ds:
-            if elem.VR not in dicom_converters.keys():
+            if elem.VR not in pdcm.values.converters.keys():
                 raise StandardError  # Ensure that all VRs are valid
         return ds
 
@@ -423,45 +425,37 @@ def _guess_implicit_VR(self):
         valid VRs
         """
         potential_vr = self._raw_content[4:6].decode()
-        if potential_vr in dicom_converters.keys():
+        if potential_vr in pdcm.values.converters.keys():
             implicit_VR = False
         else:
             implicit_VR = True
         return implicit_VR
 
     def _unmangle(self, value, is_implicit_VR=False, is_little_endian=True):
         bio = BytesIO(value)
-        ds = read_dataset(bio, is_implicit_VR, is_little_endian)
+        ds = pdcm.filereader.read_dataset(bio,
+                                          is_implicit_VR,
+                                          is_little_endian)
         return ds
 
     def _mangle(self, dataset):
         bio = BytesIO()
-        dio = DicomFileLike(bio)
+        dio = pdcm.filebase.DicomFileLike(bio)
         dio.is_implicit_VR = self._is_implicit_VR
         dio.is_little_endian = self._is_little_endian
-        ds_len = write_dataset(dio, dataset)
+        ds_len = pdcm.filewriter.write_dataset(dio, dataset)
         dio.seek(0)
         return dio.read(ds_len)
 
 
-try:
-    from dicom.dataset import Dataset
-    from dicom.filebase import DicomFileLike
-    from dicom.filereader import read_dataset
-    from dicom.filewriter import write_dataset
-    from dicom.values import converters as dicom_converters
-    from io import BytesIO
-except ImportError:
-    """Fall back to standard reader if pydicom unavailable."""
-    Nifti1DicomExtension = Nifti1Extension
 
 # NIfTI header extension type codes (ECODE)
 # see nifti1_io.h for a complete list of all known extensions and
 # references to their description or contacts of the respective
 # initiators
 extension_codes = Recoder((
     (0, "ignore", Nifti1Extension),
-    (2, "dicom", Nifti1DicomExtension),
+    (2, "dicom", Nifti1DicomExtension if have_dicom else Nifti1Extension),
     (4, "afni", Nifti1Extension),
     (6, "comment", Nifti1Extension),
     (8, "xcede", Nifti1Extension),

nibabel/pydicom_compat.py

@@ -0,0 +1,39 @@
+""" Adapter module for working with pydicom < 1.0 and >= 1.0
+
+In what follows, "dicom is available" means we can import either a) ``dicom``
+(pydicom < 1.0) or or b) ``pydicom`` (pydicom >= 1.0).
+
+Regardless of whether dicom is available this module should be importable
+without error, and always defines:
+
+* have_dicom : True if we can import pydicom or dicom;
+* pydicom : pydicom module or dicom module or None of not importable;
+* read_file : ``read_file`` function if pydicom or dicom module is importable
+  else None;
+* dicom_test : test decorator that skips test if dicom not available.
+"""
+
+import numpy as np
+
+have_dicom = True
+read_file = None
+pydicom = None
+
+try:
+    import dicom as pydicom
+except ImportError:
+    try:
+        import pydicom
+    except ImportError:
+        have_dicom = False
+    else:  # pydicom module available
+        from pydicom.dicomio import read_file
+        # Values not imported by default
+        import pydicom.values
+else:  # dicom module available
+    read_file = pydicom.read_file
+
+
+# test decorator that skips test if dicom not available.
+dicom_test = np.testing.dec.skipif(not have_dicom,
+                                   'could not import dicom or pydicom')

nibabel/tests/test_dft.py

@@ -17,8 +17,10 @@
 
 # Shield optional package imports
 from ..optpkg import optional_package
+
 # setup_module will raise SkipTest if no dicom to import
-dicom, have_dicom, _ = optional_package('dicom')
+from nibabel.pydicom_compat import have_dicom
+
 PImage, have_pil, _ = optional_package('PIL.Image')
 pil_test = np.testing.dec.skipif(not have_pil, 'could not import PIL.Image')
 

nibabel/tests/test_nifti1.py

@@ -10,6 +10,7 @@
 from __future__ import division, print_function, absolute_import
 import os
 import warnings
+import struct
 
 import numpy as np
 
@@ -43,12 +44,8 @@
 header_file = os.path.join(data_path, 'nifti1.hdr')
 image_file = os.path.join(data_path, 'example4d.nii.gz')
 
-from nibabel.optpkg import optional_package
-dicom, have_dicom, _ = optional_package('dicom')
-import struct
+from nibabel.pydicom_compat import pydicom, dicom_test
 
-dicom_test = np.testing.dec.skipif(not have_dicom,
-    'could not import pydicom')
 
 # Example transformation matrix
 R = [[0, -1, 0], [1, 0, 0], [0, 0, 1]]  # rotation matrix
@@ -1133,14 +1130,14 @@ def test_nifti_dicom_extension():
 
     # create an empty dataset if no content provided (to write a new header)
     dcmext = Nifti1DicomExtension(2, b'')
-    assert_equal(dcmext.get_content().__class__, dicom.dataset.Dataset)
+    assert_equal(dcmext.get_content().__class__, pydicom.dataset.Dataset)
     assert_equal(len(dcmext.get_content().values()), 0)
 
     # use a dataset if provided
-    ds = dicom.dataset.Dataset()
+    ds = pydicom.dataset.Dataset()
     ds.add_new((0x10, 0x20), 'LO', 'NiPy')
     dcmext = Nifti1DicomExtension(2, ds)
-    assert_equal(dcmext.get_content().__class__, dicom.dataset.Dataset)
+    assert_equal(dcmext.get_content().__class__, pydicom.dataset.Dataset)
     assert_equal(len(dcmext.get_content().values()), 1)
     assert_equal(dcmext.get_content().PatientID, 'NiPy')