lint: Convert %-formatted and .format(...) strings to f-strings with flynt.

As the output of flynt produces something that black would like to reformat,
we need to manually rerun black after running flynt. It might not be ideal
to add flynt as a linter as we need to wait till flynt finshes to run black
fixing the potential errors.

Author: PIG208

tools/deploy

@@ -31,14 +31,14 @@ def pack(options: argparse.Namespace) -> None:
         print("tools/deploy: No main bot file specified.")
         sys.exit(1)
     if not os.path.isfile(options.config):
-        print("pack: Config file not found at path: {}.".format(options.config))
+        print(f"pack: Config file not found at path: {options.config}.")
         sys.exit(1)
     if not os.path.isdir(options.path):
-        print("pack: Bot folder not found at path: {}.".format(options.path))
+        print(f"pack: Bot folder not found at path: {options.path}.")
         sys.exit(1)
     main_path = os.path.join(options.path, options.main)
     if not os.path.isfile(main_path):
-        print("pack: Bot main file not found at path: {}.".format(main_path))
+        print(f"pack: Bot main file not found at path: {main_path}.")
         sys.exit(1)
 
     # Main logic for packing the bot.
@@ -55,17 +55,14 @@ def pack(options: argparse.Namespace) -> None:
     zip_file.write(options.config, "zuliprc")
     # Pack the config file for the botfarm.
     bot_config = textwrap.dedent(
-        """\
-        [deploy]
-        bot={}
+        f"""        [deploy]
+        bot={options.main}
         zuliprc=zuliprc
-        """.format(
-            options.main
-        )
+        """
     )
     zip_file.writestr("config.ini", bot_config)
     zip_file.close()
-    print("pack: Created zip file at: {}.".format(zip_file_path))
+    print(f"pack: Created zip file at: {zip_file_path}.")
 
 
 def check_common_options(options: argparse.Namespace) -> None:
@@ -83,7 +80,7 @@ def handle_common_response_without_data(
     return handle_common_response(
         response=response,
         operation=operation,
-        success_handler=lambda r: print("{}: {}".format(operation, success_message)),
+        success_handler=lambda r: print(f"{operation}: {success_message}"),
     )
 
 
@@ -96,23 +93,23 @@ def handle_common_response(
             success_handler(response_data)
             return True
         elif response_data["status"] == "error":
-            print("{}: {}".format(operation, response_data["message"]))
+            print(f"{operation}: {response_data['message']}")
             return False
         else:
-            print("{}: Unexpected success response format".format(operation))
+            print(f"{operation}: Unexpected success response format")
             return False
     if response.status_code == requests.codes.unauthorized:
-        print("{}: Authentication error with the server. Aborting.".format(operation))
+        print(f"{operation}: Authentication error with the server. Aborting.")
     else:
-        print("{}: Error {}. Aborting.".format(operation, response.status_code))
+        print(f"{operation}: Error {response.status_code}. Aborting.")
     return False
 
 
 def upload(options: argparse.Namespace) -> None:
     check_common_options(options)
     file_path = os.path.join(bots_dir, options.botname + ".zip")
     if not os.path.exists(file_path):
-        print("upload: Could not find bot package at {}.".format(file_path))
+        print(f"upload: Could not find bot package at {file_path}.")
         sys.exit(1)
     files = {"file": open(file_path, "rb")}
     headers = {"key": options.token}
@@ -129,9 +126,9 @@ def clean(options: argparse.Namespace) -> None:
     file_path = os.path.join(bots_dir, options.botname + ".zip")
     if os.path.exists(file_path):
         os.remove(file_path)
-        print("clean: Removed {}.".format(file_path))
+        print(f"clean: Removed {file_path}.")
     else:
-        print("clean: File '{}' not found.".format(file_path))
+        print(f"clean: File '{file_path}' not found.")
 
 
 def process(options: argparse.Namespace) -> None:
@@ -229,7 +226,7 @@ def print_bots(bots: List[Any], pretty_print: bool) -> None:
         print_bots_pretty(bots)
     else:
         for bot in bots:
-            print("{}\t{}\t{}\t{}".format(bot["name"], bot["status"], bot["email"], bot["site"]))
+            print(f"{bot['name']}\t{bot['status']}\t{bot['email']}\t{bot['site']}")
 
 
 def print_bots_pretty(bots: List[Any]) -> None:
@@ -341,7 +338,7 @@ To list user's bots, use:
     if options.command in commands:
         commands[options.command](options)
     else:
-        print("tools/deploy: No command '{}' found.".format(options.command))
+        print(f"tools/deploy: No command '{options.command}' found.")
 
 
 if __name__ == "__main__":

tools/provision

@@ -41,7 +41,7 @@ the Python version this command is executed with."""
     # The output has the format "Python 1.2.3"
     py_version_list = py_version_output.split()[1].split(".")
     py_version = tuple(int(num) for num in py_version_list[0:2])
-    venv_name = "zulip-api-py{}-venv".format(py_version[0])
+    venv_name = f"zulip-api-py{py_version[0]}-venv"
 
     if py_version <= (3, 1) and (not options.force):
         print(

tools/release-packages

@@ -25,21 +25,14 @@ def cd(newdir):
 
 
 def _generate_dist(dist_type, setup_file, package_name, setup_args):
-    message = "Generating {dist_type} for {package_name}.".format(
-        dist_type=dist_type,
-        package_name=package_name,
-    )
+    message = f"Generating {dist_type} for {package_name}."
     print(crayons.white(message, bold=True))
 
     setup_dir = os.path.dirname(setup_file)
     with cd(setup_dir):
         setuptools.sandbox.run_setup(setup_file, setup_args)
 
-    message = "{dist_type} for {package_name} generated under {dir}.\n".format(
-        dist_type=dist_type,
-        package_name=package_name,
-        dir=setup_dir,
-    )
+    message = f"{dist_type} for {package_name} generated under {setup_dir}.\n"
     print(crayons.green(message, bold=True))
 
 
@@ -62,11 +55,11 @@ def cleanup(package_dir):
     build_dir = os.path.join(package_dir, "build")
     temp_dir = os.path.join(package_dir, "temp")
     dist_dir = os.path.join(package_dir, "dist")
-    egg_info = os.path.join(package_dir, "{}.egg-info".format(os.path.basename(package_dir)))
+    egg_info = os.path.join(package_dir, f"{os.path.basename(package_dir)}.egg-info")
 
     def _rm_if_it_exists(directory):
         if os.path.isdir(directory):
-            print(crayons.green("Removing {}/*".format(directory), bold=True))
+            print(crayons.green(f"Removing {directory}/*", bold=True))
             shutil.rmtree(directory)
 
     _rm_if_it_exists(build_dir)
@@ -91,7 +84,7 @@ def set_variable(fp, variable, value):
     os.remove(fp)
     shutil.move(temp_abs_path, fp)
 
-    message = "Set {variable} in {fp} to {value}.".format(fp=fp, variable=variable, value=value)
+    message = f"Set {variable} in {fp} to {value}."
     print(crayons.white(message, bold=True))
 
 
@@ -122,8 +115,8 @@ def update_requirements_in_zulip_repo(zulip_repo_dir, version, hash_or_tag):
     _edit_reqs_file(prod, zulip_bots_line, zulip_line)
     _edit_reqs_file(dev, zulip_bots_line, zulip_line)
 
-    editable_zulip = '-e "{}"\n'.format(url_zulip.rstrip())
-    editable_zulip_bots = '-e "{}"\n'.format(url_zulip_bots.rstrip())
+    editable_zulip = f'-e "{url_zulip.rstrip()}"\n'
+    editable_zulip_bots = f'-e "{url_zulip_bots.rstrip()}"\n'
 
     _edit_reqs_file(
         common,

tools/review

@@ -35,15 +35,15 @@ def check_git_pristine() -> None:
 def ensure_on_clean_master() -> None:
     branch = get_git_branch()
     if branch != "master":
-        exit("You are still on a feature branch: %s" % (branch,))
+        exit(f"You are still on a feature branch: {branch}")
     check_git_pristine()
     run("git fetch upstream master")
     run("git rebase upstream/master")
 
 
 def create_pull_branch(pull_id: int) -> None:
     run("git fetch upstream pull/%d/head" % (pull_id,))
-    run("git checkout -B review-%s FETCH_HEAD" % (pull_id,))
+    run(f"git checkout -B review-{pull_id} FETCH_HEAD")
     run("git rebase upstream/master")
     run("git log upstream/master.. --oneline")
     run("git diff upstream/master.. --name-status")

tools/run-mypy

@@ -207,7 +207,7 @@ if args.quick:
 # run mypy
 status = 0
 for repo, python_files in repo_python_files.items():
-    print("Running mypy for `{}`.".format(repo), flush=True)
+    print(f"Running mypy for `{repo}`.", flush=True)
     if python_files:
         result = subprocess.call([mypy_command] + extra_args + python_files)
         if result != 0:

tools/server_lib/test_handler.py

@@ -11,7 +11,7 @@
 
 
 def handle_input_and_run_tests_for_package(package_name, path_list):
-    parser = argparse.ArgumentParser(description="Run tests for {}.".format(package_name))
+    parser = argparse.ArgumentParser(description=f"Run tests for {package_name}.")
     parser.add_argument(
         "--coverage",
         nargs="?",
@@ -31,7 +31,7 @@ def handle_input_and_run_tests_for_package(package_name, path_list):
     )
     options = parser.parse_args()
 
-    test_session_title = " Running tests for {} ".format(package_name)
+    test_session_title = f" Running tests for {package_name} "
     header = test_session_title.center(shutil.get_terminal_size().columns, "#")
     print(header)
 

zulip/integrations/bridge_between_zulips/run-interrealm-bridge

@@ -43,7 +43,7 @@ def create_pipe_event(
                 "type": "stream",
                 "to": to_bot["stream"],
                 "subject": subject,
-                "content": "**{}**: {}".format(msg["sender_full_name"], msg["content"]),
+                "content": f"**{msg['sender_full_name']}**: {msg['content']}",
                 "has_attachment": msg.get("has_attachment", False),
                 "has_image": msg.get("has_image", False),
                 "has_link": msg.get("has_link", False),

zulip/integrations/bridge_with_irc/irc_mirror_backend.py

@@ -46,7 +46,7 @@ def connect(self, *args: Any, **kwargs: Any) -> None:
     def check_subscription_or_die(self) -> None:
         resp = self.zulip_client.get_subscriptions()
         if resp["result"] != "success":
-            print("ERROR: %s" % (resp["msg"],))
+            print(f"ERROR: {resp['msg']}")
             exit(1)
         subs = [s["name"] for s in resp["subscriptions"]]
         if self.stream not in subs:
@@ -61,7 +61,7 @@ def on_nicknameinuse(self, c: ServerConnection, e: Event) -> None:
 
     def on_welcome(self, c: ServerConnection, e: Event) -> None:
         if len(self.nickserv_password) > 0:
-            msg = "identify %s" % (self.nickserv_password,)
+            msg = f"identify {self.nickserv_password}"
             c.privmsg("NickServ", msg)
         c.join(self.channel)
 
@@ -75,7 +75,7 @@ def forward_to_irc(msg: Dict[str, Any]) -> None:
                 in_the_specified_stream = msg["display_recipient"] == self.stream
                 at_the_specified_subject = msg["subject"].casefold() == self.topic.casefold()
                 if in_the_specified_stream and at_the_specified_subject:
-                    msg["content"] = ("@**%s**: " % (msg["sender_full_name"],)) + msg["content"]
+                    msg["content"] = f"@**{msg['sender_full_name']}**: " + msg["content"]
                     send = lambda x: self.c.privmsg(self.channel, x)
                 else:
                     return
@@ -126,7 +126,7 @@ def on_pubmsg(self, c: ServerConnection, e: Event) -> None:
                     "type": "stream",
                     "to": self.stream,
                     "subject": self.topic,
-                    "content": "**{}**: {}".format(sender, content),
+                    "content": f"**{sender}**: {content}",
                 }
             )
         )

zulip/integrations/bridge_with_matrix/matrix_bridge.py

@@ -77,7 +77,7 @@ def _matrix_to_zulip(room: Any, event: Dict[str, Any]) -> None:
         """
         content = get_message_content_from_event(event, no_noise)
 
-        zulip_bot_user = "@%s:matrix.org" % (matrix_config["username"],)
+        zulip_bot_user = f"@{matrix_config['username']}:matrix.org"
         # We do this to identify the messages generated from Zulip -> Matrix
         # and we make sure we don't forward it again to the Zulip stream.
         not_from_zulip_bot = event["sender"] != zulip_bot_user
@@ -228,9 +228,7 @@ def read_configuration(config_file: str) -> Dict[str, Dict[str, str]]:
 
 def write_sample_config(target_path: str, zuliprc: Optional[str]) -> None:
     if os.path.exists(target_path):
-        raise Bridge_ConfigException(
-            "Path '{}' exists; not overwriting existing file.".format(target_path)
-        )
+        raise Bridge_ConfigException(f"Path '{target_path}' exists; not overwriting existing file.")
 
     sample_dict = OrderedDict(
         (
@@ -262,7 +260,7 @@ def write_sample_config(target_path: str, zuliprc: Optional[str]) -> None:
 
     if zuliprc is not None:
         if not os.path.exists(zuliprc):
-            raise Bridge_ConfigException("Zuliprc file '{}' does not exist.".format(zuliprc))
+            raise Bridge_ConfigException(f"Zuliprc file '{zuliprc}' does not exist.")
 
         zuliprc_config = configparser.ConfigParser()
         try:
@@ -293,10 +291,10 @@ def main() -> None:
         try:
             write_sample_config(options.sample_config, options.zuliprc)
         except Bridge_ConfigException as exception:
-            print("Could not write sample config: {}".format(exception))
+            print(f"Could not write sample config: {exception}")
             sys.exit(1)
         if options.zuliprc is None:
-            print("Wrote sample configuration to '{}'".format(options.sample_config))
+            print(f"Wrote sample configuration to '{options.sample_config}'")
         else:
             print(
                 "Wrote sample configuration to '{}' using zuliprc file '{}'".format(
@@ -312,7 +310,7 @@ def main() -> None:
     try:
         config = read_configuration(options.config)
     except Bridge_ConfigException as exception:
-        print("Could not parse config file: {}".format(exception))
+        print(f"Could not parse config file: {exception}")
         sys.exit(1)
 
     # Get config for each client
@@ -347,11 +345,11 @@ def main() -> None:
             zulip_client.call_on_each_message(zulip_to_matrix(zulip_config, room))
 
         except Bridge_FatalMatrixException as exception:
-            sys.exit("Matrix bridge error: {}".format(exception))
+            sys.exit(f"Matrix bridge error: {exception}")
         except Bridge_ZulipFatalException as exception:
-            sys.exit("Zulip bridge error: {}".format(exception))
+            sys.exit(f"Zulip bridge error: {exception}")
         except zulip.ZulipError as exception:
-            sys.exit("Zulip error: {}".format(exception))
+            sys.exit(f"Zulip error: {exception}")
         except Exception:
             traceback.print_exc()
         backoff.fail()

zulip/integrations/bridge_with_matrix/test_matrix.py

@@ -49,14 +49,14 @@ def test_no_args(self) -> None:
         output_lines = self.output_from_script([])
         expected_lines = [
             "Options required: -c or --config to run, OR --write-sample-config.",
-            "usage: {} [-h]".format(script_file),
+            f"usage: {script_file} [-h]",
         ]
         for expected, output in zip(expected_lines, output_lines):
             self.assertIn(expected, output)
 
     def test_help_usage_and_description(self) -> None:
         output_lines = self.output_from_script(["-h"])
-        usage = "usage: {} [-h]".format(script_file)
+        usage = f"usage: {script_file} [-h]"
         description = "Script to bridge"
         self.assertIn(usage, output_lines[0])
         blank_lines = [num for num, line in enumerate(output_lines) if line == ""]
@@ -71,7 +71,7 @@ def test_write_sample_config(self) -> None:
         with new_temp_dir() as tempdir:
             path = os.path.join(tempdir, sample_config_path)
             output_lines = self.output_from_script(["--write-sample-config", path])
-            self.assertEqual(output_lines, ["Wrote sample configuration to '{}'".format(path)])
+            self.assertEqual(output_lines, [f"Wrote sample configuration to '{path}'"])
 
             with open(path) as sample_file:
                 self.assertEqual(sample_file.read(), sample_config_text)
@@ -103,9 +103,9 @@ def test_write_sample_config_from_zuliprc(self) -> None:
             with open(path) as sample_file:
                 sample_lines = [line.strip() for line in sample_file.readlines()]
                 expected_lines = sample_config_text.split("\n")
-                expected_lines[7] = "email = {}".format(zulip_params["email"])
-                expected_lines[8] = "api_key = {}".format(zulip_params["key"])
-                expected_lines[9] = "site = {}".format(zulip_params["site"])
+                expected_lines[7] = f"email = {zulip_params['email']}"
+                expected_lines[8] = f"api_key = {zulip_params['key']}"
+                expected_lines[9] = f"site = {zulip_params['site']}"
                 self.assertEqual(sample_lines, expected_lines[:-1])
 
     def test_detect_zuliprc_does_not_exist(self) -> None: