Use lazy formatting with logging

Author: VirxEC

rlbot/interface.py

@@ -84,7 +84,7 @@ def send_bytes(self, data: bytes, data_type: SocketDataType):
         size = len(data)
         if size > MAX_SIZE_2_BYTES:
             self.logger.error(
-                f"Couldn't send a {data_type} message because it was too big!"
+                "Couldn't send a %s message because it was too big!", data_type
             )
             return
 
@@ -141,8 +141,10 @@ def run_after_connect(
             self.on_connect_handlers.append(handler)
             try:
                 self.connect_and_run(False, False, False, True, rlbot_server_port)
-            except timeout:
-                raise TimeoutError("Took too long to connect to the RLBot executable!")
+            except timeout as e:
+                raise TimeoutError(
+                    "Took too long to connect to the RLBot executable!"
+                ) from e
 
     def connect_and_run(
         self,
@@ -170,7 +172,9 @@ def connect_and_run(
         self.socket.settimeout(None)
         self.is_connected = True
         self.logger.info(
-            f"Socket manager connected to port {rlbot_server_port} from port {self.socket.getsockname()[1]}!"
+            "Socket manager connected to port %s from port %s!",
+            rlbot_server_port,
+            self.socket.getsockname()[1],
         )
 
         for handler in self.on_connect_handlers:
@@ -200,13 +204,16 @@ def handle_incoming_messages(self):
                     self.handle_incoming_message(incoming_message)
                 except flat.InvalidFlatbuffer as e:
                     self.logger.error(
-                        f"Error while unpacking message of type {incoming_message.type.name} "
-                        f"({len(incoming_message.data)} bytes): {e}"
+                        "Error while unpacking message of type %s (%s bytes): %s",
+                        incoming_message.type.name,
+                        len(incoming_message.data),
+                        e,
                     )
                 except Exception as e:
                     self.logger.warning(
-                        "Unexpected error while handling message of type "
-                        f"{incoming_message.type.name}: {e}"
+                        "Unexpected error while handling message of type %s: %s",
+                        incoming_message.type.name,
+                        e,
                     )
         except:
             self.logger.error("Socket manager disconnected unexpectedly!")

rlbot/managers/bot.py

@@ -35,7 +35,7 @@ def __init__(self):
             self.logger.warning("RLBOT_SPAWN_IDS environment variable not set")
         else:
             self.spawn_id = int(spawn_id)
-            self.logger.info(f"Spawn ID: {self.spawn_id}")
+            self.logger.info("Spawn ID: %s", self.spawn_id)
 
         self._game_interface = SocketRelay(logger=self.logger)
         self._game_interface.match_settings_handlers.append(self._handle_match_settings)
@@ -55,7 +55,7 @@ def _initialize_agent(self):
             self.initialize_agent()
         except Exception as e:
             self.logger.critical(
-                f"Bot {self.name} failed to initialize due the following error: {e}"
+                "Bot %s failed to initialize due the following error: %s", self.name, e
             )
             print_exc()
             exit()
@@ -131,7 +131,7 @@ def _handle_packet(self, packet: flat.GameTickPacket):
         try:
             controller = self.get_output(packet)
         except Exception as e:
-            self.logger.error(f"Bot {self.name} returned an error to RLBot: {e}")
+            self.logger.error("Bot %s returned an error to RLBot: %s", self.name, e)
             print_exc()
             return
 
@@ -191,11 +191,9 @@ def initialize_agent(self):
 
         NOTE: `self.index` is not set at this point, and should not be used. `self.team` and `self.name` _are_ set with correct information.
         """
-        pass
 
     def retire(self):
         """Called after the game ends"""
-        pass
 
     def get_output(self, game_tick_packet: flat.GameTickPacket) -> flat.ControllerState:
         """

rlbot/managers/hivemind.py

@@ -35,7 +35,7 @@ def __init__(self):
         if spawn_ids is None:
             self._logger.warning("RLBOT_SPAWN_IDS environment variable not set")
         else:
-            self._logger.info(f"Spawn ID: {spawn_ids}")
+            self._logger.info("Spawn ID: %s", spawn_ids)
             self.spawn_ids = [int(id) for id in spawn_ids.split(",")]
 
         self._game_interface = SocketRelay(logger=self._logger)
@@ -104,7 +104,7 @@ def _handle_packet(self, packet: flat.GameTickPacket):
             controller = self.get_outputs(packet)
         except Exception as e:
             self._logger.error(
-                f"Hivemind (with {self.names}) returned an error to RLBot: {e}"
+                "Hivemind (with %s) returned an error to RLBot: %s", self.names, e
             )
             print_exc()
             return
@@ -182,12 +182,12 @@ def initialize_agent(self):
         """
         Called for all heaver initialization that needs to happen.
         Field info and match settings are fully loaded at this point, and won't return garbage data.
+
+        NOTE: `self.index` is not set at this point, and should not be used. `self.team` and `self.name` _are_ set with correct information.
         """
-        pass
 
     def retire(self):
         """Called after the game ends"""
-        pass
 
     def get_outputs(
         self, game_tick_packet: flat.GameTickPacket

rlbot/managers/match.py

@@ -39,7 +39,7 @@ def ensure_server_started(self, print_version_info: bool = True):
             self.main_executable_name
         )
         if self.rlbot_server_process is not None:
-            self.logger.info(f"Already have {self.main_executable_name} running!")
+            self.logger.info("Already have %s running!", self.main_executable_name)
             return
 
         if self.main_executable_path is None:
@@ -52,7 +52,9 @@ def ensure_server_started(self, print_version_info: bool = True):
         self.rlbot_server_process = psutil.Process(rlbot_server_process.pid)
 
         self.logger.info(
-            f"Started {self.main_executable_name} with process id {self.rlbot_server_process.pid}"
+            "Started %s with process id %s",
+            self.main_executable_name,
+            self.rlbot_server_process.pid,
         )
 
     def _packet_reporter(self, packet: flat.GameTickPacket):
@@ -112,20 +114,22 @@ def shut_down(self, ensure_shutdown=True):
 
             if self.rlbot_server_process is not None:
                 self.logger.info(
-                    f"Waiting for {self.main_executable_name} to shut down..."
+                    "Waiting for %s to shut down...", self.main_executable_name
                 )
 
                 if ensure_shutdown:
                     if i == 1:
                         self.rlbot_server_process.terminate()
                     elif i == 4 or i == 7:
                         self.logger.warning(
-                            f"{self.main_executable_name} is not responding to terminate requests."
+                            "%s is not responding to terminate requests.",
+                            self.main_executable_name,
                         )
                         self.rlbot_server_process.terminate()
                     elif i >= 10 and i % 3 == 1:
                         self.logger.error(
-                            f"{self.main_executable_name} is not responding, forcefully killing."
+                            "%s is not responding, forcefully killing.",
+                            self.main_executable_name,
                         )
                         self.rlbot_server_process.kill()
 

rlbot/managers/script.py

@@ -92,4 +92,3 @@ def handle_packet(self, packet: flat.GameTickPacket):
 
     def retire(self):
         """Called after the game ends"""
-        pass

rlbot/utils/gateway.py

@@ -72,7 +72,7 @@ def launch(
 
     port = find_open_server_port()
     args = str(path) + " " + str(port)
-    DEFAULT_LOGGER.info(f"Launching RLBotServer with via {args}")
+    DEFAULT_LOGGER.info("Launching RLBotServer with via %s", args)
 
     return subprocess.Popen(args, shell=True, cwd=directory), port
 
@@ -97,7 +97,9 @@ def find_server_process(
             return proc, port
         except Exception as e:
             logger.error(
-                f"Failed to read the name of a process while hunting for {main_executable_name}: {e}"
+                "Failed to read the name of a process while hunting for %s: %s",
+                main_executable_name,
+                e,
             )
 
     return None, RLBOT_SERVER_PORT

rlbot/utils/os_detector.py

@@ -21,4 +21,4 @@ class OS(IntEnum):
         MAIN_EXECUTABLE_NAME = ""
         CURRENT_OS = OS.UNKNOWN
 
-        get_logger("os_detector").warn(f"Unknown OS: {unknown_os}")
+        get_logger("os_detector").warning("Unknown OS: %s", unknown_os)