A bit more f-strings, but that's it

Author: jond01

nibabel/streamlines/tck.py

@@ -330,8 +330,8 @@ def _read_header(fileobj):
             hdr['datatype'] = "Float32LE"
 
         if not hdr['datatype'].startswith('Float32'):
-            msg = ("TCK only supports float32 dtype but 'datatype: {}' was"
-                   " specified in the header.").format(hdr['datatype'])
+            msg = (f"TCK only supports float32 dtype but 'datatype: "
+                   f"{hdr['datatype']}' was specified in the header.")
             raise HeaderError(msg)
 
         if 'file' not in hdr:
@@ -341,9 +341,9 @@ def _read_header(fileobj):
             hdr['file'] = f'. {offset_data}'
 
         if hdr['file'].split()[0] != '.':
-            msg = ("TCK only supports single-file - in other words the"
-                   " filename part must be specified as '.' but '{}' was"
-                   " specified.").format(hdr['file'].split()[0])
+            msg = (f"TCK only supports single-file - in other words the"
+                   f" filename part must be specified as '.' but "
+                   f"'{hdr['file'].split()[0]}' was specified.")
             raise HeaderError("Missing 'file' attribute in TCK header.")
 
         # Set endianness and _dtype attributes in the header.
@@ -454,6 +454,6 @@ def __str__(self):
         info = ""
         info += f"\nMAGIC NUMBER: {hdr[Field.MAGIC_NUMBER]}"
         info += "\n"
-        info += "\n".join(["{}: {}".format(k, v)
+        info += "\n".join([f"{k}: {v}"
                            for k, v in hdr.items() if not k.startswith('_')])
         return info

nibabel/streamlines/tractogram.py

@@ -109,8 +109,8 @@ def __setitem__(self, key, value):
 
         # We make sure there is the right amount of values
         if self.n_rows > 0 and len(value) != self.n_rows:
-            msg = ("The number of values ({0}) should match n_elements "
-                   "({1}).").format(len(value), self.n_rows)
+            msg = (f"The number of values ({len(value)}) should match "
+                   f"n_elements ({self.n_rows}).")
             raise ValueError(msg)
 
         self.store[key] = value
@@ -140,10 +140,9 @@ def extend(self, other):
         """
         if (len(self) > 0 and len(other) > 0 and
                 sorted(self.keys()) != sorted(other.keys())):
-            msg = ("Entry mismatched between the two PerArrayDict objects."
-                   " This PerArrayDict contains '{0}' whereas the other "
-                   " contains '{1}'.").format(sorted(self.keys()),
-                                              sorted(other.keys()))
+            msg = (f"Entry mismatched between the two PerArrayDict objects. "
+                   f"This PerArrayDict contains '{sorted(self.keys())}' "
+                   f"whereas the other contains '{sorted(other.keys())}'.")
             raise ValueError(msg)
 
         self.n_rows += other.n_rows
@@ -365,8 +364,8 @@ def affine_to_rasmm(self, value):
         if value is not None:
             value = np.array(value)
             if value.shape != (4, 4):
-                msg = ("Affine matrix has a shape of (4, 4) but a ndarray with"
-                       "shape {} was provided instead.").format(value.shape)
+                msg = (f"Affine matrix has a shape of (4, 4) but a ndarray with"
+                       f"shape {value.shape} was provided instead.")
                 raise ValueError(msg)
 
         self._affine_to_rasmm = value

nibabel/streamlines/trk.py

@@ -153,15 +153,14 @@ def encode_value_in_name(value, name, max_name_len=20):
         `value`, padded with ``\x00`` bytes.
     """
     if len(name) > max_name_len:
-        msg = ("Data information named '{0}' is too long"
-               " (max {1} characters.)").format(name, max_name_len)
+        msg = (f"Data information named '{name}' is too long"
+               f" (max {max_name_len} characters.)")
         raise ValueError(msg)
     encoded_name = name if value <= 1 else name + '\x00' + str(value)
     if len(encoded_name) > max_name_len:
-        msg = ("Data information named '{0}' is too long (need to be less"
-               " than {1} characters when storing more than one value"
-               " for a given data information."
-               ).format(name, max_name_len - (len(str(value)) + 1))
+        msg = (f"Data information named '{name}' is too long (need to be less"
+               f" than {max_name_len - (len(str(value)) + 1)} characters "
+               f"when storing more than one value for a given data information.")
         raise ValueError(msg)
     # Fill to the end with zeros
     return encoded_name.ljust(max_name_len, '\x00').encode('latin1')
@@ -196,8 +195,8 @@ def decode_value_from_name(encoded_name):
         value = int(splits[1])  # Decode value.
     elif len(splits) > 2:
         # The remaining bytes are not \x00, raising.
-        msg = ("Wrong scalar_name or property_name: '{0}'."
-               " Unused characters should be \\x00.").format(encoded_name)
+        msg = (f"Wrong scalar_name or property_name: '{encoded_name}'."
+               f" Unused characters should be \\x00.")
         raise HeaderError(msg)
 
     return name, value
@@ -473,9 +472,9 @@ def save(self, fileobj):
             # Update field 'property_name' using 'data_per_streamline'.
             data_for_streamline = first_item.data_for_streamline
             if len(data_for_streamline) > MAX_NB_NAMED_PROPERTIES_PER_STREAMLINE:
-                msg = ("Can only store {0} named data_per_streamline (also"
-                       " known as 'properties' in the TRK format)."
-                       ).format(MAX_NB_NAMED_SCALARS_PER_POINT)
+                msg = (f"Can only store {MAX_NB_NAMED_SCALARS_PER_POINT} named "
+                       f"data_per_streamline (also known as 'properties' in the "
+                       f"TRK format).")
                 raise ValueError(msg)
 
             data_for_streamline_keys = sorted(data_for_streamline.keys())
@@ -491,9 +490,9 @@ def save(self, fileobj):
             # Update field 'scalar_name' using 'tractogram.data_per_point'.
             data_for_points = first_item.data_for_points
             if len(data_for_points) > MAX_NB_NAMED_SCALARS_PER_POINT:
-                msg = ("Can only store {0} named data_per_point (also known"
-                       " as 'scalars' in the TRK format)."
-                       ).format(MAX_NB_NAMED_SCALARS_PER_POINT)
+                msg = (f"Can only store {MAX_NB_NAMED_SCALARS_PER_POINT} "
+                       f"named data_per_point (also known as 'scalars' in "
+                       f"the TRK format).")
                 raise ValueError(msg)
 
             data_for_points_keys = sorted(data_for_points.keys())
@@ -588,9 +587,9 @@ def _read_header(fileobj):
                 # Swap byte order
                 header_rec = header_rec.newbyteorder()
                 if header_rec['hdr_size'] != TrkFile.HEADER_SIZE:
-                    msg = "Invalid hdr_size: {0} instead of {1}"
-                    raise HeaderError(msg.format(header_rec['hdr_size'],
-                                                 TrkFile.HEADER_SIZE))
+                    msg = (f"Invalid hdr_size: {header_rec['hdr_size']} "
+                           f"instead of {TrkFile.HEADER_SIZE}")
+                    raise HeaderError(msg)
 
             if header_rec['version'] == 1:
                 # There is no 4x4 matrix for voxel to RAS transformation.
@@ -616,9 +615,9 @@ def _read_header(fileobj):
             # able to determine the axis directions.
             axcodes = aff2axcodes(header[Field.VOXEL_TO_RASMM])
             if None in axcodes:
-                msg = ("The 'vox_to_ras' affine is invalid! Could not"
-                       " determine the axis directions from it.\n{0}"
-                       ).format(header[Field.VOXEL_TO_RASMM])
+                msg = (f"The 'vox_to_ras' affine is invalid! Could not"
+                       f" determine the axis directions from it.\n"
+                       f"{header[Field.VOXEL_TO_RASMM]}")
                 raise HeaderError(msg)
 
             # By default, the voxel order is LPS.

nibabel/tests/test_analyze.py

@@ -141,7 +141,8 @@ def test_log_checks(self):
             fhdr, message, raiser = self.log_chk(hdr, 30)
 
         assert fhdr['sizeof_hdr'] == self.sizeof_hdr
-        assert message == 'sizeof_hdr should be {0}; set sizeof_hdr to {0}'.format(self.sizeof_hdr)
+        assert (message == f'sizeof_hdr should be {self.sizeof_hdr}; '
+                           f'set sizeof_hdr to {self.sizeof_hdr}')
         pytest.raises(*raiser)
         # RGB datatype does not raise error
         hdr = HC()