RF: refactor using valid_exts, _meta_sniff_len

This is a refactor, trying to separate the idea of valid extensions for
loading images, from compressed extra suffixes.

Author: matthew-brett

nibabel/analyze.py

@@ -908,7 +908,9 @@ class AnalyzeImage(SpatialImage):
     """ Class for basic Analyze format image
     """
     header_class = AnalyzeHeader
+    _meta_sniff_len = header_class.sizeof_hdr
     files_types = (('image', '.img'), ('header', '.hdr'))
+    valid_exts = ('.img', '.hdr')
     _compressed_exts = ('.gz', '.bz2')
 
     makeable = True

nibabel/ecat.py

@@ -732,6 +732,7 @@ class EcatImage(SpatialImage):
     """
     _header = EcatHeader
     header_class = _header
+    valid_exts = ('.v',)
     _subheader = EcatSubHeader
     files_types = (('image', '.v'), ('header', '.v'))
 

nibabel/freesurfer/mghformat.py

@@ -454,13 +454,17 @@ def writeftr_to(self, fileobj):
         fileobj.write(ftr_nd.tostring())
 
 
-@ImageOpener.register_ext_from_image('.mgz', ImageOpener.gz_def)
+# Register .mgz extension as compressed
+ImageOpener.compress_ext_map['.mgz'] = ImageOpener.gz_def
+
+
 class MGHImage(SpatialImage):
     """ Class for MGH format image
     """
     header_class = MGHHeader
+    valid_exts = ('.mgh', '.mgz')
     files_types = (('image', '.mgh'),)
-    _compressed_exts = (('.gz',))
+    _compressed_exts = ()
 
     makeable = True
     rw = True

nibabel/freesurfer/tests/test_mghformat.py

@@ -145,7 +145,7 @@ def test_filename_exts():
     # and the default affine matrix (Note the "None")
     img = MGHImage(v, None)
     # Check if these extensions allow round trip
-    for ext in ('.mgh', '.mgz', '.mgh.gz'):
+    for ext in ('.mgh', '.mgz'):
         with InTemporaryDirectory():
             fname = 'tmpname' + ext
             save(img, fname)

nibabel/loadsave.py

@@ -110,7 +110,7 @@ def save(img, filename):
         klass = Nifti2Image
     else:  # arbitrary conversion
         valid_klasses = [klass for klass in all_image_classes
-                         if klass.is_valid_extension(ext)]
+                         if ext in klass.valid_exts]
         if not valid_klasses:  # if list is empty
             raise ImageFileError('Cannot work out file type of "%s"' %
                                  filename)

nibabel/minc1.py

@@ -298,6 +298,8 @@ class Minc1Image(SpatialImage):
     load.
     '''
     header_class = Minc1Header
+    _meta_sniff_len = 4
+    valid_exts = ('.mnc',)
     files_types = (('image', '.mnc'),)
     _compressed_exts = ('.gz', '.bz2')
 

nibabel/nifti1.py

@@ -1632,6 +1632,7 @@ class Nifti1Pair(analyze.AnalyzeImage):
     """ Class for NIfTI1 format image, header pair
     """
     header_class = Nifti1PairHeader
+    _meta_sniff_len = header_class.sizeof_hdr
     rw = True
 
     def __init__(self, dataobj, affine, header=None,
@@ -1856,6 +1857,7 @@ class Nifti1Image(Nifti1Pair):
     """ Class for single file NIfTI1 format image
     """
     header_class = Nifti1Header
+    valid_exts = ('.nii',)
     files_types = (('image', '.nii'),)
 
     @staticmethod

nibabel/nifti2.py

@@ -243,12 +243,14 @@ class Nifti2Pair(Nifti1Pair):
     """ Class for NIfTI2 format image, header pair
     """
     header_class = Nifti2PairHeader
+    _meta_sniff_len = header_class.sizeof_hdr
 
 
 class Nifti2Image(Nifti1Image):
     """ Class for single file NIfTI2 format image
     """
     header_class = Nifti2Header
+    _meta_sniff_len = header_class.sizeof_hdr
 
 
 def load(filename):

nibabel/parrec.py

@@ -1020,6 +1020,7 @@ def get_sorted_slice_indices(self):
 class PARRECImage(SpatialImage):
     """PAR/REC image"""
     header_class = PARRECHeader
+    valid_exts = ('.rec', '.par')
     files_types = (('image', '.rec'), ('header', '.par'))
 
     makeable = False

nibabel/spatialimages.py

@@ -324,8 +324,9 @@ class ImageFileError(Exception):
 class SpatialImage(object):
     ''' Template class for images '''
     header_class = Header
+    _meta_sniff_len = 0
     files_types = (('image', None),)
-    alternate_exts = ()  # Modified by @ImageOpener.register_ext_from_image
+    valid_exts = ()
     _compressed_exts = ()
 
     makeable = True  # Used in test code
@@ -874,51 +875,37 @@ def from_image(klass, img):
                      extra=img.extra.copy())
 
     @classmethod
-    def is_valid_extension(klass, ext):
-        valid = tuple(ft[1] for ft in klass.files_types) + klass.alternate_exts
-        return ext.lower() in valid
+    def _sniff_meta_for(klass, filename, sniff_nbytes):
+        froot, ext, trailing = splitext_addext(filename,
+                                               klass._compressed_exts)
+        # Determine the metadata location, then sniff it
+        t_fnames = types_filenames(filename,
+                                   klass.files_types,
+                                   trailing_suffixes=klass._compressed_exts)
+        meta_fname = t_fnames.get('header', filename)
+        try:
+            with ImageOpener(meta_fname, 'rb') as fobj:
+                sniff = fobj.read(sniff_nbytes)
+        except IOError:
+            return None
+        return sniff
 
     @classmethod
-    def path_maybe_image(klass, filename, sniff=None):
+    def path_maybe_image(klass, filename, sniff=None, sniff_max=1024):
         froot, ext, trailing = splitext_addext(filename,
                                                klass._compressed_exts)
-
-        if not klass.is_valid_extension(ext):
+        if ext.lower() not in klass.valid_exts:
             return False, sniff
-        elif not hasattr(klass.header_class, 'may_contain_header'):
+        if not hasattr(klass.header_class, 'may_contain_header'):
             return True, sniff
-
-        # Determine the metadata location, then sniff it
-        header_exts = [ft[1] for ft in klass.files_types if ft[0] == 'header']
-        if len(header_exts) == 0:
-            metadata_filename = filename
-        else:
-            # Search for an acceptable existing header;
-            #   could be compressed or not...
-            for ext in header_exts:
-                for tr_ext in np.unique([trailing, ''] +
-                                        list(klass._compressed_exts)):
-                    metadata_filename = froot + ext + tr_ext
-                    if os.path.exists(metadata_filename):
-                        break
-
-        try:
-            klass_sizeof_hdr = getattr(klass.header_class, 'sizeof_hdr', 0)
-
-            if not sniff or len(sniff) < klass_sizeof_hdr:
-                # 1024 bytes is currently larger than all headers
-                sizeof_hdr = np.max([1024, klass_sizeof_hdr])
-                with ImageOpener(metadata_filename, 'rb') as fobj:
-                    sniff = fobj.read(sizeof_hdr)
-
-            may_contain_header = klass.header_class.may_contain_header(sniff)
-        except Exception:
-            # Can happen if: file doesn't exist,
-            #   filesize < necessary sniff size (this happens!)
-            #   other unexpected errors.
-            may_contain_header = False
-
-        return may_contain_header, sniff
+        if sniff is None or len(sniff) < klass._meta_sniff_len:
+            sniff_nbytes = max(klass._meta_sniff_len, sniff_max)
+            sniff = klass._sniff_meta_for(filename, sniff_nbytes)
+        if sniff is None:  # Can't sniff, won't sniff
+            return False, None
+        if len(sniff) < klass._meta_sniff_len:
+            return False, sniff
+        return klass.header_class.may_contain_header(sniff), sniff
 
     def __getitem__(self):
         ''' No slicing or dictionary interface for images