-

cool-RR · cool-RR · commit ccf7c1945128 · 2019-07-19T18:15:41.000+03:00
diff --git a/python_toolbox/address_tools/object_to_string.py b/python_toolbox/address_tools/object_to_string.py
@@ -140,9 +140,9 @@ def get_address(obj, shorten=False, root=None, namespace={}):
     # We'll probably have to do some kind of search.
 
     if not (isinstance(obj, types.ModuleType) or hasattr(obj, '__module__')):
-        raise TypeError("`%s` is not a module, nor does it have a "
-                        "`.__module__` attribute, therefore we can't get its "
-                        "address." % (obj,))
+        raise TypeError(f"`{obj}` is not a module, nor does it have a "
+                        f"`.__module__` attribute, therefore we can't get its "
+                        f"address.")
 
     if isinstance(obj, types.ModuleType):
         address = obj.__name__
diff --git a/python_toolbox/caching/cached_property.py b/python_toolbox/caching/cached_property.py
@@ -77,4 +77,4 @@ def inner(same_method_function, self_obj, *args, **kwargs):
 
 
     def __repr__(self):
-        return '<%s: %s>' % (type(self).__name__, self.our_name or self.getter)
+        return f'<{type(self).__name__}: {self.our_name or self.getter}>'
diff --git a/python_toolbox/combi/perming/comb_space.py b/python_toolbox/combi/perming/comb_space.py
@@ -49,9 +49,8 @@ def __repr__(self):
         return '<%s: %s%s>%s' % (
             type(self).__name__,
             sequence_repr,
-            (', n_elements=%s' % (self.n_elements,)) if self.is_partial
-                                                                       else '',
-            ('[%s:%s]' % (self.slice_.start, self.slice_.stop)) if
+            (f', n_elements={self.n_elements}') if self.is_partial else '',
+            f'[{self.slice_.start}:{self.slice_.stop}]' if
                                                          self.is_sliced else ''
         )
 
diff --git a/python_toolbox/combi/perming/perm_space.py b/python_toolbox/combi/perming/perm_space.py
@@ -521,12 +521,11 @@ def __repr__(self):
             type(self).__name__,
             domain_snippet,
             sequence_repr,
-            (', n_elements=%s' % (self.n_elements,)) if self.is_partial
-                                                                       else '',
+            (f', n_elements={self.n_elements}') if self.is_partial else '',
             ', is_combination=True' if self.is_combination else '',
-            (', fixed_map=%s' % (fixed_map_repr,)) if self.is_fixed else '',
-            (', degrees=%s' % (self.degrees,)) if self.is_degreed else '',
-            (', perm_type=%s' % (self.perm_type.__name__,)) if self.is_typed
+            (f', fixed_map={fixed_map_repr}' if self.is_fixed else '',
+            (f', degrees={self.degrees}') if self.is_degreed else '',
+            (f', perm_type={self.perm_type.__name__}') if self.is_typed
                                                                        else '',
             ('[%s:%s]' % (self.slice_.start, self.slice_.stop)) if
                                                          self.is_sliced else ''
diff --git a/python_toolbox/context_management/context_manager_type.py b/python_toolbox/context_management/context_manager_type.py
@@ -96,25 +96,25 @@ def __new__(mcls, name, bases, namespace):
 
                 assert '__enter__' in namespace
 
-                raise Exception("The %s class defines an `__enter__` method, "
-                                "but not an `__exit__` method; we cannot use "
-                                "the `__exit__` method of its base context "
-                                "manager class because it uses the "
-                                "`manage_context` generator function." %
-                                result_class)
+                raise Exception(
+                    f"The {result_class} class defines an `__enter__` method, "
+                    f"but not an `__exit__` method; we cannot use the "
+                    f"`__exit__` method of its base context manager class "
+                    f"because it uses the `manage_context` generator function."
+                )
 
 
             if our_enter_uses_manage_context and not \
                our_exit_uses_manage_context:
 
                 assert '__exit__' in namespace
 
-                raise Exception("The %s class defines an `__exit__` method, "
-                                "but not an `__enter__` method; we cannot use "
-                                "the `__enter__` method of its base context "
-                                "manager class because it uses the "
-                                "`manage_context` generator function." %
-                                result_class)
+                raise Exception(
+                    f"The {result_class} class defines an `__exit__` method, "
+                    f"but not an `__enter__` method; we cannot use the "
+                    f"`__enter__` method of its base context manager class "
+                    f"because it uses the `manage_context` generator function."
+                )
 
         return result_class
 
diff --git a/python_toolbox/cute_profile/profile_handling.py b/python_toolbox/cute_profile/profile_handling.py
@@ -29,8 +29,8 @@ def __call__(self, profile):
     def handle(self):
         pass
 
-    make_file_name = lambda self: ('%s.profile' %
-                              datetime_module.datetime.now()).replace(':', '.')
+    make_file_name = lambda self: (
+                 f'{datetime_module.datetime.now()}.profile').replace(':', '.')
 
 
 
diff --git a/python_toolbox/cute_testing.py b/python_toolbox/cute_testing.py
@@ -73,10 +73,10 @@ def manage_context(self):
                 if self.exception_type is not type(exception):
                     assert issubclass(type(exception), self.exception_type)
                     raise Failure(
-                        "The exception `%s` was raised, and it *is* an "
-                        "instance of the `%s` we were expecting; but its type "
-                        "is not `%s`, it's `%s`, which is a subclass of `%s`, "
-                        "but you specified `assert_exact_type=True`, so "
+                        "The exception %s was raised, and it *is* an "
+                        "instance of the %s we were expecting; but its type "
+                        "is not %s, it's %s, which is a subclass of %s, "
+                        "and you specified `assert_exact_type=True`, so "
                         "subclasses aren't acceptable." % (repr(exception),
                         self.exception_type.__name__,
                         self.exception_type.__name__, type(exception).__name__,
@@ -87,24 +87,24 @@ def manage_context(self):
                 if isinstance(self.text, str):
                     if self.text not in message:
                         raise Failure(
-                            "A `%s` was raised but %s wasn't in its message." %
-                            (self.exception_type.__name__, repr(self.text))
+                            f"A {self.exception_type.__name__} was raised "
+                            f"but {repr(self.text)} wasn't in its message."
                         )
                 else:
                     # It's a regex pattern
                     if not self.text.match(message):
                         raise Failure(
-                            "A `%s` was raised but it didn't match the given "
-                            "regex." % self.exception_type.__name__
+                            f"A {self.exception_type.__name__} was raised "
+                            f"but it didn't match the given regex."
                         )
         except BaseException as different_exception:
             raise Failure(
-                "%s was excpected, but a different exception %s was raised "
-                "instead." % (self.exception_type.__name__,
-                              type(different_exception).__name__)
+                f"{self.exception_type.__name__} was excpected, but a "
+                f"different exception {type(different_exception).__name__} "
+                f"was raised instead."
             )
         else:
-            raise Failure("%s wasn't raised." % self.exception_type.__name__)
+            raise Failure(f"{self.exception_type.__name__} wasn't raised.")
 
 
 def assert_same_signature(*callables):
diff --git a/python_toolbox/decorator_tools.py b/python_toolbox/decorator_tools.py
@@ -52,10 +52,11 @@ def inner(*args, **kwargs):
             function = args[0]
             function_name = function.__name__
             decorator_builder_name = decorator_builder.__name__
-            raise TypeError('It seems that you forgot to add parentheses '
-                            'after `@%s` when decorating the `%s` '
-                            'function.' % (decorator_builder_name,
-                            function_name))
+            raise TypeError(
+                f'It seems that you forgot to add parentheses after '
+                f'@{decorator_builder_name} when decorating the
+                f'{function_name} function.'
+            )
         else:
             return decorator_builder(*args, **kwargs)
 
diff --git a/python_toolbox/dict_tools.py b/python_toolbox/dict_tools.py
@@ -164,9 +164,9 @@ def reverse(d):
     for key, value in d.items():
         if value in new_d:
             raise Exception(
-                "Value %s appeared twice! Once with a key of %s and then "
-                "again with a key of %s. This function is intended only for "
-                "dicts with distinct values." % (value, key, new_d[value])
+                f"Value {value} appeared twice! Once with a key of {key} and "
+                f"then again with a key of {new_d[value]}. This function is "
+                f"intended only for dicts with distinct values."
             )
         new_d[value] = key
     return new_d
diff --git a/python_toolbox/file_tools.py b/python_toolbox/file_tools.py
@@ -163,8 +163,8 @@ def atomic_create(path, binary=False):
     '''
     path = pathlib.Path(path)
     if path.exists():
-        raise Exception("There's already a file called %s" % path)
-    desired_temp_file_path = path.parent / ('._%s.tmp' % path.stem)
+        raise FileExistsError(f"There's already a file called {path}")
+    desired_temp_file_path = path.parent / f'._{path.stem}.tmp'
     try:
         with create_file_renaming_if_taken(desired_temp_file_path,
                                          'xb' if binary else 'x') as temp_file:
@@ -174,7 +174,7 @@ def atomic_create(path, binary=False):
         # This part runs only if there was no exception when writing to the
         # file:
         if path.exists():
-            raise Exception("There's already a file called %s" % path)
+            raise FileExistsError(f"There's already a file called {path}")
         actual_temp_file_path.rename(path)
         assert path.exists()
 
diff --git a/python_toolbox/function_anchoring_type.py b/python_toolbox/function_anchoring_type.py
@@ -59,8 +59,9 @@ def __new__(mcls, name, bases, namespace_dict):
                 # Something already exists at the anchor address; let's be
                 # careful.
                 if already_defined_object is not function:
-                    raise Exception("An object `%s.%s` already exists! Can't "
-                                    "anchor function." % \
-                                    (module_name, function_name))
+                    raise Exception(
+                        f"An object `{module_name}.{function_name}` already "
+                        f"exists! Can't anchor function."
+                    )
         return my_type
 
diff --git a/python_toolbox/misc_tools/misc_tools.py b/python_toolbox/misc_tools/misc_tools.py
@@ -185,8 +185,8 @@ def find_clear_place_on_circle(circle_points, circle_size=1):
     sorted_circle_points = sorted(circle_points)
     last_point = sorted_circle_points[-1]
     if last_point >= circle_size:
-        raise Exception("One of the points (%s) is bigger than the circle "
-                        "size %s." % (last_point, circle_size))
+        raise Exception(f"One of the points ({last_point}) is bigger than the "
+                        f"circle size {circle_size}.")
     clear_space = {}
 
     for first_point, second_point in \
@@ -318,9 +318,9 @@ def decimal_number_from_string(string):
     if isinstance(string, bytes):
         string = string.decode()
     if not isinstance(string, str):
-        raise Exception("%s isn't a decimal number." % string)
+        raise Exception(f"{string} isn't a decimal number.")
     if not _decimal_number_pattern.match(string):
-        raise Exception("%s isn't a decimal number." % string)
+        raise Exception(f"{string} isn't a decimal number.")
     return float(string) if '.' in string else int(string)
 
 
diff --git a/python_toolbox/misc_tools/name_mangling.py b/python_toolbox/misc_tools/name_mangling.py
@@ -25,7 +25,7 @@ def mangle_attribute_name_if_needed(attribute_name, class_name):
     if total_length > MANGLE_LEN:
         cleaned_class_name = cleaned_class_name[:(MANGLE_LEN - total_length)]
 
-    return '_%s%s' % (cleaned_class_name, attribute_name)
+    return f'_{cleaned_class_name}{attribute_name}'
 
 
 def will_attribute_name_be_mangled(attribute_name, class_name):
diff --git a/python_toolbox/misc_tools/proxy_property.py b/python_toolbox/misc_tools/proxy_property.py
@@ -49,12 +49,14 @@ def __init__(self, attribute_name, doc=None):
         You may specify a docstring as `doc`.
         '''
         if not attribute_name.startswith('.'):
-            raise Exception("The `attribute_name` must start with a dot to "
-                            "make it clear it's an attribute. %s does not "
-                            "start with a dot." % repr(attribute_name))
+            raise Exception(
+                f"The `attribute_name` must start with a dot to make it clear "
+                f"it's an attribute. {repr(attribute_name)} does not start "
+                f"with a dot."
+            )
         self.getter = self.setter = None
-        exec('def getter(thing): return thing%s' % attribute_name)
-        exec('def setter(thing, value): thing%s = value' % attribute_name)
+        exec(f'def getter(thing): return thing{attribute_name}')
+        exec(f'def setter(thing, value): thing{attribute_name} = value')
         exec('self.getter, self.setter = getter, setter')
         self.attribute_name = attribute_name[1:]
         self.__doc__ = doc
@@ -76,6 +78,6 @@ def __set__(self, thing, value):
     def __repr__(self):
         return '<%s: %s%s>' % (
             type(self).__name__,
-            repr('.%s' % self.attribute_name),
-            ', doc=%s' % repr(self.__doc__) if self.__doc__ else ''
+            repr(f'.{self.attribute_name}'),
+            f', doc={repr(self.__doc__) if self.__doc__ else ""}'
         )
diff --git a/python_toolbox/monkeypatch_envelopes.py b/python_toolbox/monkeypatch_envelopes.py
@@ -20,8 +20,8 @@ def add_attachment_from_string(self, file_data, file_name,
     part.set_payload(file_data)
     email_encoders.encode_base64(part)
 
-    part.add_header('Content-Disposition', 'attachment; filename="%s"'
-                    % file_name)
+    part.add_header('Content-Disposition',
+                    f'attachment; filename="{file_name}"')
 
     self._parts.append((mimetype, part))
 
diff --git a/python_toolbox/nifty_collections/bagging.py b/python_toolbox/nifty_collections/bagging.py
@@ -47,13 +47,13 @@ def _process_count(count):
     '''Process a count of an item to ensure it's a positive `int`.'''
     if not math_tools.is_integer(count):
         raise TypeError(
-            'You passed %s as a count, while a `Bag` can only handle integer '
-            'counts.' % repr(count)
+            f'You passed {repr(count)} as a count, while a `Bag` can only '
+            f'handle integer counts.'
         )
     if count < 0:
         raise TypeError(
-            "You passed %s as a count, while `Bag` doesn't support negative "
-            "amounts." % repr(count)
+            f"You passed {repr(count)} as a count, while `Bag` doesn't support"
+            f"negative amounts."
         )
 
     if count == 0:
@@ -132,7 +132,7 @@ def inner(same_method_function, self_obj, *args, **kwargs):
 
 
     def __repr__(self):
-        return '<%s: %s>' % (type(self).__name__, self.our_name or self.getter)
+        return f'<{type(self).__name__}: {self.our_name or self.getter}>'
 
 
 class _BaseBagMixin:
@@ -505,11 +505,8 @@ def __ge__(self, other):
 
     def __repr__(self):
         if not self:
-            return '%s()' % type(self).__name__
-        return '%s(%s)' % (
-            type(self).__name__,
-            self._dict if self._dict else ''
-        )
+            return f'{type(self).__name__}()'
+        return f'{type(self).__name__}({self._dict if self._dict else ""})'
 
     __deepcopy__ = lambda self, memo: type(self)(
                                                copy.deepcopy(self._dict, memo))
diff --git a/python_toolbox/nifty_collections/weak_key_identity_dict.py b/python_toolbox/nifty_collections/weak_key_identity_dict.py
@@ -62,7 +62,7 @@ def __getitem__(self, key):
 
 
     def __repr__(self):
-        return "<WeakKeyIdentityDict at %s>" % id(self)
+        return f"<WeakKeyIdentityDict at {id(self)}>"
 
 
     def __setitem__(self, key, value):
diff --git a/python_toolbox/os_tools.py b/python_toolbox/os_tools.py
@@ -24,6 +24,6 @@ def start_file(path):
 
     else:
         raise NotImplementedError(
-            "Your operating system `%s` isn't supported by "
-            "`start_file`." % sys.platform)
+            f"Your operating system {sys.platform} isn't supported by "
+            f"`start_file`.")
 
diff --git a/python_toolbox/reasoned_bool.py b/python_toolbox/reasoned_bool.py
@@ -25,9 +25,9 @@ def __init__(self, value, reason=None):
 
     def __repr__(self):
         if self.reason is not None:
-            return '<%s because %s>' % (self.value, repr(self.reason))
+            return f'<{self.value} because {repr(self.reason)}>'
         else: # self.reason is None
-            return '<%s with no reason>' % self.value
+            return f'<{self.value} with no reason>'
 
 
     def __eq__(self, other):
diff --git a/python_toolbox/segment_tools.py b/python_toolbox/segment_tools.py
@@ -25,7 +25,7 @@ def crop_segment(segment, base_segment):
     if not (base_start <= start <= base_end or \
             base_start <= end <= base_end or \
             start <= base_start <= base_end <= end):
-        raise Exception('%s is not touching %s' % (segment, base_segment))
+        raise Exception(f'{segment} is not touching {base_segment}')
 
     new_start = max((start, base_start))
     new_end = min((end, base_end))
diff --git a/python_toolbox/sequence_tools/canonical_slice.py b/python_toolbox/sequence_tools/canonical_slice.py
@@ -133,7 +133,7 @@ def __init__(self, slice_, iterable_or_length=None, offset=0):
         ### Finished doing sanity checks. #####################################
 
     __iter__ = lambda self: iter((self.start, self.stop, self.step))
-    __repr__ = lambda self: '%s%s' % (type(self).__name__, tuple(self))
+    __repr__ = lambda self: f'{type(self).__name__}{tuple(self)}'
     _reduced = property(lambda self: (type(self), tuple(self)))
     __hash__ = lambda self: hash(self._reduced)
     __eq__ = lambda self, other: (isinstance(other, CanonicalSlice) and
diff --git a/python_toolbox/sequence_tools/cute_range.py b/python_toolbox/sequence_tools/cute_range.py
diff --git a/python_toolbox/sequence_tools/misc.py b/python_toolbox/sequence_tools/misc.py
diff --git a/python_toolbox/sleek_reffing/cute_sleek_value_dict.py b/python_toolbox/sleek_reffing/cute_sleek_value_dict.py
diff --git a/python_toolbox/sleek_reffing/sleek_ref.py b/python_toolbox/sleek_reffing/sleek_ref.py
diff --git a/python_toolbox/wx_tools/widgets/cute_window/bind_savvy_evt_handler/bind_savvy_evt_handler.py b/python_toolbox/wx_tools/widgets/cute_window/bind_savvy_evt_handler/bind_savvy_evt_handler.py
diff --git a/python_toolbox/wx_tools/widgets/cute_window/bind_savvy_evt_handler/event_codes.py b/python_toolbox/wx_tools/widgets/cute_window/bind_savvy_evt_handler/event_codes.py
diff --git a/python_toolbox/wx_tools/widgets/hue_selection_dialog/textual.py b/python_toolbox/wx_tools/widgets/hue_selection_dialog/textual.py
diff --git a/test_python_toolbox/test_combi/test_extensive.py b/test_python_toolbox/test_combi/test_extensive.py
diff --git a/test_python_toolbox/test_combi/test_perm_space.py b/test_python_toolbox/test_combi/test_perm_space.py
diff --git a/test_python_toolbox/test_nifty_collections/test_bagging.py b/test_python_toolbox/test_nifty_collections/test_bagging.py

Original file line number	Diff line number	Diff line change
`@@ -77,4 +77,4 @@ def inner(same_method_function, self_obj, args, *kwargs):`
`77`	`77`
`78`	`78`
`79`	`79`	`def __repr__(self):`
`80`		`- return '<%s: %s>' % (type(self).__name__, self.our_name or self.getter)`
	`80`	`+ return f'<{type(self).__name__}: {self.our_name or self.getter}>'`