RF: Rename is_header to may_contain_header

Rename hdr variables to hdr_struct to reduce confusion
Rename is_image to path_maybe_image

Author: effigies

nibabel/analyze.py

@@ -893,15 +893,15 @@ def _chk_pixdims(hdr, fix=False):
         return hdr, rep
 
     @classmethod
-    def is_header(klass, binaryblock):
+    def may_contain_header(klass, binaryblock):
         if len(binaryblock) < klass.sizeof_hdr:
             raise ValueError('Must pass a binary block >= %d bytes' %
                              klass.sizeof_hdr)
 
-        hdr = np.ndarray(shape=(), dtype=header_dtype,
-                         buffer=binaryblock[:klass.sizeof_hdr])
-        bs_hdr = hdr.byteswap()
-        return 348 in (hdr['sizeof_hdr'], bs_hdr['sizeof_hdr'])
+        hdr_struct = np.ndarray(shape=(), dtype=header_dtype,
+                                buffer=binaryblock[:klass.sizeof_hdr])
+        bs_hdr_struct = hdr_struct.byteswap()
+        return 348 in (hdr_struct['sizeof_hdr'], bs_hdr_struct['sizeof_hdr'])
 
 
 class AnalyzeImage(SpatialImage):

nibabel/loadsave.py

@@ -36,7 +36,7 @@ def load(filename, **kwargs):
 
     sniff = None
     for image_klass in all_image_classes:
-        is_valid, sniff = image_klass.is_image(filename, sniff)
+        is_valid, sniff = image_klass.path_maybe_image(filename, sniff)
         if is_valid:
             return image_klass.from_filename(filename, **kwargs)
 

nibabel/minc1.py

@@ -282,7 +282,7 @@ def data_from_fileobj(self, fileobj):
 
 class Minc1Header(MincHeader):
     @classmethod
-    def is_header(klass, binaryblock):
+    def may_contain_header(klass, binaryblock):
         if len(binaryblock) < klass.sizeof_hdr:
             raise ValueError('Must pass a binary block >= %d bytes' %
                              klass.sizeof_hdr)

nibabel/minc2.py

@@ -136,7 +136,7 @@ def get_scaled_data(self, sliceobj=()):
 
 class Minc2Header(MincHeader):
     @classmethod
-    def is_header(klass, binaryblock):
+    def may_contain_header(klass, binaryblock):
         if len(binaryblock) < klass.sizeof_hdr:
             raise ValueError('Must pass a binary block >= %d bytes' %
                              klass.sizeof_hdr)

nibabel/nifti1.py

@@ -1612,14 +1612,14 @@ def _chk_xform_code(klass, code_type, hdr, fix):
         return hdr, rep
 
     @classmethod
-    def is_header(klass, binaryblock):
+    def may_contain_header(klass, binaryblock):
         if len(binaryblock) < klass.sizeof_hdr:
             raise ValueError('Must pass a binary block >= %d bytes' %
                              klass.sizeof_hdr)
 
-        hdr = np.ndarray(shape=(), dtype=header_dtype,
-                         buffer=binaryblock[:klass.sizeof_hdr])
-        return hdr['magic'] in (b'ni1', b'n+1')
+        hdr_struct = np.ndarray(shape=(), dtype=header_dtype,
+                                buffer=binaryblock[:klass.sizeof_hdr])
+        return hdr_struct['magic'] in (b'ni1', b'n+1')
 
 
 class Nifti1PairHeader(Nifti1Header):

nibabel/nifti2.py

@@ -222,15 +222,15 @@ def _chk_eol_check(hdr, fix=False):
         return hdr, rep
 
     @classmethod
-    def is_header(klass, binaryblock):
+    def may_contain_header(klass, binaryblock):
         if len(binaryblock) < klass.sizeof_hdr:
             raise ValueError('Must pass a binary block >= %d bytes' %
                              klass.sizeof_hdr)
 
-        hdr = np.ndarray(shape=(), dtype=header_dtype,
-                         buffer=binaryblock[:klass.sizeof_hdr])
-        bs_hdr = hdr.byteswap()
-        return 540 in (hdr['sizeof_hdr'], bs_hdr['sizeof_hdr'])
+        hdr_struct = np.ndarray(shape=(), dtype=header_dtype,
+                                buffer=binaryblock[:klass.sizeof_hdr])
+        bs_hdr_struct = hdr_struct.byteswap()
+        return 540 in (hdr_struct['sizeof_hdr'], bs_hdr_struct['sizeof_hdr'])
 
 
 class Nifti2PairHeader(Nifti2Header):

nibabel/spatialimages.py

@@ -877,13 +877,13 @@ def is_valid_extension(klass, ext):
         return np.any([ft[1] == ext.lower() for ft in klass.files_types])
 
     @classmethod
-    def is_image(klass, filename, sniff=None):
+    def path_maybe_image(klass, filename, sniff=None):
         froot, ext, trailing = splitext_addext(filename,
                                                klass._compressed_exts)
 
         if not klass.is_valid_extension(ext):
             return False, sniff
-        elif not hasattr(klass.header_class, 'is_header'):
+        elif not hasattr(klass.header_class, 'may_contain_header'):
             return True, sniff
 
         # Determine the metadata location, then sniff it
@@ -909,14 +909,14 @@ def is_image(klass, filename, sniff=None):
                 with ImageOpener(metadata_filename, 'rb') as fobj:
                     sniff = fobj.read(sizeof_hdr)
 
-            is_header = klass.header_class.is_header(sniff)
+            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.
-            is_header = False
+            may_contain_header = False
 
-        return is_header, sniff
+        return may_contain_header, sniff
 
     def __getitem__(self):
         ''' No slicing or dictionary interface for images

nibabel/spm2analyze.py

@@ -114,16 +114,16 @@ def get_slope_inter(self):
         return None, None
 
     @classmethod
-    def is_header(klass, binaryblock):
+    def may_contain_header(klass, binaryblock):
         if len(binaryblock) < klass.sizeof_hdr:
             raise ValueError('Must pass a binary block >= %d bytes' %
                              klass.sizeof_hdr)
 
-        hdr = np.ndarray(shape=(), dtype=header_dtype,
-                         buffer=binaryblock[:klass.sizeof_hdr])
-        bs_hdr = hdr.byteswap()
+        hdr_struct = np.ndarray(shape=(), dtype=header_dtype,
+                                buffer=binaryblock[:klass.sizeof_hdr])
+        bs_hdr_struct = hdr_struct.byteswap()
         return (binaryblock[344:348] not in (b'ni1\x00', b'n+1\x00') and
-                348 in (hdr['sizeof_hdr'], bs_hdr['sizeof_hdr']))
+                348 in (hdr_struct['sizeof_hdr'], bs_hdr_struct['sizeof_hdr']))
 
 
 class Spm2AnalyzeImage(spm99.Spm99AnalyzeImage):

nibabel/tests/test_image_types.py

@@ -6,7 +6,7 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-''' Tests for is_image / is_header functions '''
+''' Tests for is_image / may_contain_header functions '''
 from __future__ import division, print_function, absolute_import
 
 import copy
@@ -21,7 +21,7 @@
                 Spm2AnalyzeImage, Spm99AnalyzeImage,
                 MGHImage, all_image_classes)
 
-from nose.tools import assert_true, assert_equal, assert_raises
+from nose.tools import assert_true, assert_raises
 
 DATA_PATH = pjoin(dirname(__file__), 'data')
 
@@ -34,7 +34,7 @@ def wat(hdr):
                                       AnalyzeHeader]
         for klass in all_analyze_header_klasses:
             try:
-                if klass.is_header(hdr.binaryblock):
+                if klass.may_contain_header(hdr.binaryblock):
                     return klass
                 else:
                     print('checked completed, but failed.')
@@ -106,16 +106,16 @@ def check_img(img_path, img_klass, sniff_mode, sniff, expect_success,
             """Embedded function to do the actual checks expected."""
 
             if sniff_mode == 'empty' and \
-                    hasattr(img_klass.header_class, 'is_header'):
-                assert_raises(ValueError, img_klass.header_class.is_header,
-                              sniff)
+                    hasattr(img_klass.header_class, 'may_contain_header'):
+                assert_raises(ValueError,
+                              img_klass.header_class.may_contain_header, sniff)
 
             if sniff_mode == 'no_sniff':
                 # Don't pass any sniff--not even "None"
-                is_img, new_sniff = img_klass.is_image(img_path)
+                is_img, new_sniff = img_klass.path_maybe_image(img_path)
             else:
                 # Pass a sniff, but don't reuse across images.
-                is_img, new_sniff = img_klass.is_image(img_path, sniff)
+                is_img, new_sniff = img_klass.path_maybe_image(img_path, sniff)
 
             if expect_success:
                 # Check that the sniff returned is appropriate.