pylint: fix consider-using-f-string cases

Fix all cases of C0209 consider-using-f-string.

Part of #270

Author: DifferentialOrange

tarantool/connection.py

@@ -1210,8 +1210,8 @@ def check():  # Check that connection is alive
             else:
                 if self.connected:
                     break
-            warn("Reconnecting, attempt %d of %d" %
-                 (attempt, self.reconnect_max_attempts), NetworkWarning)
+            warn(f"Reconnecting, attempt {attempt} of {self.reconnect_max_attempts}",
+                 NetworkWarning)
             if attempt == self.reconnect_max_attempts:
                 raise NetworkError(
                     socket.error(last_errno, errno.errorcode[last_errno]))

tarantool/connection_pool.py

@@ -526,7 +526,7 @@ def _make_key(self, addr):
         :meta private:
         """
 
-        return '{0}:{1}'.format(addr['host'], addr['port'])
+        return f"{addr['host']}:{addr['port']}"
 
     def _get_new_state(self, unit):
         """
@@ -546,38 +546,33 @@ def _get_new_state(self, unit):
             try:
                 conn.connect()
             except NetworkError as exc:
-                msg = "Failed to connect to {0}:{1}".format(
-                    unit.addr['host'], unit.addr['port'])
+                msg = f"Failed to connect to {unit.addr['host']}:{unit.addr['port']}"
                 warn(msg, ClusterConnectWarning)
                 return InstanceState(Status.UNHEALTHY)
 
         try:
             resp = conn.call('box.info')
         except NetworkError as exc:
-            msg = "Failed to get box.info for {0}:{1}, reason: {2}".format(
-                unit.addr['host'], unit.addr['port'], repr(exc))
+            msg = f"Failed to get box.info for {unit.addr['host']}:{unit.addr['port']}, reason: {repr(exc)}"
             warn(msg, PoolTolopogyWarning)
             return InstanceState(Status.UNHEALTHY)
 
         try:
             read_only = resp.data[0]['ro']
         except (IndexError, KeyError) as exc:
-            msg = "Incorrect box.info response from {0}:{1}".format(
-                unit.addr['host'], unit.addr['port'])
+            msg = f"Incorrect box.info response from {unit.addr['host']}:{unit.addr['port']}"
             warn(msg, PoolTolopogyWarning)
             return InstanceState(Status.UNHEALTHY)
 
         try:
             status = resp.data[0]['status']
 
             if status != 'running':
-                msg = "{0}:{1} instance status is not 'running'".format(
-                    unit.addr['host'], unit.addr['port'])
+                msg = f"{unit.addr['host']}:{unit.addr['port']} instance status is not 'running'"
                 warn(msg, PoolTolopogyWarning)
                 return InstanceState(Status.UNHEALTHY)
         except (IndexError, KeyError) as exc:
-            msg = "Incorrect box.info response from {0}:{1}".format(
-                unit.addr['host'], unit.addr['port'])
+            msg = f"Incorrect box.info response from {unit.addr['host']}:{unit.addr['port']}"
             warn(msg, PoolTolopogyWarning)
             return InstanceState(Status.UNHEALTHY)
 

tarantool/dbapi.py

@@ -291,7 +291,7 @@ def _set_autocommit(self, autocommit):
 
         if not isinstance(autocommit, bool):
             raise InterfaceError("autocommit parameter must be boolean, "
-                                 "not %s" % autocommit.__class__.__name__)
+                                 f"not {autocommit.__class__.__name__}")
         if autocommit is False:
             raise NotSupportedError("The connector supports "
                                     "only autocommit mode")

tarantool/error.py

@@ -194,7 +194,7 @@ def os_strerror_patched(code):
         if not message.startswith("Unknown"):
             return message
         else:
-            return _code2str.get(code, "Unknown error %s" % code)
+            return _code2str.get(code, f"Unknown error {code}")
 
     os.strerror = os_strerror_patched
     del os_strerror_patched

tarantool/mesh_connection.py

@@ -61,7 +61,7 @@ def parse_uri(uri):
 
     # TODO: Support Unix sockets.
     def parse_error(uri, msg):
-        msg = 'URI "%s": %s' % (uri, msg)
+        msg = f'URI "{uri}": {msg}'
         return None, msg
 
     if not uri:
@@ -119,7 +119,7 @@ def prepare_address(address):
     """
 
     def format_error(address, err):
-        return None, 'Address %s: %s' % (str(address), err)
+        return None, f'Address {str(address)}: {err}'
 
     if not isinstance(address, dict):
         return format_error(address, 'address must be a dict')
@@ -559,7 +559,7 @@ def _opt_refresh_instances(self):
         try:
             resp = self._send_request_wo_reconnect(request)
         except DatabaseError as exc:
-            msg = 'got "%s" error, skipped address updates' % str(exc)
+            msg = f'got "{str(exc)}" error, skipped address updates'
             warn(msg, ClusterDiscoveryWarning)
             return
 

tarantool/msgpack_ext/packer.py

@@ -48,4 +48,4 @@ def default(obj, packer=None):
     for encoder in encoders:
         if isinstance(obj, encoder['type']):
             return ExtType(encoder['ext'].EXT_ID, encoder['ext'].encode(obj, packer))
-    raise TypeError("Unknown type: %r" % (obj,))
+    raise TypeError(f"Unknown type: {repr(obj)}")

tarantool/msgpack_ext/unpacker.py

@@ -42,4 +42,4 @@ def ext_hook(code, data, unpacker=None):
 
     if code in decoders:
         return decoders[code](data, unpacker)
-    raise NotImplementedError("Unknown msgpack extension type code %d" % (code,))
+    raise NotImplementedError(f"Unknown msgpack extension type code {code}")

tarantool/request.py

@@ -683,10 +683,10 @@ def __init__(self, conn, sql, args):
 
         super(RequestExecute, self).__init__(conn)
         if isinstance(args, Mapping):
-            args = [{":%s" % name: value} for name, value in args.items()]
+            args = [{f":{name}": value} for name, value in args.items()]
         elif not isinstance(args, Sequence):
-            raise TypeError("Parameter type '%s' is not supported. "
-                            "Must be a mapping or sequence" % type(args))
+            raise TypeError(f"Parameter type '{type(args)}' is not supported. "
+                            "Must be a mapping or sequence")
 
         request_body = self._dumps({IPROTO_SQL_TEXT: sql,
                                     IPROTO_SQL_BIND: args})

tarantool/schema.py

@@ -244,7 +244,7 @@ def fetch_space(self, space):
         elif len(space_row) == 0 or not len(space_row[0]):
             # We can't find space with this name or id
             temp_name = 'name' if isinstance(space, str) else 'id'
-            errmsg = "There's no space with {1} '{0}'".format(space, temp_name)
+            errmsg = f"There's no space with {temp_name} '{space}'"
             raise SchemaError(errmsg)
 
         space_row = space_row[0]
@@ -356,9 +356,8 @@ def fetch_index(self, space_object, index):
         elif len(index_row) == 0 or not len(index_row[0]):
             # We can't find index with this name or id
             temp_name = 'name' if isinstance(index, str) else 'id'
-            errmsg = ("There's no index with {2} '{0}'"
-                      " in space '{1}'").format(index, space_object.name,
-                                                temp_name)
+            errmsg = (f"There's no index with {temp_name} '{index}'"
+                      f" in space '{space_object.name}'")
             raise SchemaError(errmsg)
 
         index_row = index_row[0]
@@ -452,9 +451,7 @@ def get_field(self, space, field):
             return _space.format[field]
         except:
             kind = 'name' if isinstance(field, str) else 'id'
-            errmsg = "There's no field with {2} '{0}' in space '{1}'".format(
-                    field, _space.name, kind
-            )
+            errmsg = f"There's no field with {kind} '{field}' in space '{_space.name}'"
             raise SchemaError(errmsg)
 
         return field

test/suites/lib/remote_tarantool_server.py

@@ -41,42 +41,38 @@ def __init__(self):
     def acquire_lock(self):
         deadline = time.time() + AWAIT_TIME
         while True:
-            res = self.admin.execute('return acquire_lock("%s")' % self.whoami)
+            res = self.admin.execute(f'return acquire_lock("{ self.whoami}")')
             ok = res[0]
             err = res[1] if not ok else None
             if ok:
                 break
             if time.time() > deadline:
-                raise RuntimeError('can not acquire "%s" lock: %s' % (
-                    self.whoami, str(err)))
-            print('waiting to acquire "%s" lock' % self.whoami,
+                raise RuntimeError(f'can not acquire "{self.whoami}" lock: {str(err)}')
+            print(f'waiting to acquire "{self.whoami}" lock',
                   file=sys.stderr)
             time.sleep(1)
         self.lock_is_acquired = True
 
     def touch_lock(self):
         assert(self.lock_is_acquired)
-        res = self.admin.execute('return touch_lock("%s")' % self.whoami)
+        res = self.admin.execute(f'return touch_lock("{self.whoami}")')
         ok = res[0]
         err = res[1] if not ok else None
         if not ok:
-            raise RuntimeError('can not update "%s" lock: %s' % (
-                self.whoami, str(err)))
+            raise RuntimeError(f'can not update "{self.whoami}" lock: {str(err)}')
 
     def release_lock(self):
-        res = self.admin.execute('return release_lock("%s")' % self.whoami)
+        res = self.admin.execute(f'return release_lock("{self.whoami}")')
         ok = res[0]
         err = res[1] if not ok else None
         if not ok:
-            raise RuntimeError('can not release "%s" lock: %s' % (
-                self.whoami, str(err)))
+            raise RuntimeError(f'can not release "{self.whoami}" lock: {str(err)}')
         self.lock_is_acquired = False
 
     def start(self):
         if not self.lock_is_acquired:
             self.acquire_lock()
-        self.admin.execute('box.cfg{listen = "0.0.0.0:%s"}' %
-                           self.args['primary'])
+        self.admin.execute(f'box.cfg{{listen = "0.0.0.0:{self.args["primary"]}"}}')
 
     def stop(self):
         self.admin.execute('box.cfg{listen = box.NULL}')

test/suites/lib/skip.py

@@ -34,7 +34,7 @@ def skip_or_run_test_tarantool_impl(self, required_tt_version, msg):
     support_version = pkg_resources.parse_version(required_tt_version)
 
     if self.tnt_version < support_version:
-        self.skipTest('Tarantool %s %s' % (self.tnt_version, msg))
+        self.skipTest(f'Tarantool {self.tnt_version} {msg}')
 
 
 def skip_or_run_test_tarantool(func, required_tt_version, msg):
@@ -92,9 +92,9 @@ def wrapper(self, *args, **kwargs):
 
         assert srv is not None
 
-        resp = srv.admin("pcall(require, '%s')" % required_tt_module)
+        resp = srv.admin(f"pcall(require, '{required_tt_module}')")
         if not resp[0]:
-            self.skipTest('Tarantool %s' % (msg, ))
+            self.skipTest(f'Tarantool {msg}')
 
         if func.__name__ != 'setUp':
             func(self, *args, **kwargs)
@@ -119,7 +119,7 @@ def wrapper(self, *args, **kwargs):
         python_version = pkg_resources.parse_version(python_version_str)
         support_version = pkg_resources.parse_version(required_python_version)
         if python_version < support_version:
-            self.skipTest('Python %s connector %s' % (python_version, msg))
+            self.skipTest(f'Python {python_version} connector {msg}')
 
         if func.__name__ != 'setUp':
             func(self, *args, **kwargs)

test/suites/lib/tarantool_server.py

@@ -25,7 +25,7 @@ def check_port(port, rais=True):
     sock.close()
 
     if rais:
-        raise RuntimeError("The server is already running on port {0}".format(port))
+        raise RuntimeError(f"The server is already running on port {port}")
     return False
 
 
@@ -100,7 +100,7 @@ def _admin(self, port):
         try:
             int(port)
         except ValueError:
-            raise ValueError("Bad port number: '%s'" % port)
+            raise ValueError(f"Bad port number: '{port}'")
         if hasattr(self, 'admin'):
             del self.admin
         self.admin = TarantoolAdmin('0.0.0.0', port)
@@ -186,17 +186,17 @@ def generate_listen(self, port, port_only):
         if not port_only and self.transport == SSL_TRANSPORT:
             listen = self.host + ":" + str(port) + "?transport=ssl&"
             if self.ssl_key_file:
-                listen += "ssl_key_file={}&".format(self.ssl_key_file)
+                listen += f"ssl_key_file={self.ssl_key_file}&"
             if self.ssl_cert_file:
-                listen += "ssl_cert_file={}&".format(self.ssl_cert_file)
+                listen += f"ssl_cert_file={self.ssl_cert_file}&"
             if self.ssl_ca_file:
-                listen += "ssl_ca_file={}&".format(self.ssl_ca_file)
+                listen += f"ssl_ca_file={self.ssl_ca_file}&"
             if self.ssl_ciphers:
-                listen += "ssl_ciphers={}&".format(self.ssl_ciphers)
+                listen += f"ssl_ciphers={self.ssl_ciphers}&"
             if self.ssl_password:
-                listen += "ssl_password={}&".format(self.ssl_password)
+                listen += f"ssl_password={self.ssl_password}&"
             if self.ssl_password_file:
-                listen += "ssl_password_file={}&".format(self.ssl_password_file)
+                listen += f"ssl_password_file={self.ssl_password_file}&"
             listen = listen[:-1]
         else:
             listen = str(port)
@@ -234,7 +234,7 @@ def wait_until_started(self):
                     elif ans in ('loading',):
                         continue
                     else:
-                        raise Exception("Strange output for `box.info.status`: %s" % (ans))
+                        raise Exception(f"Strange output for `box.info.status`: {ans}")
             except socket.error as exc:
                 if exc.errno == errno.ECONNREFUSED:
                     time.sleep(0.1)

test/suites/test_connection.py

@@ -61,7 +61,7 @@ def my_ext_type_encoder(obj):
             if isinstance(obj, decimal.Decimal):
                 obj = obj + 1
                 return msgpack.ExtType(ext_decimal.EXT_ID, ext_decimal.encode(obj, None))
-            raise TypeError("Unknown type: %r" % (obj,))
+            raise TypeError(f"Unknown type: {repr(obj)}")
 
         def my_packer_factory(_):
             return msgpack.Packer(default=my_ext_type_encoder)
@@ -92,7 +92,7 @@ def test_custom_unpacker(self):
         def my_ext_type_decoder(code, data):
             if code == ext_decimal.EXT_ID:
                 return ext_decimal.decode(data, None) - 1
-            raise NotImplementedError("Unknown msgpack extension type code %d" % (code,))
+            raise NotImplementedError(f"Unknown msgpack extension type code {code}")
 
         def my_unpacker_factory(_):
             if msgpack.version >= (1, 0, 0):
@@ -127,13 +127,13 @@ def my_unpacker_factory(_):
         data = bytes(bytearray.fromhex(data_hex))
         space = 'space_varbin'
 
-        self.con.execute("""
-            INSERT INTO "%s" VALUES (%d, x'%s');
-        """ % (space, data_id, data_hex))
+        self.con.execute(f"""
+            INSERT INTO "{space}" VALUES ({data_id}, x'{data_hex}');
+        """)
 
-        resp = self.con.execute("""
-            SELECT * FROM "%s" WHERE "varbin" == x'%s';
-        """ % (space, data_hex))
+        resp = self.con.execute(f"""
+            SELECT * FROM "{space}" WHERE "varbin" == x'{data_hex}';
+        """)
         self.assertSequenceEqual(resp, [[data_id, data]])
 
     def test_custom_unpacker_supersedes_use_list(self):

test/suites/test_dbapi.py

@@ -12,11 +12,11 @@
 class TestSuiteDBAPI(dbapi20.DatabaseAPI20Test):
     table_prefix = 'dbapi20test_'  # If you need to specify a prefix for tables
 
-    ddl0 = 'create table %s (id INTEGER PRIMARY KEY AUTOINCREMENT, ' \
+    ddl0 = f'create table {table_prefix} (id INTEGER PRIMARY KEY AUTOINCREMENT, ' \
            'name varchar(20))'
-    ddl1 = 'create table %sbooze (name varchar(20) primary key)' % table_prefix
-    ddl2 = 'create table %sbarflys (name varchar(20) primary key, ' \
-           'drink varchar(30))' % table_prefix
+    ddl1 = f'create table {table_prefix}booze (name varchar(20) primary key)'
+    ddl2 = f'create table {table_prefix}barflys (name varchar(20) primary key, ' \
+           'drink varchar(30))'
 
     @classmethod
     def setUpClass(self):
@@ -57,14 +57,12 @@ def test_rowcount(self):
                 'cursor.rowcount should be -1 or 1 after executing no-result '
                 'statements' + str(cur.rowcount)
                 )
-            cur.execute("%s into %sbooze values ('Victoria Bitter')" % (
-                self.insert, self.table_prefix
-                ))
+            cur.execute(f"{self.insert} into {self.table_prefix}booze values ('Victoria Bitter')")
             dbapi20._failUnless(self,cur.rowcount == 1,
                 'cursor.rowcount should == number or rows inserted, or '
                 'set to -1 after executing an insert statement'
                 )
-            cur.execute("select name from %sbooze" % self.table_prefix)
+            cur.execute(f"select name from {self.table_prefix}booze")
             dbapi20._failUnless(self,cur.rowcount == -1,
                 'cursor.rowcount should == number of rows returned, or '
                 'set to -1 after executing a select statement'