@@ 4,7 4,7 @@ from base64 import decodebytes
 def get_ident(client_reader, client_writer, user=None):
     client = client_writer.get_extra_info("peername")[0]
     if user:
-        client = "%s@%s" % (user, client)
+        client = f"{user}@{client}"
     return {"id": hex(id(client_reader))[-6:], "client": client}
 
 

          

@@ 22,7 22,7 @@ async def relay_stream(
                 " ".join([str(arg) for arg in ex.args]),
             )
             logger.debug(
-                ("[{id}][{client}]: %s" % error_message).format(**ident)
+                f"[{ident['id']}][{ident['client']}]: {error_message}"
             )
             break
         else:

          
@@ 46,10 46,8 @@ async def process_https(
         client_writer.write(b"\r\n")
         # HTTPS need to log here, as the connection may keep alive for long.
         logger.info(
-            (
-                "[{id}][{client}]: %s %d %s"
-                % (request_method, response_code, uri)
-            ).format(**ident)
+            f"[{ident['id']}][{ident['client']}]: "
+            f"{request_method} {response_code} {uri}"
         )
 
         tasks = [

          
@@ 67,12 65,11 @@ async def process_https(
             ex.__class__.__name__,
             " ".join([str(arg) for arg in ex.args]),
         )
+
     if error_message:
         logger.error(
-            (
-                "[{id}][{client}]: %s %d %s (%s)"
-                % (request_method, response_code, uri, error_message)
-            ).format(**ident)
+            f"[{ident['id']}][{ident['client']}]: "
+            f"{request_method} {response_code} {uri} ({error_message})"
         )
 
 

          
@@ 119,21 116,19 @@ async def process_http(
 
     path = uri[len(hostname) + 7 :]  # 7 is len('http://')
     new_head = " ".join([request_method, path, http_version])
-
     host, port = get_host_and_port(hostname, 80)
-
     try:
         req_reader, req_writer = await asyncio.open_connection(
             host, port, flags=TCP_NODELAY
         )
-        req_writer.write(("%s\r\n" % new_head).encode())
+        req_writer.write(f"{new_head}\r\n".encode())
         await req_writer.drain()
 
-        req_writer.write(b"Host: " + hostname.encode())
+        req_writer.write(f"Host: {hostname}".encode())
         req_writer.write(b"\r\n")
 
         [
-            req_writer.write((header + "\r\n").encode())
+            req_writer.write(f"{header}\r\n".encode())
             for header in request_headers
         ]
         req_writer.write(b"\r\n")

          
@@ 155,20 150,17 @@ async def process_http(
 
     if response_code is None:
         response_code = int(response_status.decode("ascii").split(" ")[1])
+
     logger = get_logger()
     if error_message is None:
         logger.info(
-            (
-                "[{id}][{client}]: %s %d %s"
-                % (request_method, response_code, uri)
-            ).format(**ident)
+            f"[{ident['id']}][{ident['client']}]: "
+            f"{request_method} {response_code} {uri}"
         )
     else:
         logger.error(
-            (
-                "[{id}][{client}]: %s %d %s (%s)"
-                % (request_method, response_code, uri, error_message)
-            ).format(**ident)
+            f"[{ident['id']}][{ident['client']}]: "
+            f"{request_method} {response_code} {uri} ({error_message})"
         )
 
 

          
@@ 200,14 192,11 @@ async def process_request(client_reader,
         while len(payload) < content_length:
             payload += await client_reader.read(1024)
     except Exception as ex:
+        name = ex.__class__.__name__
+        args = " ".join([str(arg) for arg in ex.args])
         logger.debug(
-            (
-                "[{id}][{client}]: !!! Task reject (%s: %s)"
-                % (
-                    ex.__class__.__name__,
-                    " ".join([str(arg) for arg in ex.args]),
-                )
-            ).format(**ident)
+            f"[{ident['id']}][{ident['client']}]: "
+            f"!!! Task reject ({name}: {args})"
         )
 
     if header:

          

@@ 24,8 24,9 @@ def main():
     port and provides `--help` message.
     """
     parser = ArgumentParser(
-        description="Wormhole(%s): Asynchronous IO HTTP and HTTPS Proxy"
-        % VERSION
+        description=(
+            f"Wormhole({VERSION}): Asynchronous IO HTTP and HTTPS Proxy"
+        )
     )
     parser.add_argument(
         "-H",

          
@@ 86,7 87,7 @@ def main():
     except ImportError:
         pass
     else:
-        logger.debug("[000000][%s]: Using event loop from uvloop." % args.host)
+        logger.debug(f"[000000][{args.host}]: Using event loop from uvloop.")
         asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
     loop = asyncio.new_event_loop()
     try:

          

@@ 38,10 38,9 @@ def debug_wormhole_semaphore(client_read
     available = wormhole_semaphore._value
     logger = get_logger()
     logger.debug(
-        (
-            "[{id}][{client}]: Resource available: %.2f%% (%d/%d)"
-            % (100 * float(available) / MAX_TASKS, available, MAX_TASKS)
-        ).format(**ident)
+        f"[{ident['id']}][{ident['client']}]: "
+        "Resource available: "
+        f"{100 * available / MAX_TASKS:.2f}% ({available}/{MAX_TASKS})"
     )
 
 

          
@@ 54,9 53,8 @@ async def process_wormhole(client_reader
     )
     if not request_line:
         logger.debug(
-            ("[{id}][{client}]: !!! Task reject (empty request)").format(
-                **ident
-            )
+            f"[{ident['id']}][{ident['client']}]: "
+            "!!! Task reject (empty request)"
         )
         return
 

          
@@ 68,9 66,8 @@ async def process_wormhole(client_reader
         request_method, uri, http_version = request_fields
     else:
         logger.debug(
-            ("[{id}][{client}]: !!! Task reject (invalid request)").format(
-                **ident
-            )
+            f"[{ident['id']}][{ident['client']}]: "
+            "!!! Task reject (invalid request)"
         )
         return
 

          
@@ 78,9 75,8 @@ async def process_wormhole(client_reader
         user_ident = await verify(client_reader, client_writer, headers, auth)
         if user_ident is None:
             logger.info(
-                ("[{id}][{client}]: %s 407 %s" % (request_method, uri)).format(
-                    **ident
-                )
+                f"[{ident['id']}][{ident['client']}]: "
+                f"{request_method} 407 {uri}"
             )
             return
         ident = user_ident

          
@@ 129,13 125,11 @@ def accept_client(client_reader, client_
         del clients[task]
         client_writer.close()
         logger.debug(
-            (
-                "[{id}][{client}]: Connection closed (%.5f seconds)"
-                % (time() - started_time)
-            ).format(**ident)
+            f"[{ident['id']}][{ident['client']}]: "
+            f"Connection closed ({time() - started_time:.5f} seconds)"
         )
 
-    logger.debug(("[{id}][{client}]: Connection started").format(**ident))
+    logger.debug(f"[{ident['id']}][{ident['client']}]: Connection started")
     task.add_done_callback(client_done)
 
 

          
@@ 146,12 140,10 @@ async def start_wormhole_server(host, po
         server = await asyncio.start_server(accept, host, port)
     except OSError as ex:
         logger.critical(
-            "[000000][%s]: !!! Failed to bind server at [%s:%d]: %s"
-            % (host, host, port, ex.args[1])
+            f"[000000][{host}]: "
+            f"!!! Failed to bind server at [{host}:{port}]: {ex.args[1]}"
         )
         raise
     else:
-        logger.info(
-            "[000000][%s]: wormhole bound at %s:%d" % (host, host, port)
-        )
+        logger.info(f"[000000][{host}]: wormhole bound at {host}:{port}")
         return server