pyupgrade %-formatting

Author: Zac-HD

hypothesis-python/scripts/validate_branch_check.py

@@ -48,11 +48,11 @@
         print("The following were always True:")
         print()
         for c in always_true:
-            print("  * %s" % (c,))
+            print(f"  * {c}")
     if always_false:
         print("The following were always False:")
         print()
         for c in always_false:
-            print("  * %s" % (c,))
+            print(f"  * {c}")
     if failure:
         sys.exit(1)

hypothesis-python/src/hypothesis/_settings.py

@@ -73,7 +73,7 @@ def __set__(self, obj, value):
         obj.__dict__[self.name] = value
 
     def __delete__(self, obj):
-        raise AttributeError("Cannot delete attribute %s" % (self.name,))
+        raise AttributeError(f"Cannot delete attribute {self.name}")
 
     @property
     def __doc__(self):
@@ -83,7 +83,7 @@ def __doc__(self):
             if self.show_default
             else "(dynamically calculated)"
         )
-        return "%s\n\ndefault value: ``%s``" % (description, default)
+        return f"{description}\n\ndefault value: ``{default}``"
 
 
 default_variable = DynamicVariable(None)
@@ -139,7 +139,7 @@ def __getattr__(self, name):
         if name in all_settings:
             return all_settings[name].default
         else:
-            raise AttributeError("settings has no attribute %s" % (name,))
+            raise AttributeError(f"settings has no attribute {name}")
 
     def __init__(
         self,
@@ -279,15 +279,15 @@ def __setattr__(self, name, value):
         raise AttributeError("settings objects are immutable")
 
     def __repr__(self):
-        bits = ("%s=%r" % (name, getattr(self, name)) for name in all_settings)
+        bits = ("{}={!r}".format(name, getattr(self, name)) for name in all_settings)
         return "settings(%s)" % ", ".join(sorted(bits))
 
     def show_changed(self):
         bits = []
         for name, setting in all_settings.items():
             value = getattr(self, name)
             if value != setting.default:
-                bits.append("%s=%r" % (name, value))
+                bits.append(f"{name}={value!r}")
         return ", ".join(sorted(bits, key=len))
 
     @staticmethod
@@ -437,7 +437,7 @@ class Phase(IntEnum):
     shrink = 4
 
     def __repr__(self):
-        return "Phase.%s" % (self.name,)
+        return f"Phase.{self.name}"
 
 
 @unique
@@ -448,7 +448,7 @@ class HealthCheck(Enum):
     """
 
     def __repr__(self):
-        return "%s.%s" % (self.__class__.__name__, self.name)
+        return f"{self.__class__.__name__}.{self.name}"
 
     @classmethod
     def all(cls) -> List["HealthCheck"]:
@@ -505,7 +505,7 @@ class Verbosity(IntEnum):
     debug = 3
 
     def __repr__(self):
-        return "Verbosity.%s" % (self.name,)
+        return f"Verbosity.{self.name}"
 
 
 settings._define_setting(
@@ -520,7 +520,7 @@ def _validate_phases(phases):
     phases = tuple(phases)
     for a in phases:
         if not isinstance(a, Phase):
-            raise InvalidArgument("%r is not a valid phase" % (a,))
+            raise InvalidArgument(f"{a!r} is not a valid phase")
     return tuple(p for p in list(Phase) if p in phases)
 
 
@@ -538,7 +538,7 @@ def _validate_phases(phases):
 def _validate_stateful_step_count(x):
     check_type(int, x, name="stateful_step_count")
     if x < 1:
-        raise InvalidArgument("stateful_step_count=%r must be at least one." % (x,))
+        raise InvalidArgument(f"stateful_step_count={x!r} must be at least one.")
     return x
 
 
@@ -588,7 +588,7 @@ class duration(datetime.timedelta):
 
     def __repr__(self):
         ms = self.total_seconds() * 1000
-        return "timedelta(milliseconds=%r)" % (int(ms) if ms == int(ms) else ms,)
+        return "timedelta(milliseconds={!r})".format(int(ms) if ms == int(ms) else ms)
 
 
 def _validate_deadline(x):

hypothesis-python/src/hypothesis/control.py

@@ -183,7 +183,7 @@ def target(observation: Union[int, float], *, label: str = "") -> None:
     context = _current_build_context.value
     if context is None:
         raise InvalidArgument("Calling target() outside of a test is invalid.")
-    verbose_report("Saw target(observation=%r, label=%r)" % (observation, label))
+    verbose_report(f"Saw target(observation={observation!r}, label={label!r})")
 
     if label in context.data.target_observations:
         raise InvalidArgument(

hypothesis-python/src/hypothesis/core.py

@@ -192,18 +192,18 @@ def decode_failure(blob):
     try:
         buffer = base64.b64decode(blob)
     except Exception:
-        raise InvalidArgument("Invalid base64 encoded string: %r" % (blob,))
+        raise InvalidArgument(f"Invalid base64 encoded string: {blob!r}")
     prefix = buffer[:1]
     if prefix == b"\0":
         return buffer[1:]
     elif prefix == b"\1":
         try:
             return zlib.decompress(buffer[1:])
         except zlib.error:
-            raise InvalidArgument("Invalid zlib compression for blob %r" % (blob,))
+            raise InvalidArgument(f"Invalid zlib compression for blob {blob!r}")
     else:
         raise InvalidArgument(
-            "Could not decode blob %r: Invalid start byte %r" % (blob, prefix)
+            f"Could not decode blob {blob!r}: Invalid start byte {prefix!r}"
         )
 
 
@@ -218,7 +218,7 @@ def do_draw(self, data):
         return self.mapped_strategy.do_draw(data)
 
     def __repr__(self):
-        return "WithRunner(%r, runner=%r)" % (self.mapped_strategy, self.runner)
+        return f"WithRunner({self.mapped_strategy!r}, runner={self.runner!r})"
 
 
 def is_invalid_test(name, original_argspec, given_arguments, given_kwargs):

hypothesis-python/src/hypothesis/database.py

@@ -150,7 +150,7 @@ def __init__(self):
         self.data = {}
 
     def __repr__(self) -> str:
-        return "InMemoryExampleDatabase(%r)" % (self.data,)
+        return f"InMemoryExampleDatabase({self.data!r})"
 
     def fetch(self, key: bytes) -> Iterable[bytes]:
         yield from self.data.get(key, ())
@@ -190,7 +190,7 @@ def __init__(self, path: str) -> None:
         self.keypaths = {}  # type: dict
 
     def __repr__(self) -> str:
-        return "DirectoryBasedExampleDatabase(%r)" % (self.path,)
+        return f"DirectoryBasedExampleDatabase({self.path!r})"
 
     def _key_path(self, key):
         try:

hypothesis-python/src/hypothesis/errors.py

@@ -37,9 +37,7 @@ class NoSuchExample(HypothesisException):
     """
 
     def __init__(self, condition_string, extra=""):
-        super().__init__(
-            "No examples found of condition %s%s" % (condition_string, extra)
-        )
+        super().__init__(f"No examples found of condition {condition_string}{extra}")
 
 
 class Unsatisfiable(HypothesisException):

hypothesis-python/src/hypothesis/extra/django/_fields.py

@@ -262,9 +262,7 @@ def register_field_strategy(
     ``strategy`` must be a :class:`~hypothesis.strategies.SearchStrategy`.
     """
     if not issubclass(field_type, (dm.Field, df.Field)):
-        raise InvalidArgument(
-            "field_type=%r must be a subtype of Field" % (field_type,)
-        )
+        raise InvalidArgument(f"field_type={field_type!r} must be a subtype of Field")
     check_type(st.SearchStrategy, strategy, "strategy")
     if field_type in _global_field_lookup:
         raise InvalidArgument(

hypothesis-python/src/hypothesis/extra/django/_impl.py

@@ -90,7 +90,7 @@ def from_model(
         raise TypeError("Missing required positional argument `model`")
 
     if not issubclass(m_type, dm.Model):
-        raise InvalidArgument("model=%r must be a subtype of Model" % (model,))
+        raise InvalidArgument(f"model={model!r} must be a subtype of Model")
 
     fields_by_name = {f.name: f for f in m_type._meta.concrete_fields}
     for name, value in sorted(field_strategies.items()):
@@ -172,7 +172,7 @@ def from_form(
     # ImageField
     form_kwargs = form_kwargs or {}
     if not issubclass(form, df.BaseForm):
-        raise InvalidArgument("form=%r must be a subtype of Form" % (form,))
+        raise InvalidArgument(f"form={form!r} must be a subtype of Form")
 
     # Forms are a little bit different from models. Model classes have
     # all their fields defined, whereas forms may have different fields

hypothesis-python/src/hypothesis/extra/lark.py

@@ -157,7 +157,7 @@ def rule_label(self, name):
             return self.__rule_labels[name]
         except KeyError:
             return self.__rule_labels.setdefault(
-                name, calc_label_from_name("LARK:%s" % (name,))
+                name, calc_label_from_name(f"LARK:{name}")
             )
 
     def draw_symbol(self, data, symbol, draw_state):
@@ -235,7 +235,7 @@ def from_lark(
     else:
         check_type(dict, explicit, "explicit")
         explicit = {
-            k: v.map(check_explicit("explicit[%r]=%r" % (k, v)))
+            k: v.map(check_explicit(f"explicit[{k!r}]={v!r}"))
             for k, v in explicit.items()
         }
     return LarkStrategy(grammar, start, explicit)

hypothesis-python/src/hypothesis/extra/numpy.py

@@ -341,7 +341,7 @@ def fill_for(elements, unique, fill, name=""):
         else:
             fill = elements
     else:
-        st.check_strategy(fill, "%s.fill" % (name,) if name else "fill")
+        st.check_strategy(fill, f"{name}.fill" if name else "fill")
     return fill
 
 
@@ -1098,7 +1098,7 @@ def _hypothesis_parse_gufunc_signature(signature, all_checks=True):
                 "contains shapes with more than 32 dimensions and is thus invalid."
                 % (signature,)
             )
-        raise InvalidArgument("%r is not a valid gufunc signature" % (signature,))
+        raise InvalidArgument(f"{signature!r} is not a valid gufunc signature")
     input_shapes, output_shapes = (
         tuple(tuple(re.findall(_DIMENSION, a)) for a in re.findall(_SHAPE, arg_list))
         for arg_list in signature.split("->")
@@ -1412,11 +1412,11 @@ def basic_indices(
     order_check("dims", 0, min_dims, max_dims)
     check_argument(
         max_dims <= 32,
-        "max_dims=%r, but numpy arrays have at most 32 dimensions" % (max_dims,),
+        f"max_dims={max_dims!r}, but numpy arrays have at most 32 dimensions",
     )
     check_argument(
         all(isinstance(x, int) and x >= 0 for x in shape),
-        "shape=%r, but all dimensions must be of integer size >= 0" % (shape,),
+        f"shape={shape!r}, but all dimensions must be of integer size >= 0",
     )
     return BasicIndexStrategy(
         shape,
@@ -1476,11 +1476,11 @@ def integer_array_indices(
     check_type(tuple, shape, "shape")
     check_argument(
         shape and all(isinstance(x, int) and x > 0 for x in shape),
-        "shape=%r must be a non-empty tuple of integers > 0" % (shape,),
+        f"shape={shape!r} must be a non-empty tuple of integers > 0",
     )
     check_strategy(result_shape, "result_shape")
     check_argument(
-        np.issubdtype(dtype, np.integer), "dtype=%r must be an integer dtype" % (dtype,)
+        np.issubdtype(dtype, np.integer), f"dtype={dtype!r} must be an integer dtype"
     )
     signed = np.issubdtype(dtype, np.signedinteger)
 

hypothesis-python/src/hypothesis/extra/pandas/impl.py

@@ -64,10 +64,10 @@ def elements_and_dtype(elements, dtype, source=None):
     if source is None:
         prefix = ""
     else:
-        prefix = "%s." % (source,)
+        prefix = f"{source}."
 
     if elements is not None:
-        st.check_strategy(elements, "%selements" % (prefix,))
+        st.check_strategy(elements, f"{prefix}elements")
     else:
         with check("dtype is not None"):
             if dtype is None:
@@ -82,7 +82,7 @@ def elements_and_dtype(elements, dtype, source=None):
     with check("is_categorical_dtype"):
         if is_categorical_dtype(dtype):
             raise InvalidArgument(
-                "%sdtype is categorical, which is currently unsupported" % (prefix,)
+                f"{prefix}dtype is categorical, which is currently unsupported"
             )
 
     dtype = try_convert(np.dtype, dtype, "dtype")
@@ -92,7 +92,7 @@ def elements_and_dtype(elements, dtype, source=None):
     elif dtype is not None:
 
         def convert_element(value):
-            name = "draw(%selements)" % (prefix,)
+            name = f"draw({prefix}elements)"
             try:
                 return np.array([value], dtype=dtype)[0]
             except TypeError:
@@ -102,7 +102,7 @@ def convert_element(value):
                 )
             except ValueError:
                 raise InvalidArgument(
-                    "Cannot convert %s=%r to type %s" % (name, value, dtype.str)
+                    f"Cannot convert {name}={value!r} to type {dtype.str}"
                 )
 
         elements = elements.map(convert_element)
@@ -524,7 +524,7 @@ def row():
                 )
 
         if c.name in column_names:
-            raise InvalidArgument("duplicate definition of column name %r" % (c.name,))
+            raise InvalidArgument(f"duplicate definition of column name {c.name!r}")
 
         column_names.add(c.name)
 

hypothesis-python/src/hypothesis/extra/pytestplugin.py

@@ -95,7 +95,7 @@ def pytest_report_header(config):
         settings_str = settings.get_profile(profile).show_changed()
         if settings_str != "":
             settings_str = " -> %s" % (settings_str)
-        return "hypothesis profile %r%s" % (profile, settings_str)
+        return f"hypothesis profile {profile!r}{settings_str}"
 
     def pytest_configure(config):
         core.running_under_pytest = True
@@ -105,7 +105,7 @@ def pytest_configure(config):
         verbosity_name = config.getoption(VERBOSITY_OPTION)
         if verbosity_name:
             verbosity_value = Verbosity[verbosity_name]
-            profile_name = "%s-with-%s-verbosity" % (
+            profile_name = "{}-with-{}-verbosity".format(
                 settings._current_profile,
                 verbosity_name,
             )

hypothesis-python/src/hypothesis/internal/cache.py

@@ -141,7 +141,7 @@ def unpin(self, key):
         i = self.keys_to_indices[key]
         entry = self.data[i]
         if entry.pins == 0:
-            raise ValueError("Key %r has not been pinned" % (key,))
+            raise ValueError(f"Key {key!r} has not been pinned")
         entry.pins -= 1
         if entry.pins == 0:
             self.__pinned_entry_count -= 1
@@ -159,7 +159,7 @@ def clear(self):
         self.__pinned_entry_count = 0
 
     def __repr__(self):
-        return "{%s}" % (", ".join("%r: %r" % (e.key, e.value) for e in self.data),)
+        return "{{{}}}".format(", ".join(f"{e.key!r}: {e.value!r}" for e in self.data))
 
     def new_entry(self, key, value):
         """Called when a key is written that does not currently appear in the

hypothesis-python/src/hypothesis/internal/charmap.py

@@ -146,7 +146,7 @@ def as_general_categories(cats, name="cats"):
             out.update(x for x in cs if x.startswith(c))
         elif c not in cs:
             raise InvalidArgument(
-                "In %s=%r, %r is not a valid Unicode category." % (name, cats, c)
+                f"In {name}={cats!r}, {c!r} is not a valid Unicode category."
             )
     return tuple(c for c in cs if c in out)