Merge pull request astropy#16264 from eerovaher/ruff-034

Update Ruff `pre-commit` hook to v0.3.4

Author: astrofrog

.pre-commit-config.yaml

@@ -60,7 +60,7 @@ repos:
           - tomli
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.3.0"
+    rev: "v0.3.4"
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]

astropy/coordinates/baseframe.py

@@ -526,9 +526,8 @@ def _infer_data(self, args, copy, kwargs):
 
         if len(args) > 0:
             raise TypeError(
-                "{}.__init__ had {} remaining unhandled arguments".format(
-                    self.__class__.__name__, len(args)
-                )
+                f"{type(self).__name__}.__init__ had {len(args)} remaining "
+                "unhandled arguments"
             )
 
         if representation_data is None and differential_data is not None:

astropy/io/ascii/core.py

@@ -762,9 +762,8 @@ def check_column_names(self, names, strict_names, guessing):
             and self.__class__.__name__ != "EcsvHeader"
         ):
             raise ValueError(
-                "Table format guessing requires at least two columns, got {}".format(
-                    list(self.colnames)
-                )
+                "Table format guessing requires at least two columns, "
+                f"got {list(self.colnames)}"
             )
 
         if names is not None and len(names) != len(self.colnames):

astropy/io/ascii/misc.py

@@ -105,9 +105,8 @@ def sortmore(*args, **kw):
         k = lambda x: (globalkey(*x),) + tuple(f(z) for (f, z) in zip(key, x))
     else:
         raise KeyError(
-            "kw arg 'key' should be None, callable, or a sequence of callables, not {}".format(
-                type(key)
-            )
+            "kw arg 'key' should be None, callable, or a sequence of callables, "
+            f"not {type(key)}"
         )
 
     res = sorted(zip(*args), key=k)

astropy/io/ascii/tests/test_c_reader.py

@@ -1689,7 +1689,9 @@ def test_newline_as_delimiter(delimiter, fast_reader):
         eol = "\r"
 
     inp0 = ["a  | b | c ", " 1 | '2' | 3.00000 "]
-    inp1 = "a {0:s} b {0:s}c{1:s} 1 {0:s}'2'{0:s} 3.0".format(delimiter, eol)
+    inp1 = (
+        f"a {delimiter:s} b {delimiter:s}c{eol:s} 1 {delimiter:s}'2'{delimiter:s} 3.0"
+    )
     inp2 = [f"a {delimiter} b{delimiter} c", f"1{delimiter} '2' {delimiter} 3.0"]
 
     t0 = ascii.read(inp0, delimiter="|", fast_reader=fast_reader)
@@ -1704,7 +1706,9 @@ def test_newline_as_delimiter(delimiter, fast_reader):
     assert_table_equal(t2, t0)
 
     inp0 = 'a {0:s} b {0:s} c{1:s} 1 {0:s}"2"{0:s} 3.0'.format("|", eol)
-    inp1 = 'a {0:s} b {0:s} c{1:s} 1 {0:s}"2"{0:s} 3.0'.format(delimiter, eol)
+    inp1 = (
+        f'a {delimiter:s} b {delimiter:s} c{eol:s} 1 {delimiter:s}"2"{delimiter:s} 3.0'
+    )
 
     t0 = ascii.read(inp0, delimiter="|", fast_reader=fast_reader)
     t1 = ascii.read(inp1, delimiter=delimiter, fast_reader=fast_reader)

astropy/io/ascii/ui.py

@@ -208,9 +208,8 @@ def _get_format_class(format, reader_writer_cls, label):
             reader_writer_cls = core.FORMAT_CLASSES[format]
         else:
             raise ValueError(
-                "ASCII format {!r} not in allowed list {}".format(
-                    format, sorted(core.FORMAT_CLASSES)
-                )
+                f"ASCII format {format!r} not in allowed list "
+                f"{sorted(core.FORMAT_CLASSES)}"
             )
     return reader_writer_cls
 
@@ -1015,8 +1014,10 @@ def write(
 
     if diff_format_with_names:
         warnings.warn(
-            "The key(s) {} specified in the formats argument do not match a column"
-            " name.".format(diff_format_with_names),
+            (
+                f"The key(s) {diff_format_with_names} specified in the formats "
+                "argument do not match a column name."
+            ),
             AstropyWarning,
         )
 

astropy/io/fits/card.py

@@ -129,8 +129,8 @@ class Card(_Verify):
     _rvkc_identifier = r"[a-zA-Z_]\w*"
     _rvkc_field = _rvkc_identifier + r"(\.\d+)?"
     _rvkc_field_specifier_s = rf"{_rvkc_field}(\.{_rvkc_field})*"
-    _rvkc_field_specifier_val = r"(?P<keyword>{}): +(?P<val>{})".format(
-        _rvkc_field_specifier_s, _numr_FSC
+    _rvkc_field_specifier_val = (
+        rf"(?P<keyword>{_rvkc_field_specifier_s}): +(?P<val>{_numr_FSC})"
     )
     _rvkc_keyword_val = rf"\'(?P<rawval>{_rvkc_field_specifier_val})\'"
     _rvkc_keyword_val_comm = rf" *{_rvkc_keyword_val} *(/ *(?P<comm>[ -~]*))?$"
@@ -141,9 +141,7 @@ class Card(_Verify):
     # string that is being used to index into a card list that contains
     # record value keyword cards (ex. 'DP1.AXIS.1')
     _rvkc_keyword_name_RE = re.compile(
-        r"(?P<keyword>{})\.(?P<field_specifier>{})$".format(
-            _rvkc_identifier, _rvkc_field_specifier_s
-        )
+        rf"(?P<keyword>{_rvkc_identifier})\.(?P<field_specifier>{_rvkc_field_specifier_s})$"
     )
 
     # regular expression to extract the field specifier and value and comment

astropy/io/fits/column.py

@@ -1092,9 +1092,9 @@ def _verify_keywords(
                     # is in the range allowed by the column's format
                     msg = (
                         "Column null option (TNULLn) is invalid for binary "
-                        "table columns of type {!r} (got {!r}).  The invalid "
-                        "value will be ignored for the purpose of formatting "
-                        "the data in this column.".format(format, null)
+                        f"table columns of type {format!r} (got {null!r}).  "
+                        "The invalid value will be ignored for the purpose of "
+                        "formatting the data in this column."
                     )
 
             if msg is None:
@@ -1203,12 +1203,10 @@ def _verify_keywords(
                     msg = None
                 elif reduce(operator.mul, dims_tuple) > format.repeat:
                     msg = (
-                        "The repeat count of the column format {!r} for column {!r} "
-                        "is fewer than the number of elements per the TDIM "
-                        "argument {!r}.  The invalid TDIMn value will be ignored "
-                        "for the purpose of formatting this column.".format(
-                            name, format, dim
-                        )
+                        f"The repeat count of the column format {name!r} for column "
+                        f"{format!r} is fewer than the number of elements per the TDIM "
+                        f"argument {dim!r}.  The invalid TDIMn value will be ignored "
+                        "for the purpose of formatting this column."
                     )
 
             if msg is None:
@@ -1221,8 +1219,8 @@ def _verify_keywords(
             if not isinstance(coord_type, str):
                 msg = (
                     "Coordinate/axis type option (TCTYPn) must be a string "
-                    "(got {!r}). The invalid keyword will be ignored for the "
-                    "purpose of formatting this column.".format(coord_type)
+                    f"(got {coord_type!r}). The invalid keyword will be ignored "
+                    "for the purpose of formatting this column."
                 )
             elif len(coord_type) > 8:
                 msg = (
@@ -1242,8 +1240,8 @@ def _verify_keywords(
             if not isinstance(coord_unit, str):
                 msg = (
                     "Coordinate/axis unit option (TCUNIn) must be a string "
-                    "(got {!r}). The invalid keyword will be ignored for the "
-                    "purpose of formatting this column.".format(coord_unit)
+                    f"(got {coord_unit!r}). The invalid keyword will be ignored "
+                    "for the purpose of formatting this column."
                 )
 
             if msg is None:
@@ -1260,11 +1258,9 @@ def _verify_keywords(
                 msg = None
                 if not isinstance(v, numbers.Real):
                     msg = (
-                        "Column {} option ({}n) must be a real floating type (got"
-                        " {!r}). The invalid value will be ignored for the purpose of"
-                        " formatting the data in this column.".format(
-                            k, ATTRIBUTE_TO_KEYWORD[k], v
-                        )
+                        f"Column {k} option ({ATTRIBUTE_TO_KEYWORD[k]}n) must be a "
+                        f"real floating type (got {v!r}). The invalid value will be "
+                        "ignored for the purpose of formatting the data in this column."
                     )
 
                 if msg is None:
@@ -1277,8 +1273,8 @@ def _verify_keywords(
             if not isinstance(time_ref_pos, str):
                 msg = (
                     "Time coordinate reference position option (TRPOSn) must be "
-                    "a string (got {!r}). The invalid keyword will be ignored for "
-                    "the purpose of formatting this column.".format(time_ref_pos)
+                    f"a string (got {time_ref_pos!r}). The invalid keyword will be "
+                    "ignored for the purpose of formatting this column."
                 )
 
             if msg is None:

astropy/io/fits/diff.py

@@ -1126,9 +1126,8 @@ def _report(self):
         if self.diff_total > self.numdiffs:
             self._writeln(" ...")
         self._writeln(
-            " {} different pixels found ({:.2%} different).".format(
-                self.diff_total, self.diff_ratio
-            )
+            f" {self.diff_total} different pixels found "
+            f"({self.diff_ratio:.2%} different)."
         )
 
 
@@ -1214,9 +1213,8 @@ def _report(self):
 
         self._writeln(" ...")
         self._writeln(
-            " {} different bytes found ({:.2%} different).".format(
-                self.diff_total, self.diff_ratio
-            )
+            f" {self.diff_total} different bytes found "
+            f"({self.diff_ratio:.2%} different)."
         )
 
 
@@ -1544,9 +1542,8 @@ def _report(self):
             self._writeln(" ...")
 
         self._writeln(
-            " {} different table data element(s) found ({:.2%} different).".format(
-                self.diff_total, self.diff_ratio
-            )
+            f" {self.diff_total} different table data element(s) found "
+            f"({self.diff_ratio:.2%} different)."
         )
 
 

astropy/io/fits/fitsrec.py

@@ -936,10 +936,9 @@ def _convert_other(self, column, field, recformat):
                     actual_nitems = field.shape[1]
                 if nitems > actual_nitems and not isinstance(recformat, _FormatP):
                     warnings.warn(
-                        "TDIM{} value {:d} does not fit with the size of "
-                        "the array items ({:d}).  TDIM{:d} will be ignored.".format(
-                            indx + 1, self._coldefs[indx].dims, actual_nitems, indx + 1
-                        )
+                        f"TDIM{indx + 1} value {self._coldefs[indx].dims:d} does not "
+                        f"fit with the size of the array items ({actual_nitems:d}).  "
+                        f"TDIM{indx + 1:d} will be ignored."
                     )
                     dim = None
 
@@ -1218,14 +1217,11 @@ def _scale_back_strings(self, col_idx, input_field, output_field):
                 _ascii_encode(input_field, out=output_field)
             except _UnicodeArrayEncodeError as exc:
                 raise ValueError(
-                    "Could not save column '{}': Contains characters that "
-                    "cannot be encoded as ASCII as required by FITS, starting "
-                    "at the index {!r} of the column, and the index {} of "
-                    "the string at that location.".format(
-                        self._coldefs[col_idx].name,
-                        exc.index[0] if len(exc.index) == 1 else exc.index,
-                        exc.start,
-                    )
+                    f"Could not save column '{self._coldefs[col_idx].name}': "
+                    "Contains characters that cannot be encoded as ASCII as required "
+                    "by FITS, starting at the index "
+                    f"{exc.index[0] if len(exc.index) == 1 else exc.index!r} of the "
+                    f"column, and the index {exc.start} of the string at that location."
                 )
         else:
             # Otherwise go ahead and do a direct copy into--if both are type
@@ -1293,9 +1289,8 @@ def _scale_back_ascii(self, col_idx, input_field, output_field):
             value = fmt.format(value)
             if len(value) > starts[col_idx + 1] - starts[col_idx]:
                 raise ValueError(
-                    "Value {!r} does not fit into the output's itemsize of {}.".format(
-                        value, spans[col_idx]
-                    )
+                    f"Value {value!r} does not fit into the output's itemsize of "
+                    f"{spans[col_idx]}."
                 )
 
             if trailing_decimal and value[0] == " ":