Run flynt

Author: akx

benchmarks/base.py

@@ -35,11 +35,11 @@ def run_benchmark(self):
         for value_set in itertools.product(*group_values):
             pairs = list(zip(group_names, value_set))
             arg_string = ', '.join(f'{p[0]}={p[1]}' for p in pairs)
-            sys.stdout.write('Benchmark: %s... ' % arg_string)
+            sys.stdout.write(f'Benchmark: {arg_string}... ')
             sys.stdout.flush()
             kwargs = dict(pairs)
             setup = functools.partial(self.setup, **kwargs)
             run = functools.partial(self.run, **kwargs)
             t = timeit.timeit(stmt=run, setup=setup, number=1000)
-            sys.stdout.write('%f\n' % t)
+            sys.stdout.write(f'{t:f}\n')
             sys.stdout.flush()

benchmarks/command_packer_benchmark.py

@@ -16,8 +16,7 @@ def send_packed_command(self, command, check_health=True):
                 _errno, errmsg = 'UNKNOWN', e.args[0]
             else:
                 _errno, errmsg = e.args
-            raise ConnectionError("Error %s while writing to socket. %s." %
-                                  (_errno, errmsg))
+            raise ConnectionError(f"Error {_errno} while writing to socket. {errmsg}.")
         except Exception:
             self.disconnect()
             raise
@@ -48,8 +47,7 @@ def send_packed_command(self, command, check_health=True):
                 _errno, errmsg = 'UNKNOWN', e.args[0]
             else:
                 _errno, errmsg = e.args
-            raise ConnectionError("Error %s while writing to socket. %s." %
-                                  (_errno, errmsg))
+            raise ConnectionError(f"Error {_errno} while writing to socket. {errmsg}.")
         except Exception:
             self.disconnect()
             raise

redis/client.py

@@ -1141,7 +1141,7 @@ def __enter__(self):
         # check that monitor returns 'OK', but don't return it to user
         response = self.connection.read_response()
         if not bool_ok(response):
-            raise RedisError('MONITOR failed: %s' % response)
+            raise RedisError(f'MONITOR failed: {response}')
         return self
 
     def __exit__(self, *args):
@@ -1517,12 +1517,10 @@ def run_in_thread(self, sleep_time=0, daemon=False,
                       exception_handler=None):
         for channel, handler in self.channels.items():
             if handler is None:
-                raise PubSubError("Channel: '%s' has no handler registered" %
-                                  channel)
+                raise PubSubError(f"Channel: '{channel}' has no handler registered")
         for pattern, handler in self.patterns.items():
             if handler is None:
-                raise PubSubError("Pattern: '%s' has no handler registered" %
-                                  pattern)
+                raise PubSubError(f"Pattern: '{pattern}' has no handler registered")
 
         thread = PubSubWorkerThread(
             self,

redis/cluster.py

@@ -678,8 +678,7 @@ def _determine_nodes(self, *args, **kwargs):
             # get the nodes group for this command if it was predefined
             command_flag = self.command_flags.get(command)
         if command_flag:
-            log.debug("Target node/s for {0}: {1}".
-                      format(command, command_flag))
+            log.debug(f"Target node/s for {command}: {command_flag}")
         if command_flag == self.__class__.RANDOM:
             # return a random node
             return [self.get_random_node()]
@@ -824,8 +823,7 @@ def execute_command(self, *args, **kwargs):
                         *args, **kwargs, nodes_flag=target_nodes)
                     if not target_nodes:
                         raise RedisClusterException(
-                            "No targets were found to execute"
-                            " {} command on".format(args))
+                            f"No targets were found to execute {args} command on")
                 for node in target_nodes:
                     res[node.name] = self._execute_command(
                         node, *args, **kwargs)
@@ -1495,8 +1493,7 @@ def _raise_on_invalid_node(self, redis_cluster, node, host, port):
         """
         if node is None or redis_cluster.get_node(node_name=node.name) is None:
             raise RedisClusterException(
-                "Node {}:{} doesn't exist in the cluster"
-                .format(host, port))
+                f"Node {host}:{port} doesn't exist in the cluster")
 
     def execute_command(self, *args, **kwargs):
         """

redis/commands/cluster.py

@@ -228,8 +228,7 @@ def client_kill_filter(self, _id=None, _type=None, addr=None,
         if _type is not None:
             client_types = ('normal', 'master', 'slave', 'pubsub')
             if str(_type).lower() not in client_types:
-                raise DataError("CLIENT KILL type must be one of {!r}".format(
-                    client_types))
+                raise DataError(f"CLIENT KILL type must be one of {client_types!r}")
             args.extend((b'TYPE', _type))
         if skipme is not None:
             if not isinstance(skipme, bool):
@@ -267,8 +266,7 @@ def client_list(self, _type=None, target_nodes=None):
         if _type is not None:
             client_types = ('normal', 'master', 'replica', 'pubsub')
             if str(_type).lower() not in client_types:
-                raise DataError("CLIENT LIST _type must be one of {!r}".format(
-                    client_types))
+                raise DataError(f"CLIENT LIST _type must be one of {client_types!r}")
             return self.execute_command('CLIENT LIST',
                                         b'TYPE',
                                         _type,
@@ -302,7 +300,7 @@ def client_reply(self, reply, target_nodes=None):
         """
         replies = ['ON', 'OFF', 'SKIP']
         if reply not in replies:
-            raise DataError('CLIENT REPLY must be one of %r' % replies)
+            raise DataError(f'CLIENT REPLY must be one of {replies!r}')
         return self.execute_command("CLIENT REPLY", reply,
                                     target_nodes=target_nodes)
 
@@ -788,8 +786,7 @@ def cluster_failover(self, target_node, option=None):
         if option:
             if option.upper() not in ['FORCE', 'TAKEOVER']:
                 raise RedisError(
-                    'Invalid option for CLUSTER FAILOVER command: {}'.format(
-                        option))
+                    f'Invalid option for CLUSTER FAILOVER command: {option}')
             else:
                 return self.execute_command('CLUSTER FAILOVER', option,
                                             target_nodes=target_node)

redis/commands/core.py

@@ -342,8 +342,7 @@ def client_kill_filter(self, _id=None, _type=None, addr=None,
         if _type is not None:
             client_types = ('normal', 'master', 'slave', 'pubsub')
             if str(_type).lower() not in client_types:
-                raise DataError("CLIENT KILL type must be one of {!r}".format(
-                                client_types))
+                raise DataError(f"CLIENT KILL type must be one of {client_types!r}")
             args.extend((b'TYPE', _type))
         if skipme is not None:
             if not isinstance(skipme, bool):
@@ -388,8 +387,7 @@ def client_list(self, _type=None, client_id=[]):
         if _type is not None:
             client_types = ('normal', 'master', 'replica', 'pubsub')
             if str(_type).lower() not in client_types:
-                raise DataError("CLIENT LIST _type must be one of {!r}".format(
-                                client_types))
+                raise DataError(f"CLIENT LIST _type must be one of {client_types!r}")
             args.append(b'TYPE')
             args.append(_type)
         if not isinstance(client_id, list):
@@ -434,7 +432,7 @@ def client_reply(self, reply):
         """
         replies = ['ON', 'OFF', 'SKIP']
         if reply not in replies:
-            raise DataError('CLIENT REPLY must be one of %r' % replies)
+            raise DataError(f'CLIENT REPLY must be one of {replies!r}')
         return self.execute_command("CLIENT REPLY", reply)
 
     def client_id(self):
@@ -551,7 +549,7 @@ def config_rewrite(self):
         return self.execute_command('CONFIG REWRITE')
 
     def cluster(self, cluster_arg, *args):
-        return self.execute_command('CLUSTER %s' % cluster_arg.upper(), *args)
+        return self.execute_command(f'CLUSTER {cluster_arg.upper()}', *args)
 
     def dbsize(self):
         """

redis/commands/search/commands.py

@@ -348,7 +348,7 @@ def _mk_query_args(self, query):
             # convert the query from a text to a query object
             query = Query(query)
         if not isinstance(query, Query):
-            raise ValueError("Bad query type %s" % type(query))
+            raise ValueError(f"Bad query type {type(query)}")
 
         args += query.get_args()
         return args, query

redis/commands/search/document.py

@@ -10,4 +10,4 @@ def __init__(self, id, payload=None, **fields):
             setattr(self, k, v)
 
     def __repr__(self):
-        return "Document %s" % self.__dict__
+        return f"Document {self.__dict__}"

redis/commands/search/indexDefinition.py

@@ -38,8 +38,7 @@ def _appendIndexType(self, index_type):
         elif index_type is IndexType.JSON:
             self.args.extend(["ON", "JSON"])
         elif index_type is not None:
-            raise RuntimeError("index_type must be one of {}".
-                               format(list(IndexType)))
+            raise RuntimeError(f"index_type must be one of {list(IndexType)}")
 
     def _appendPrefix(self, prefix):
         """Append PREFIX."""

redis/commands/search/querystring.py

@@ -199,11 +199,9 @@ def join_fields(self, key, vals):
         if len(vals) == 1:
             return [BaseNode(f"@{key}:{vals[0].to_string()}")]
         if not vals[0].combinable:
-            return [BaseNode("@{}:{}".format(key,
-                                             v.to_string())) for v in vals]
+            return [BaseNode(f"@{key}:{v.to_string()}") for v in vals]
         s = BaseNode(
-            "@{}:({})".format(key,
-                              self.JOINSTR.join(v.to_string() for v in vals))
+            f"@{key}:({self.JOINSTR.join(v.to_string() for v in vals)})"
         )
         return [s]
 
@@ -220,9 +218,7 @@ def JOINSTR(self):
     def to_string(self, with_parens=None):
         with_parens = self._should_use_paren(with_parens)
         pre, post = ("(", ")") if with_parens else ("", "")
-        return "{}{}{}".format(
-            pre, self.JOINSTR.join(n.to_string() for n in self.params), post
-        )
+        return f"{pre}{self.JOINSTR.join(n.to_string() for n in self.params)}{post}"
 
     def _should_use_paren(self, optval):
         if optval is not None:

redis/connection.py

@@ -214,8 +214,7 @@ def _read_from_socket(self, length=None, timeout=SENTINEL,
             allowed = NONBLOCKING_EXCEPTION_ERROR_NUMBERS.get(ex.__class__, -1)
             if not raise_on_timeout and ex.errno == allowed:
                 return False
-            raise ConnectionError("Error while reading from socket: %s" %
-                                  (ex.args,))
+            raise ConnectionError(f"Error while reading from socket: {ex.args}")
         finally:
             if custom_timeout:
                 sock.settimeout(self.socket_timeout)
@@ -323,7 +322,7 @@ def read_response(self, disable_decoding=False):
         byte, response = raw[:1], raw[1:]
 
         if byte not in (b'-', b'+', b':', b'$', b'*'):
-            raise InvalidResponse("Protocol Error: %r" % raw)
+            raise InvalidResponse(f"Protocol Error: {raw!r}")
 
         # server returned an error
         if byte == b'-':
@@ -445,8 +444,7 @@ def read_from_socket(self, timeout=SENTINEL, raise_on_timeout=True):
             allowed = NONBLOCKING_EXCEPTION_ERROR_NUMBERS.get(ex.__class__, -1)
             if not raise_on_timeout and ex.errno == allowed:
                 return False
-            raise ConnectionError("Error while reading from socket: %s" %
-                                  (ex.args,))
+            raise ConnectionError(f"Error while reading from socket: {ex.args}")
         finally:
             if custom_timeout:
                 sock.settimeout(self._socket_timeout)
@@ -646,8 +644,7 @@ def _error_message(self, exception):
         # args for socket.error can either be (errno, "message")
         # or just "message"
         if len(exception.args) == 1:
-            return "Error connecting to %s:%s. %s." % \
-                (self.host, self.port, exception.args[0])
+            return f"Error connecting to {self.host}:{self.port}. {exception.args[0]}."
         else:
             return "Error %s connecting to %s:%s. %s." % \
                 (exception.args[0], self.host, self.port, exception.args[1])
@@ -741,8 +738,7 @@ def send_packed_command(self, command, check_health=True):
             else:
                 errno = e.args[0]
                 errmsg = e.args[1]
-            raise ConnectionError("Error %s while writing to socket. %s." %
-                                  (errno, errmsg))
+            raise ConnectionError(f"Error {errno} while writing to socket. {errmsg}.")
         except BaseException:
             self.disconnect()
             raise
@@ -767,8 +763,7 @@ def read_response(self, disable_decoding=False):
             )
         except socket.timeout:
             self.disconnect()
-            raise TimeoutError("Timeout reading from %s:%s" %
-                               (self.host, self.port))
+            raise TimeoutError(f"Timeout reading from {self.host}:{self.port}")
         except OSError as e:
             self.disconnect()
             raise ConnectionError("Error while reading from %s:%s : %s" %
@@ -867,8 +862,7 @@ def __init__(self, ssl_keyfile=None, ssl_certfile=None,
             }
             if ssl_cert_reqs not in CERT_REQS:
                 raise RedisError(
-                    "Invalid SSL Certificate Requirements Flag: %s" %
-                    ssl_cert_reqs)
+                    f"Invalid SSL Certificate Requirements Flag: {ssl_cert_reqs}")
             ssl_cert_reqs = CERT_REQS[ssl_cert_reqs]
         self.cert_reqs = ssl_cert_reqs
         self.ca_certs = ssl_ca_certs
@@ -947,8 +941,7 @@ def _error_message(self, exception):
         # args for socket.error can either be (errno, "message")
         # or just "message"
         if len(exception.args) == 1:
-            return "Error connecting to unix socket: %s. %s." % \
-                (self.path, exception.args[0])
+            return f"Error connecting to unix socket: {self.path}. {exception.args[0]}."
         else:
             return "Error %s connecting to unix socket: %s. %s." % \
                 (exception.args[0], self.path, exception.args[1])
@@ -990,7 +983,7 @@ def parse_url(url):
                     kwargs[name] = parser(value)
                 except (TypeError, ValueError):
                     raise ValueError(
-                        "Invalid value for `%s` in connection URL." % name
+                        f"Invalid value for `{name}` in connection URL."
                     )
             else:
                 kwargs[name] = value

redis/sentinel.py

@@ -136,7 +136,7 @@ def rotate_slaves(self):
             yield self.get_master_address()
         except MasterNotFoundError:
             pass
-        raise SlaveNotFoundError('No slave found for %r' % (self.service_name))
+        raise SlaveNotFoundError(f'No slave found for {self.service_name!r}')
 
 
 class Sentinel(SentinelCommands):

tasks.py

@@ -73,7 +73,7 @@ def clean(c):
         shutil.rmtree("build")
     if os.path.isdir("dist"):
         shutil.rmtree("dist")
-    run("docker rm -f {}".format(' '.join(dockers)))
+    run(f"docker rm -f {' '.join(dockers)}")
 
 
 @task

tests/conftest.py

@@ -87,8 +87,7 @@ def wait_for_cluster_creation(redis_url, cluster_nodes, timeout=20):
     now = time.time()
     end_time = now + timeout
     client = None
-    print("Waiting for {0} cluster nodes to become available".
-          format(cluster_nodes))
+    print(f"Waiting for {cluster_nodes} cluster nodes to become available")
     while now < end_time:
         try:
             client = redis.RedisCluster.from_url(redis_url)
@@ -320,8 +319,8 @@ def wait_for_command(client, monitor, command):
     if LooseVersion(redis_version) >= LooseVersion('5.0.0'):
         id_str = str(client.client_id())
     else:
-        id_str = '%08x' % random.randrange(2**32)
-    key = '__REDIS-PY-%s__' % id_str
+        id_str = f'{random.randrange(2 ** 32):08x}'
+    key = f'__REDIS-PY-{id_str}__'
     client.get(key)
     while True:
         monitor_response = monitor.next_command()

tests/test_cluster.py

@@ -333,8 +333,7 @@ def ok_response(connection, *args, **options):
                     return "MOCK_OK"
 
                 parse_response.side_effect = ok_response
-                raise AskError("12182 {}:{}".format(redirect_node.host,
-                                                      redirect_node.port))
+                raise AskError(f"12182 {redirect_node.host}:{redirect_node.port}")
 
             parse_response.side_effect = ask_redirect_effect
 
@@ -2373,8 +2372,7 @@ def test_asking_error(self, r):
             warnings.warn("skipping this test since the cluster has only one "
                           "node")
             return
-        ask_msg = "{} {}:{}".format(r.keyslot(key), ask_node.host,
-                                       ask_node.port)
+        ask_msg = f"{r.keyslot(key)} {ask_node.host}:{ask_node.port}"
 
         def raise_ask_error():
             raise AskError(ask_msg)
@@ -2434,9 +2432,7 @@ def test_moved_redirection_on_slave_with_default(self, r):
         with r.pipeline() as readwrite_pipe:
             mock_node_resp(primary, "MOCK_FOO")
             if replica is not None:
-                moved_error = "{} {}:{}".format(r.keyslot(key),
-                                                   primary.host,
-                                                   primary.port)
+                moved_error = f"{r.keyslot(key)} {primary.host}:{primary.port}"
 
                 def raise_moved_error():
                     raise MovedError(moved_error)

tests/test_commands.py

@@ -1805,11 +1805,11 @@ def test_zadd_incr_with_xx(self, r):
     def test_zadd_gt_lt(self, r):
 
         for i in range(1, 20):
-            r.zadd('a', {'a%s' % i: i})
+            r.zadd('a', {f'a{i}': i})
         assert r.zadd('a', {'a20': 5}, gt=3) == 1
 
         for i in range(1, 20):
-            r.zadd('a', {'a%s' % i: i})
+            r.zadd('a', {f'a{i}': i})
         assert r.zadd('a', {'a2': 5}, lt=1) == 0
 
         # cannot use both nx and xx options

tests/test_connection.py

@@ -15,7 +15,7 @@ def test_invalid_response(r):
     with mock.patch.object(parser._buffer, 'readline', return_value=raw):
         with pytest.raises(InvalidResponse) as cm:
             parser.read_response()
-    assert str(cm.value) == 'Protocol Error: %r' % raw
+    assert str(cm.value) == f'Protocol Error: {raw!r}'
 
 
 @skip_if_server_version_lt('4.0.0')