Replace remaining % and .format with f-strings (by hand)

Author: akx

benchmarks/basic_operations.py

@@ -62,10 +62,9 @@ def set_str(conn, num, pipeline_size, data_size):
     if pipeline_size > 1:
         conn = conn.pipeline()
 
-    format_str = '{:0<%d}' % data_size
-    set_data = format_str.format('a')
+    set_data = 'a'.ljust(data_size, '0')
     for i in range(num):
-        conn.set('set_str:%d' % i, set_data)
+        conn.set(f'set_str:{i}', set_data)
         if pipeline_size > 1 and i % pipeline_size == 0:
             conn.execute()
 
@@ -78,10 +77,9 @@ def set_int(conn, num, pipeline_size, data_size):
     if pipeline_size > 1:
         conn = conn.pipeline()
 
-    format_str = '{:0<%d}' % data_size
-    set_data = int(format_str.format('1'))
+    set_data = 10 ** (data_size - 1)
     for i in range(num):
-        conn.set('set_int:%d' % i, set_data)
+        conn.set(f'set_int:{i}', set_data)
         if pipeline_size > 1 and i % pipeline_size == 0:
             conn.execute()
 
@@ -95,7 +93,7 @@ def get_str(conn, num, pipeline_size, data_size):
         conn = conn.pipeline()
 
     for i in range(num):
-        conn.get('set_str:%d' % i)
+        conn.get(f'set_str:{i}')
         if pipeline_size > 1 and i % pipeline_size == 0:
             conn.execute()
 
@@ -109,7 +107,7 @@ def get_int(conn, num, pipeline_size, data_size):
         conn = conn.pipeline()
 
     for i in range(num):
-        conn.get('set_int:%d' % i)
+        conn.get(f'set_int:{i}')
         if pipeline_size > 1 and i % pipeline_size == 0:
             conn.execute()
 
@@ -136,8 +134,7 @@ def lpush(conn, num, pipeline_size, data_size):
     if pipeline_size > 1:
         conn = conn.pipeline()
 
-    format_str = '{:0<%d}' % data_size
-    set_data = int(format_str.format('1'))
+    set_data = 10 ** (data_size - 1)
     for i in range(num):
         conn.lpush('lpush_key', set_data)
         if pipeline_size > 1 and i % pipeline_size == 0:

redis/client.py

@@ -1805,8 +1805,10 @@ def raise_first_error(self, commands, response):
 
     def annotate_exception(self, exception, number, command):
         cmd = ' '.join(map(safe_str, command))
-        msg = 'Command # %d (%s) of pipeline caused error: %s' % (
-            number, cmd, exception.args[0])
+        msg = (
+            f'Command # {number} ({cmd}) of pipeline '
+            f'caused error: {exception.args[0]}'
+        )
         exception.args = (msg,) + exception.args[1:]
 
     def parse_response(self, connection, command_name, **options):

redis/cluster.py

@@ -740,16 +740,17 @@ def determine_slot(self, *args):
             raise RedisClusterException(
                 "No way to dispatch this command to Redis Cluster. "
                 "Missing key.\nYou can execute the command by specifying "
-                "target nodes.\nCommand: {}".format(args)
+                f"target nodes.\nCommand: {args}"
             )
 
         if len(keys) > 1:
             # multi-key command, we need to make sure all keys are mapped to
             # the same slot
             slots = {self.keyslot(key) for key in keys}
             if len(slots) != 1:
-                raise RedisClusterException("{} - all keys must map to the "
-                                            "same key slot".format(args[0]))
+                raise RedisClusterException(
+                    f"{args[0]} - all keys must map to the same key slot"
+                )
             return slots.pop()
         else:
             # single key command
@@ -774,12 +775,12 @@ def _parse_target_nodes(self, target_nodes):
             # rc.cluster_save_config(rc.get_primaries())
             nodes = target_nodes.values()
         else:
-            raise TypeError("target_nodes type can be one of the "
-                            "followings: node_flag (PRIMARIES, "
-                            "REPLICAS, RANDOM, ALL_NODES),"
-                            "ClusterNode, list<ClusterNode>, or "
-                            "dict<any, ClusterNode>. The passed type is {0}".
-                            format(type(target_nodes)))
+            raise TypeError(
+                "target_nodes type can be one of the following: "
+                "node_flag (PRIMARIES, REPLICAS, RANDOM, ALL_NODES),"
+                "ClusterNode, list<ClusterNode>, or dict<any, ClusterNode>. "
+                f"The passed type is {type(target_nodes)}"
+            )
         return nodes
 
     def execute_command(self, *args, **kwargs):
@@ -866,9 +867,10 @@ def _execute_command(self, target_node, *args, **kwargs):
                                            command in READ_COMMANDS)
                     moved = False
 
-                log.debug("Executing command {0} on target node: {1} {2}".
-                          format(command, target_node.server_type,
-                                 target_node.name))
+                log.debug(
+                    f"Executing command {command} on target node: "
+                    f"{target_node.server_type} {target_node.name}"
+                )
                 redis_node = self.get_redis_connection(target_node)
                 connection = get_connection(redis_node, *args, **kwargs)
                 if asking:
@@ -1005,13 +1007,13 @@ def __init__(self, host, port, server_type=None, redis_connection=None):
         self.redis_connection = redis_connection
 
     def __repr__(self):
-        return '[host={},port={},' \
-               'name={},server_type={},redis_connection={}]' \
-            .format(self.host,
-                    self.port,
-                    self.name,
-                    self.server_type,
-                    self.redis_connection)
+        return (
+            f'[host={self.host},'
+            f'port={self.port},'
+            f'name={self.name},'
+            f'server_type={self.server_type},'
+            f'redis_connection={self.redis_connection}]'
+        )
 
     def __eq__(self, obj):
         return isinstance(obj, ClusterNode) and obj.name == self.name
@@ -1133,9 +1135,8 @@ def get_node_from_slot(self, slot, read_from_replicas=False,
         if self.slots_cache.get(slot) is None or \
                 len(self.slots_cache[slot]) == 0:
             raise SlotNotCoveredError(
-                'Slot "{}" not covered by the cluster. '
-                '"require_full_coverage={}"'.format(
-                    slot, self._require_full_coverage)
+                f'Slot "{slot}" not covered by the cluster. '
+                f'"require_full_coverage={self._require_full_coverage}"'
             )
 
         if read_from_replicas is True:
@@ -1194,7 +1195,7 @@ def node_require_full_coverage(node):
             except Exception as e:
                 raise RedisClusterException(
                     'ERROR sending "config get cluster-require-full-coverage"'
-                    ' command to redis server: {}, {}'.format(node.name, e)
+                    f' command to redis server: {node.name}, {e}'
                 )
 
         # at least one node should have cluster-require-full-coverage yes
@@ -1267,7 +1268,7 @@ def initialize(self):
                 msg = e.__str__
                 log.exception('An exception occurred while trying to'
                               ' initialize the cluster using the seed node'
-                              ' {}:\n{}'.format(startup_node.name, msg))
+                              f' {startup_node.name}:\n{msg}')
                 continue
             except ResponseError as e:
                 log.exception(
@@ -1281,15 +1282,13 @@ def initialize(self):
                 else:
                     raise RedisClusterException(
                         'ERROR sending "cluster slots" command to redis '
-                        'server: {}. error: {}'.format(
-                            startup_node, message)
+                        f'server: {startup_node}. error: {message}'
                     )
             except Exception as e:
                 message = e.__str__()
                 raise RedisClusterException(
                     'ERROR sending "cluster slots" command to redis '
-                    'server: {}. error: {}'.format(
-                        startup_node, message)
+                    f'server: {startup_node}. error: {message}'
                 )
 
             # CLUSTER SLOTS command results in the following output:
@@ -1340,17 +1339,16 @@ def initialize(self):
                     else:
                         # Validate that 2 nodes want to use the same slot cache
                         # setup
-                        if tmp_slots[i][0].name != target_node.name:
+                        tmp_slot = tmp_slots[i][0]
+                        if tmp_slot.name != target_node.name:
                             disagreements.append(
-                                '{} vs {} on slot: {}'.format(
-                                    tmp_slots[i][0].name, target_node.name, i)
+                                f'{tmp_slot.name} vs {target_node.name} on slot: {i}'
                             )
 
                             if len(disagreements) > 5:
                                 raise RedisClusterException(
-                                    'startup_nodes could not agree on a valid'
-                                    ' slots cache: {}'.format(
-                                        ", ".join(disagreements))
+                                    f'startup_nodes could not agree on a valid '
+                                    f'slots cache: {", ".join(disagreements)}'
                                 )
 
         if not startup_nodes_reachable:
@@ -1368,9 +1366,8 @@ def initialize(self):
             # Despite the requirement that the slots be covered, there
             # isn't a full coverage
             raise RedisClusterException(
-                'All slots are not covered after query all startup_nodes.'
-                ' {} of {} covered...'.format(
-                    len(self.slots_cache), REDIS_CLUSTER_HASH_SLOTS)
+                f'All slots are not covered after query all startup_nodes. '
+                f'{len(self.slots_cache)} of {REDIS_CLUSTER_HASH_SLOTS} covered...'
             )
         elif not fully_covered and not self._require_full_coverage:
             # The user set require_full_coverage to False.
@@ -1387,8 +1384,7 @@ def initialize(self):
                     'cluster-require-full-coverage configuration to no on '
                     'all of the cluster nodes if you wish the cluster to '
                     'be able to serve without being fully covered.'
-                    ' {} of {} covered...'.format(
-                        len(self.slots_cache), REDIS_CLUSTER_HASH_SLOTS)
+                    f'{len(self.slots_cache)} of {REDIS_CLUSTER_HASH_SLOTS} covered...'
                 )
 
         # Set the tmp variables to the real variables
@@ -1642,8 +1638,10 @@ def annotate_exception(self, exception, number, command):
         Provides extra context to the exception prior to it being handled
         """
         cmd = ' '.join(map(safe_str, command))
-        msg = 'Command # %d (%s) of pipeline caused error: %s' % (
-            number, cmd, exception.args[0])
+        msg = (
+            f'Command # {number} ({cmd}) of pipeline '
+            f'caused error: {exception.args[0]}'
+        )
         exception.args = (msg,) + exception.args[1:]
 
     def execute(self, raise_on_error=True):
@@ -1832,12 +1830,12 @@ def _send_cluster_commands(self, stack,
             # If a lot of commands have failed, we'll be setting the
             # flag to rebuild the slots table from scratch.
             # So MOVED errors should correct themselves fairly quickly.
-            msg = 'An exception occurred during pipeline execution. ' \
-                  'args: {0}, error: {1} {2}'.\
-                format(attempt[-1].args,
-                       type(attempt[-1].result).__name__,
-                       str(attempt[-1].result))
-            log.exception(msg)
+            log.exception(
+                f'An exception occurred during pipeline execution. '
+                f'args: {attempt[-1].args}, '
+                f'error: {type(attempt[-1].result).__name__} '
+                f'{str(attempt[-1].result)}'
+            )
             self.reinitialize_counter += 1
             if self._should_reinitialized():
                 self.nodes_manager.initialize()
@@ -1929,8 +1927,8 @@ def block_pipeline_command(func):
 
     def inner(*args, **kwargs):
         raise RedisClusterException(
-            "ERROR: Calling pipelined function {} is blocked when "
-            "running redis in cluster mode...".format(func.__name__))
+            f"ERROR: Calling pipelined function {func.__name__} is blocked when "
+            f"running redis in cluster mode...")
 
     return inner
 

redis/commands/cluster.py

@@ -638,11 +638,10 @@ def stralgo(self, algo, value1, value2, specific_argument='strings',
         # check validity
         supported_algo = ['LCS']
         if algo not in supported_algo:
-            raise DataError("The supported algorithms are: %s"
-                            % (', '.join(supported_algo)))
+            supported_algos_str = ', '.join(supported_algo)
+            raise DataError(f"The supported algorithms are: {supported_algos_str}")
         if specific_argument not in ['keys', 'strings']:
-            raise DataError("specific_argument can be only"
-                            " keys or strings")
+            raise DataError("specific_argument can be only keys or strings")
         if len and idx:
             raise DataError("len and idx cannot be provided together.")
 

redis/commands/core.py

@@ -227,8 +227,8 @@ def acl_setuser(self, username, enabled=False, nopass=False,
                 elif password.startswith(b'-'):
                     pieces.append(b'<%s' % password[1:])
                 else:
-                    raise DataError('Password %d must be prefixeed with a '
-                                    '"+" to add or a "-" to remove' % i)
+                    raise DataError(f'Password {i} must be prefixed with a '
+                                    f'"+" to add or a "-" to remove')
 
         if hashed_passwords:
             # as most users will have only one password, allow remove_passwords
@@ -241,8 +241,8 @@ def acl_setuser(self, username, enabled=False, nopass=False,
                 elif hashed_password.startswith(b'-'):
                     pieces.append(b'!%s' % hashed_password[1:])
                 else:
-                    raise DataError('Hashed %d password must be prefixeed '
-                                    'with a "+" to add or a "-" to remove' % i)
+                    raise DataError(f'Hashed password {i} must be prefixed with a '
+                                    f'"+" to add or a "-" to remove')
 
         if nopass:
             pieces.append(b'nopass')
@@ -260,16 +260,18 @@ def acl_setuser(self, username, enabled=False, nopass=False,
                 elif category.startswith(b'-'):
                     pieces.append(b'-@%s' % category[1:])
                 else:
-                    raise DataError('Category "%s" must be prefixed with '
-                                    '"+" or "-"'
-                                    % encoder.decode(category, force=True))
+                    raise DataError(
+                        f'Category "{encoder.decode(category, force=True)}" '
+                        'must be prefixed with "+" or "-"'
+                    )
         if commands:
             for cmd in commands:
                 cmd = encoder.encode(cmd)
                 if not cmd.startswith(b'+') and not cmd.startswith(b'-'):
-                    raise DataError('Command "%s" must be prefixed with '
-                                    '"+" or "-"'
-                                    % encoder.decode(cmd, force=True))
+                    raise DataError(
+                        f'Command "{encoder.decode(cmd, force=True)}" '
+                        'must be prefixed with "+" or "-"'
+                    )
                 pieces.append(cmd)
 
         if keys:
@@ -1552,11 +1554,10 @@ def stralgo(self, algo, value1, value2, specific_argument='strings',
         # check validity
         supported_algo = ['LCS']
         if algo not in supported_algo:
-            raise DataError("The supported algorithms are: %s"
-                            % (', '.join(supported_algo)))
+            supported_algos_str = ', '.join(supported_algo)
+            raise DataError(f"The supported algorithms are: {supported_algos_str}")
         if specific_argument not in ['keys', 'strings']:
-            raise DataError("specific_argument can be only"
-                            " keys or strings")
+            raise DataError("specific_argument can be only keys or strings")
         if len and idx:
             raise DataError("len and idx cannot be provided together.")
 
@@ -3464,8 +3465,8 @@ def hmset(self, name, mapping):
         For more information check https://redis.io/commands/hmset
         """
         warnings.warn(
-            '%s.hmset() is deprecated. Use %s.hset() instead.'
-            % (self.__class__.__name__, self.__class__.__name__),
+            f'{self.__class__.__name__}.hmset() is deprecated. '
+            f'Use {self.__class__.__name__}.hset() instead.',
             DeprecationWarning,
             stacklevel=2,
         )

redis/commands/parser.py

@@ -46,8 +46,9 @@ def get_keys(self, redis_conn, *args):
                 # version has changed, the commands may not be current
                 self.initialize(redis_conn)
                 if cmd_name not in self.commands:
-                    raise RedisError("{} command doesn't exist in Redis "
-                                     "commands".format(cmd_name.upper()))
+                    raise RedisError(
+                        f"{cmd_name.upper()} command doesn't exist in Redis commands"
+                    )
 
         command = self.commands.get(cmd_name)
         if 'movablekeys' in command['flags']:

redis/commands/search/aggregation.py

@@ -392,9 +392,8 @@ def __init__(self, rows, cursor, schema):
         self.schema = schema
 
     def __repr__(self):
-        return "<{} at 0x{:x} Rows={}, Cursor={}>".format(
-            self.__class__.__name__,
-            id(self),
-            len(self.rows),
-            self.cursor.cid if self.cursor else -1,
+        cid = self.cursor.cid if self.cursor else -1
+        return (
+            f"<{self.__class__.__name__} at 0x{id(self):x} "
+            f"Rows={len(self.rows)}, Cursor={cid}>"
         )

redis/commands/search/result.py

@@ -70,4 +70,4 @@ def __init__(
             self.docs.append(doc)
 
     def __repr__(self):
-        return "Result{%d total, docs: %s}" % (self.total, self.docs)
+        return f"Result{{{self.total} total, docs: {self.docs}}}"