sniff_size => sizeof_hdr

Author: Ben Cipollini

nibabel/analyze.py

@@ -190,7 +190,6 @@ class AnalyzeHeader(LabeledWrapStruct):
     has_data_intercept = False
 
     sizeof_hdr = 348
-    sniff_size = 348
 
     def __init__(self,
                  binaryblock=None,
@@ -895,11 +894,11 @@ def _chk_pixdims(hdr, fix=False):
 
     @classmethod
     def is_header(klass, binaryblock):
-        if len(binaryblock) < klass.sniff_size:
-            raise ValueError('Must pass a binary block >= %d bytes' % klass.sniff_size)
+        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.sniff_size])
+                         buffer=binaryblock[:klass.sizeof_hdr])
         bs_hdr = hdr.byteswap()
         return 348 in (hdr['sizeof_hdr'], bs_hdr['sizeof_hdr'])
 

nibabel/minc1.py

@@ -270,7 +270,7 @@ class MincHeader(Header):
     """
     # We don't use the data layout - this just in case we do later
     data_layout = 'C'
-    sniff_size = 4
+    sizeof_hdr = 4
 
     def data_to_fileobj(self, data, fileobj, rescale=True):
         """ See Header class for an implementation we can't use """

nibabel/nifti1.py

@@ -558,9 +558,6 @@ class Nifti1Header(SpmAnalyzeHeader):
     pair_magic = b'ni1'
     single_magic = b'n+1'
 
-    # for sniffing type
-    sniff_size = 348
-
     # Quaternion threshold near 0, based on float32 precision
     quaternion_threshold = -np.finfo(np.float32).eps * 3
 
@@ -1616,11 +1613,11 @@ def _chk_xform_code(klass, code_type, hdr, fix):
 
     @classmethod
     def is_header(klass, binaryblock):
-        if len(binaryblock) < klass.sniff_size:
-            raise ValueError('Must pass a binary block >= %d bytes' % klass.sniff_size)
+        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.sniff_size])
+                         buffer=binaryblock[:klass.sizeof_hdr])
         return hdr['magic'] in (b'ni1', b'n+1')
 
 

nibabel/nifti2.py

@@ -141,9 +141,6 @@ class Nifti2Header(Nifti1Header):
     # Size of header in sizeof_hdr field
     sizeof_hdr = 540
 
-    # sniff size to determine type
-    sniff_size = 540
-
     # Quaternion threshold near 0, based on float64 preicision
     quaternion_threshold = -np.finfo(np.float64).eps * 3
 
@@ -226,11 +223,11 @@ def _chk_eol_check(hdr, fix=False):
 
     @classmethod
     def is_header(klass, binaryblock):
-        if len(binaryblock) < klass.sniff_size:
-            raise ValueError('Must pass a binary block >= %d bytes' % klass.sniff_size)
+        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.sniff_size])
+                         buffer=binaryblock[:klass.sizeof_hdr])
         bs_hdr = hdr.byteswap()
         return 540 in (hdr['sizeof_hdr'], bs_hdr['sizeof_hdr'])
 

nibabel/spatialimages.py

@@ -904,15 +904,15 @@ def is_image(klass, filename, sniff=None):
                         break
 
         try:
-            klass_sniff_size = getattr(klass.header_class, 'sniff_size', 0)
+            klass_sizeof_hdr = getattr(klass.header_class, 'sizeof_hdr', 0)
 
-            if not sniff or len(sniff) < klass_sniff_size:
+            if not sniff or len(sniff) < klass_sizeof_hdr:
                 # 1024 == large size, for efficiency (could iterate over imageclasses).
-                sniff_size = np.max([1024, klass_sniff_size])
+                sizeof_hdr = np.max([1024, klass_sizeof_hdr])
                 with ImageOpener(metadata_filename, 'rb') as fobj:
-                    sniff = fobj.read(sniff_size)
+                    sniff = fobj.read(sizeof_hdr)
 
-            is_header = klass.header_class.is_header(sniff[:klass_sniff_size])
+            is_header = klass.header_class.is_header(sniff[:klass_sizeof_hdr])
         except Exception as e:
             # Can happen if: file doesn't exist,
             #   filesize < necessary sniff size (this happens!)

nibabel/spm2analyze.py

@@ -35,9 +35,6 @@ class Spm2AnalyzeHeader(spm99.Spm99AnalyzeHeader):
     # Copies of module level definitions
     template_dtype = header_dtype
 
-    # binary read size to determine type
-    sniff_size = 348
-
     def get_slope_inter(self):
         ''' Get data scaling (slope) and intercept from header data
 
@@ -118,11 +115,11 @@ def get_slope_inter(self):
 
     @classmethod
     def is_header(klass, binaryblock):
-        if len(binaryblock) < klass.sniff_size:
-            raise ValueError('Must pass a binary block >= %d bytes' % klass.sniff_size)
+        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.sniff_size])
+                         buffer=binaryblock[:klass.sizeof_hdr])
         bs_hdr = hdr.byteswap()
         return (binaryblock[344:348] not in (b'ni1\x00', b'n+1\x00') and
                 348 in (hdr['sizeof_hdr'], bs_hdr['sizeof_hdr']))

nibabel/tests/test_image_types.py

@@ -117,9 +117,9 @@ def check_img(img_path, img_klass, sniff_mode, sniff, expect_success, msg):
 
             if expect_success:
                 new_msg = '%s returned sniff==None (%s)' % (img_klass.__name__, msg)
-                expected_sniff_size = getattr(img_klass.header_class, 'sniff_size', 0)
-                current_sniff_size = len(new_sniff) if new_sniff is not None else 0
-                assert_true(current_sniff_size >= expected_sniff_size, new_msg)
+                expected_sizeof_hdr = getattr(img_klass.header_class, 'sizeof_hdr', 0)
+                current_sizeof_hdr = len(new_sniff) if new_sniff is not None else 0
+                assert_true(current_sizeof_hdr >= expected_sizeof_hdr, new_msg)
 
             # Build a message to the user.
             new_msg = '%s (%s) image is%s a %s image.' % (
@@ -140,20 +140,20 @@ def check_img(img_path, img_klass, sniff_mode, sniff, expect_success, msg):
             else:
                 return sniff
 
-        sniff_size = getattr(expected_img_klass.header_class, 'sniff_size', 0)
+        sizeof_hdr = getattr(expected_img_klass.header_class, 'sizeof_hdr', 0)
 
         for sniff_mode, sniff in dict(
                 vanilla=None,  # use the sniff of the previous item
                 no_sniff=None,  # Don't pass a sniff
                 none=None,  # pass None as the sniff, should query in fn
                 empty='',  # pass an empty sniff, should query in fn
-                irrelevant='a' * (sniff_size - 1),  # A too-small sniff, query
-                bad_sniff='a' * sniff_size).items():  # Bad sniff, should fail.
+                irrelevant='a' * (sizeof_hdr - 1),  # A too-small sniff, query
+                bad_sniff='a' * sizeof_hdr).items():  # Bad sniff, should fail.
 
             for klass in img_klasses:
                 if klass == expected_img_klass:
                     expect_success = (sniff_mode not in ['bad_sniff'] or
-                                      sniff_size == 0 or
+                                      sizeof_hdr == 0 or
                                       klass == Minc1Image)  # special case...
                 elif (issubclass(klass, expected_img_klass) or
                       issubclass(expected_img_klass, klass)):