xenofem/python-zulip-api
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

pyupgrade: Reformat with --py36-plus.

Browse source 
This includes mainly fixes of string literals using f-strings or
.format(...), as well as unpacking of list comprehensions.
This commit is contained in:
PIG208 2021-05-28 19:19:40 +08:00 committed by Tim Abbott
parent e27ac0ddbe
commit 9ce7c52a10
78 changed files with 356 additions and 389 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
tools/custom_check.py
View file

@ -13,7 +13,7 @@ whitespace_rules = [
] # type: List[Rule]
markdown_whitespace_rules = list(
[rule for rule in whitespace_rules if rule["pattern"] != r"\s+$"]
rule for rule in whitespace_rules if rule["pattern"] != r"\s+$"
) + [
# Two spaces trailing a line with other content is okay--it's a markdown line break.
# This rule finds one space trailing a non-space, three or more trailing spaces, and

24
tools/deploy
View file

@ -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.
@ -65,7 +65,7 @@ def pack(options: argparse.Namespace) -> None:
)
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 +83,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}"),
)
@ -99,12 +99,12 @@ def handle_common_response(
print("{}: {}".format(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
@ -112,7 +112,7 @@ 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 +129,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:
@ -341,7 +341,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__":

2
tools/provision
View file

@ -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(

10
tools/release-packages
View file

@ -62,11 +62,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 +91,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 +122,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,

4
tools/review
View file

@ -35,7 +35,7 @@ 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")
@ -43,7 +43,7 @@ def ensure_on_clean_master() -> None:
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")

2
tools/run-mypy
View file

@ -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:

4
tools/server_lib/test_handler.py
View file

@ -11,7 +11,7 @@ os.chdir(os.path.dirname(TOOLS_DIR))
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)

2
tools/test-bots
View file

@ -97,7 +97,7 @@ def main():
if options.pytest:
excluded_bots = ["merels"]
pytest_bots_to_test = sorted([bot for bot in bots_to_test if bot not in excluded_bots])
pytest_bots_to_test = sorted(bot for bot in bots_to_test if bot not in excluded_bots)
pytest_options = [
"-s", # show output from tests; this hides the progress bar though
"-x", # stop on first test failure

8
zulip/integrations/bridge_with_irc/irc_mirror_backend.py
View file

@ -46,7 +46,7 @@ class IRCBot(irc.bot.SingleServerIRCBot):
def check_subscription_or_die(self) -> None:
resp = self.zulip_client.get_subscriptions()
if resp["result"] != "success":
print("ERROR: %s" % (resp["msg"],))
print("ERROR: {}".format(resp["msg"]))
exit(1)
subs = [s["name"] for s in resp["subscriptions"]]
if self.stream not in subs:
@ -61,7 +61,7 @@ class IRCBot(irc.bot.SingleServerIRCBot):
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 @@ class IRCBot(irc.bot.SingleServerIRCBot):
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"] = ("@**{}**: ".format(msg["sender_full_name"])) + msg["content"]
send = lambda x: self.c.privmsg(self.channel, x)
else:
return
@ -126,7 +126,7 @@ class IRCBot(irc.bot.SingleServerIRCBot):
"type": "stream",
"to": self.stream,
"subject": self.topic,
"content": "**{}**: {}".format(sender, content),
"content": f"**{sender}**: {content}",
}
)
)

20
zulip/integrations/bridge_with_matrix/matrix_bridge.py
View file

@ -77,7 +77,7 @@ def matrix_to_zulip(
"""
content = get_message_content_from_event(event, no_noise)
zulip_bot_user = "@%s:matrix.org" % (matrix_config["username"],)
zulip_bot_user = "@{}:matrix.org".format(matrix_config["username"])
# 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()

6
zulip/integrations/bridge_with_matrix/test_matrix.py
View file

@ -49,14 +49,14 @@ class MatrixBridgeScriptTests(TestCase):
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 @@ class MatrixBridgeScriptTests(TestCase):
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)

1
zulip/integrations/bridge_with_slack/run-slack-bridge
View file

@ -1,5 +1,4 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import argparse
import os

80
zulip/integrations/codebase/zulip_codebase_mirror
View file

@ -56,7 +56,7 @@ while len(json_implementations):
def make_api_call(path: str) -> Optional[List[Dict[str, Any]]]:
response = requests.get(
"https://api3.codebasehq.com/%s" % (path,),
f"https://api3.codebasehq.com/{path}",
auth=(config.CODEBASE_API_USERNAME, config.CODEBASE_API_KEY),
params={"raw": "True"},
headers={
@ -76,13 +76,13 @@ def make_api_call(path: str) -> Optional[List[Dict[str, Any]]]:
sys.exit(-1)
else:
logging.warn(
"Found non-success response status code: %s %s" % (response.status_code, response.text)
f"Found non-success response status code: {response.status_code} {response.text}"
)
return None
def make_url(path: str) -> str:
return "%s/%s" % (config.CODEBASE_ROOT_URL, path)
return f"{config.CODEBASE_ROOT_URL}/{path}"
def handle_event(event: Dict[str, Any]) -> None:
@ -102,11 +102,11 @@ def handle_event(event: Dict[str, Any]) -> None:
project_name = raw_props.get("name")
project_repo_type = raw_props.get("scm_type")
url = make_url("projects/%s" % (project_link,))
scm = "of type %s" % (project_repo_type,) if project_repo_type else ""
url = make_url(f"projects/{project_link}")
scm = f"of type {project_repo_type}" if project_repo_type else ""
subject = "Repository %s Created" % (project_name,)
content = "%s created a new repository %s [%s](%s)" % (actor_name, scm, project_name, url)
subject = f"Repository {project_name} Created"
content = f"{actor_name} created a new repository {scm} [{project_name}]({url})"
elif event_type == "push":
stream = config.ZULIP_COMMITS_STREAM_NAME
@ -117,14 +117,14 @@ def handle_event(event: Dict[str, Any]) -> None:
deleted_ref = raw_props.get("deleted_ref")
new_ref = raw_props.get("new_ref")
subject = "Push to %s on %s" % (branch, project)
subject = f"Push to {branch} on {project}"
if deleted_ref:
content = "%s deleted branch %s from %s" % (actor_name, branch, project)
content = f"{actor_name} deleted branch {branch} from {project}"
else:
if new_ref:
branch = "new branch %s" % (branch,)
content = "%s pushed %s commit(s) to %s in project %s:\n\n" % (
branch = f"new branch {branch}"
content = "{} pushed {} commit(s) to {} in project {}:\n\n".format(
actor_name,
num_commits,
branch,
@ -132,11 +132,9 @@ def handle_event(event: Dict[str, Any]) -> None:
)
for commit in raw_props.get("commits"):
ref = commit.get("ref")
url = make_url(
"projects/%s/repositories/%s/commit/%s" % (project_link, repo_link, ref)
)
url = make_url(f"projects/{project_link}/repositories/{repo_link}/commit/{ref}")
message = commit.get("message")
content += "* [%s](%s): %s\n" % (ref, url, message)
content += f"* [{ref}]({url}): {message}\n"
elif event_type == "ticketing_ticket":
stream = config.ZULIP_TICKETS_STREAM_NAME
@ -144,11 +142,11 @@ def handle_event(event: Dict[str, Any]) -> None:
name = raw_props.get("subject")
assignee = raw_props.get("assignee")
priority = raw_props.get("priority")
url = make_url("projects/%s/tickets/%s" % (project_link, num))
url = make_url(f"projects/{project_link}/tickets/{num}")
if assignee is None:
assignee = "no one"
subject = "#%s: %s" % (num, name)
subject = f"#{num}: {name}"
content = (
"""%s created a new ticket [#%s](%s) priority **%s** assigned to %s:\n\n~~~ quote\n %s"""
% (actor_name, num, url, priority, assignee, name)
@ -161,12 +159,12 @@ def handle_event(event: Dict[str, Any]) -> None:
body = raw_props.get("content")
changes = raw_props.get("changes")
url = make_url("projects/%s/tickets/%s" % (project_link, num))
subject = "#%s: %s" % (num, name)
url = make_url(f"projects/{project_link}/tickets/{num}")
subject = f"#{num}: {name}"
content = ""
if body is not None and len(body) > 0:
content = "%s added a comment to ticket [#%s](%s):\n\n~~~ quote\n%s\n\n" % (
content = "{} added a comment to ticket [#{}]({}):\n\n~~~ quote\n{}\n\n".format(
actor_name,
num,
url,
@ -175,7 +173,7 @@ def handle_event(event: Dict[str, Any]) -> None:
if "status_id" in changes:
status_change = changes.get("status_id")
content += "Status changed from **%s** to **%s**\n\n" % (
content += "Status changed from **{}** to **{}**\n\n".format(
status_change[0],
status_change[1],
)
@ -184,10 +182,10 @@ def handle_event(event: Dict[str, Any]) -> None:
name = raw_props.get("name")
identifier = raw_props.get("identifier")
url = make_url("projects/%s/milestone/%s" % (project_link, identifier))
url = make_url(f"projects/{project_link}/milestone/{identifier}")
subject = name
content = "%s created a new milestone [%s](%s)" % (actor_name, name, url)
content = f"{actor_name} created a new milestone [{name}]({url})"
elif event_type == "comment":
stream = config.ZULIP_COMMITS_STREAM_NAME
@ -198,12 +196,10 @@ def handle_event(event: Dict[str, Any]) -> None:
if commit:
repo_link = raw_props.get("repository_permalink")
url = make_url(
"projects/%s/repositories/%s/commit/%s" % (project_link, repo_link, commit)
)
url = make_url(f"projects/{project_link}/repositories/{repo_link}/commit/{commit}")
subject = "%s commented on %s" % (actor_name, commit)
content = "%s commented on [%s](%s):\n\n~~~ quote\n%s" % (
subject = f"{actor_name} commented on {commit}"
content = "{} commented on [{}]({}):\n\n~~~ quote\n{}".format(
actor_name,
commit,
url,
@ -215,13 +211,13 @@ def handle_event(event: Dict[str, Any]) -> None:
category = raw_props.get("category")
comment_content = raw_props.get("content")
subject = "Discussion: %s" % (subj,)
subject = f"Discussion: {subj}"
if category:
format_str = "%s started a new discussion in %s:\n\n~~~ quote\n%s\n~~~"
content = format_str % (actor_name, category, comment_content)
else:
content = "%s posted:\n\n~~~ quote\n%s\n~~~" % (actor_name, comment_content)
content = f"{actor_name} posted:\n\n~~~ quote\n{comment_content}\n~~~"
elif event_type == "deployment":
stream = config.ZULIP_COMMITS_STREAM_NAME
@ -233,19 +229,17 @@ def handle_event(event: Dict[str, Any]) -> None:
repo_link = raw_props.get("repository_permalink")
start_ref_url = make_url(
"projects/%s/repositories/%s/commit/%s" % (project_link, repo_link, start_ref)
)
end_ref_url = make_url(
"projects/%s/repositories/%s/commit/%s" % (project_link, repo_link, end_ref)
f"projects/{project_link}/repositories/{repo_link}/commit/{start_ref}"
)
end_ref_url = make_url(f"projects/{project_link}/repositories/{repo_link}/commit/{end_ref}")
between_url = make_url(
"projects/%s/repositories/%s/compare/%s...%s"
% (project_link, repo_link, start_ref, end_ref)
)
subject = "Deployment to %s" % (environment,)
subject = f"Deployment to {environment}"
content = "%s deployed [%s](%s) [through](%s) [%s](%s) to the **%s** environment." % (
content = "{} deployed [{}]({}) [through]({}) [{}]({}) to the **{}** environment.".format(
actor_name,
start_ref,
start_ref_url,
@ -256,7 +250,7 @@ def handle_event(event: Dict[str, Any]) -> None:
)
if servers is not None:
content += "\n\nServers deployed to: %s" % (
", ".join(["`%s`" % (server,) for server in servers])
", ".join(f"`{server}`" for server in servers)
)
elif event_type == "named_tree":
@ -270,7 +264,7 @@ def handle_event(event: Dict[str, Any]) -> None:
elif event_type == "sprint_ended":
logging.warn("Sprint notifications not yet implemented")
else:
logging.info("Unknown event type %s, ignoring!" % (event_type,))
logging.info(f"Unknown event type {event_type}, ignoring!")
if subject and content:
if len(subject) > 60:
@ -280,9 +274,9 @@ def handle_event(event: Dict[str, Any]) -> None:
{"type": "stream", "to": stream, "subject": subject, "content": content}
)
if res["result"] == "success":
logging.info("Successfully sent Zulip with id: %s" % (res["id"],))
logging.info("Successfully sent Zulip with id: {}".format(res["id"]))
else:
logging.warn("Failed to send Zulip: %s %s" % (res["result"], res["msg"]))
logging.warn("Failed to send Zulip: {} {}".format(res["result"], res["msg"]))
# the main run loop for this mirror script
@ -300,7 +294,7 @@ def run_mirror() -> None:
else:
since = datetime.fromtimestamp(float(timestamp), tz=pytz.utc)
except (ValueError, OSError) as e:
logging.warn("Could not open resume file: %s" % (str(e),))
logging.warn(f"Could not open resume file: {str(e)}")
since = default_since()
try:
@ -339,9 +333,7 @@ def check_permissions() -> None:
try:
open(config.RESUME_FILE, "a+")
except OSError as e:
sys.stderr.write(
"Could not open up the file %s for reading and writing" % (config.RESUME_FILE,)
)
sys.stderr.write(f"Could not open up the file {config.RESUME_FILE} for reading and writing")
sys.stderr.write(str(e))

14
zulip/integrations/git/post-receive
View file

@ -41,14 +41,14 @@ def git_repository_name() -> str:
def git_commit_range(oldrev: str, newrev: str) -> str:
log_cmd = ["git", "log", "--reverse", "--pretty=%aE %H %s", "%s..%s" % (oldrev, newrev)]
log_cmd = ["git", "log", "--reverse", "--pretty=%aE %H %s", f"{oldrev}..{newrev}"]
commits = ""
for ln in subprocess.check_output(log_cmd, universal_newlines=True).splitlines():
author_email, commit_id, subject = ln.split(None, 2)
if hasattr(config, "format_commit_message"):
commits += config.format_commit_message(author_email, subject, commit_id)
else:
commits += "!avatar(%s) %s\n" % (author_email, subject)
commits += f"!avatar({author_email}) {subject}\n"
return commits
@ -75,19 +75,19 @@ def send_bot_message(oldrev: str, newrev: str, refname: str) -> None:
removed = git_commit_range(newrev, oldrev)
if oldrev == "0000000000000000000000000000000000000000":
message = "`%s` was pushed to new branch `%s`" % (new_head, branch)
message = f"`{new_head}` was pushed to new branch `{branch}`"
elif newrev == "0000000000000000000000000000000000000000":
message = "branch `%s` was removed (was `%s`)" % (branch, old_head)
message = f"branch `{branch}` was removed (was `{old_head}`)"
elif removed:
message = "`%s` was pushed to `%s`, **REMOVING**:\n\n%s" % (new_head, branch, removed)
message = f"`{new_head}` was pushed to `{branch}`, **REMOVING**:\n\n{removed}"
if added:
message += "\n**and adding**:\n\n" + added
message += "\n**A HISTORY REWRITE HAS OCCURRED!**"
message += "\n@everyone: Please check your local branches to deal with this."
elif added:
message = "`%s` was deployed to `%s` with:\n\n%s" % (new_head, branch, added)
message = f"`{new_head}` was deployed to `{branch}` with:\n\n{added}"
else:
message = "`%s` was pushed to `%s`... but nothing changed?" % (new_head, branch)
message = f"`{new_head}` was pushed to `{branch}`... but nothing changed?"
message_data = {
"type": "stream",

4
zulip/integrations/git/zulip_git_config.py
View file

@ -25,7 +25,7 @@ ZULIP_API_KEY = "0123456789abcdef0123456789abcdef"
# And similarly for branch "test-post-receive" (for use when testing).
def commit_notice_destination(repo: str, branch: str, commit: str) -> Optional[Dict[str, str]]:
if branch in ["master", "test-post-receive"]:
return dict(stream=STREAM_NAME, subject="%s" % (branch,))
return dict(stream=STREAM_NAME, subject=f"{branch}")
# Return None for cases where you don't want a notice sent
return None
@ -37,7 +37,7 @@ def commit_notice_destination(repo: str, branch: str, commit: str) -> Optional[D
#
# return '!avatar(%s) [%s](https://example.com/commits/%s)\n' % (author, subject, commit_id)
def format_commit_message(author: str, subject: str, commit_id: str) -> str:
return "!avatar(%s) %s\n" % (author, subject)
return f"!avatar({author}) {subject}\n"
## If properly installed, the Zulip API should be in your import

4
zulip/integrations/google/google-calendar
View file

@ -174,9 +174,9 @@ def send_reminders() -> Optional[None]:
key = (id, start)
if key not in sent:
if start.hour == 0 and start.minute == 0:
line = "%s is today." % (summary,)
line = f"{summary} is today."
else:
line = "%s starts at %s" % (summary, start.strftime("%H:%M"))
line = "{} starts at {}".format(summary, start.strftime("%H:%M"))
print("Sending reminder:", line)
messages.append(line)
keys.add(key)

16
zulip/integrations/hg/zulip_changegroup.py
View file

@ -37,7 +37,7 @@ def format_summary_line(
revcount=revcount, s=plural, url=summary_url
)
else:
formatted_commit_count = "{revcount} commit{s}".format(revcount=revcount, s=plural)
formatted_commit_count = f"{revcount} commit{plural}"
return "**{user}** pushed {commits} to **{branch}** (`{tip}:{node}`):\n\n".format(
user=user, commits=formatted_commit_count, branch=branch, tip=tip, node=node[:12]
@ -60,9 +60,9 @@ def format_commit_lines(web_url: str, repo: repo, base: int, tip: int) -> str:
if web_url:
summary_url = rev_base_url + str(rev_ctx)
summary = "* [{summary}]({url})".format(summary=one_liner, url=summary_url)
summary = f"* [{one_liner}]({summary_url})"
else:
summary = "* {summary}".format(summary=one_liner)
summary = f"* {one_liner}"
commit_summaries.append(summary)
@ -95,7 +95,7 @@ def get_config(ui: ui, item: str) -> str:
# config returns configuration value.
return ui.config("zulip", item)
except IndexError:
ui.warn("Zulip: Could not find required item {} in hg config.".format(item))
ui.warn(f"Zulip: Could not find required item {item} in hg config.")
sys.exit(1)
@ -106,10 +106,10 @@ def hook(ui: ui, repo: repo, **kwargs: str) -> None:
hooktype = kwargs["hooktype"]
node = kwargs["node"]
ui.debug("Zulip: received {hooktype} event\n".format(hooktype=hooktype))
ui.debug(f"Zulip: received {hooktype} event\n")
if hooktype != "changegroup":
ui.warn("Zulip: {hooktype} not supported\n".format(hooktype=hooktype))
ui.warn(f"Zulip: {hooktype} not supported\n")
sys.exit(1)
ctx = repo[node]
@ -123,14 +123,14 @@ def hook(ui: ui, repo: repo, **kwargs: str) -> None:
# Only send notifications on branches we are watching.
watched_branches = [b.lower().strip() for b in branch_whitelist.split(",")]
if branch.lower() not in watched_branches:
ui.debug("Zulip: ignoring event for {branch}\n".format(branch=branch))
ui.debug(f"Zulip: ignoring event for {branch}\n")
sys.exit(0)
if branch_blacklist:
# Don't send notifications for branches we've ignored.
ignored_branches = [b.lower().strip() for b in branch_blacklist.split(",")]
if branch.lower() in ignored_branches:
ui.debug("Zulip: ignoring event for {branch}\n".format(branch=branch))
ui.debug(f"Zulip: ignoring event for {branch}\n")
sys.exit(0)
# The first and final commits in the changeset.

10
zulip/integrations/jabber/jabber_mirror_backend.py
View file

@ -65,7 +65,7 @@ def jid_to_zulip(jid: JID) -> str:
suffix = ""
if not jid.username.endswith("-bot"):
suffix = options.zulip_email_suffix
return "%s%s@%s" % (jid.username, suffix, options.zulip_domain)
return f"{jid.username}{suffix}@{options.zulip_domain}"
def zulip_to_jid(email: str, jabber_domain: str) -> JID:
@ -274,7 +274,7 @@ def get_rooms(zulipToJabber: ZulipToJabberBot) -> List[str]:
ret = method()
if ret.get("result") != "success":
logging.error(str(ret))
sys.exit("Could not get initial list of Zulip %s" % (key,))
sys.exit(f"Could not get initial list of Zulip {key}")
return ret[key]
if options.mode == "public":
@ -291,7 +291,7 @@ def get_rooms(zulipToJabber: ZulipToJabberBot) -> List[str]:
def config_error(msg: str) -> None:
sys.stderr.write("%s\n" % (msg,))
sys.stderr.write(f"{msg}\n")
sys.exit(2)
@ -442,10 +442,10 @@ option does not affect login credentials.""".replace(
try:
jid = JID(options.jid)
except InvalidJID as e:
config_error("Bad JID: %s: %s" % (options.jid, e.message))
config_error(f"Bad JID: {options.jid}: {e.message}")
if options.conference_domain is None:
options.conference_domain = "conference.%s" % (jid.domain,)
options.conference_domain = f"conference.{jid.domain}"
xmpp = JabberToZulipBot(jid, options.jabber_password, get_rooms(zulipToJabber))

10
zulip/integrations/log2zulip/log2zulip
View file

@ -46,12 +46,12 @@ def mkdir_p(path: str) -> None:
def send_log_zulip(file_name: str, count: int, lines: List[str], extra: str = "") -> None:
content = "%s new errors%s:\n```\n%s\n```" % (count, extra, "\n".join(lines))
content = "{} new errors{}:\n```\n{}\n```".format(count, extra, "\n".join(lines))
zulip_client.send_message(
{
"type": "stream",
"to": "logs",
"subject": "%s on %s" % (file_name, platform.node()),
"subject": f"{file_name} on {platform.node()}",
"content": content,
}
)
@ -84,7 +84,7 @@ def process_logs() -> None:
file_data = last_data.get(log_file, {})
if not os.path.exists(log_file):
# If the file doesn't exist, log an error and then move on to the next file
print("Log file does not exist or could not stat log file: %s" % (log_file,))
print(f"Log file does not exist or could not stat log file: {log_file}")
continue
length = int(subprocess.check_output(["wc", "-l", log_file]).split()[0])
if file_data.get("last") is None:
@ -95,7 +95,7 @@ def process_logs() -> None:
# a log file ends up at the same line length as before
# immediately after rotation, this tool won't notice.
file_data["last"] = 1
output = subprocess.check_output(["tail", "-n+%s" % (file_data["last"],), log_file])
output = subprocess.check_output(["tail", "-n+{}".format(file_data["last"]), log_file])
new_lines = output.decode("utf-8", errors="replace").split("\n")[:-1]
if len(new_lines) > 0:
process_lines(new_lines, log_file)
@ -124,7 +124,7 @@ if __name__ == "__main__":
try:
log_files = json.loads(open(args.control_path).read())
except (json.JSONDecodeError, OSError):
print("Could not load control data from %s" % (args.control_path,))
print(f"Could not load control data from {args.control_path}")
traceback.print_exc()
sys.exit(1)
process_logs()

6
zulip/integrations/nagios/nagios-notify-zulip
View file

@ -31,16 +31,16 @@ msg = dict(type="stream", to=opts.stream) # type: Dict[str, Any]
if opts.service is None:
# Host notification
thing = "host" # type: Text
msg["subject"] = "host %s" % (opts.host,)
msg["subject"] = f"host {opts.host}"
else:
# Service notification
thing = "service"
msg["subject"] = "service %s on %s" % (opts.service, opts.host)
msg["subject"] = f"service {opts.service} on {opts.host}"
if len(msg["subject"]) > 60:
msg["subject"] = msg["subject"][0:57].rstrip() + "..."
# e.g. **PROBLEM**: service is CRITICAL
msg["content"] = "**%s**: %s is %s" % (opts.type, thing, opts.state)
msg["content"] = f"**{opts.type}**: {thing} is {opts.state}"
# The "long output" can contain newlines represented by "\n" escape sequences.
# The Nagios mail command uses /usr/bin/printf "%b" to expand these.

4
zulip/integrations/openshift/zulip_openshift_config.py
View file

@ -21,7 +21,7 @@ ZULIP_API_KEY = "0123456789abcdef0123456789abcdef"
# And similarly for branch "test-post-receive" (for use when testing).
def deployment_notice_destination(branch: str) -> Optional[Dict[str, str]]:
if branch in ["master", "test-post-receive"]:
return dict(stream="deployments", subject="%s" % (branch,))
return dict(stream="deployments", subject=f"{branch}")
# Return None for cases where you don't want a notice sent
return None
@ -46,7 +46,7 @@ def format_deployment_message(
dep_id: str = "",
dep_time: str = "",
) -> str:
return "Deployed commit `%s` (%s) in [%s](%s)" % (commit_id, branch, app_name, url)
return f"Deployed commit `{commit_id}` ({branch}) in [{app_name}]({url})"
## If properly installed, the Zulip API should be in your import

2
zulip/integrations/perforce/zulip_perforce_config.py
View file

@ -37,7 +37,7 @@ def commit_notice_destination(path: str, changelist: int) -> Optional[Dict[str,
directory = dirs[2]
if directory not in ["evil-master-plan", "my-super-secret-repository"]:
return dict(stream="%s-commits" % (directory,), subject=path)
return dict(stream=f"{directory}-commits", subject=path)
# Return None for cases where you don't want a notice sent
return None

8
zulip/integrations/rss/rss-bot
View file

@ -105,7 +105,7 @@ try:
mkdir_p(opts.data_dir)
except OSError:
# We can't write to the logfile, so just print and give up.
print("Unable to store RSS data at %s." % (opts.data_dir,), file=sys.stderr)
print(f"Unable to store RSS data at {opts.data_dir}.", file=sys.stderr)
exit(1)
log_file = os.path.join(opts.data_dir, "rss-bot.log") # type: str
@ -170,7 +170,7 @@ def send_zulip(entry: Any, feed_name: str) -> Dict[str, Any]:
if opts.unwrap:
body = unwrap_text(body)
content = "**[%s](%s)**\n%s\n%s" % (
content = "**[{}]({})**\n{}\n{}".format(
entry.title,
entry.link,
strip_tags(body),
@ -194,7 +194,7 @@ try:
with open(opts.feed_file) as f:
feed_urls = [feed.strip() for feed in f.readlines()] # type: List[str]
except OSError:
log_error_and_exit("Unable to read feed file at %s." % (opts.feed_file,))
log_error_and_exit(f"Unable to read feed file at {opts.feed_file}.")
client = zulip.Client(
email=opts.zulip_email,
@ -245,7 +245,7 @@ for feed_url in feed_urls:
response = send_zulip(entry, feed_name) # type: Dict[str, Any]
if response["result"] != "success":
logger.error("Error processing %s" % (feed_url,))
logger.error(f"Error processing {feed_url}")
logger.error(str(response))
if first_message:
# This is probably some fundamental problem like the stream not

2
zulip/integrations/svn/zulip_svn_config.py
View file

@ -21,7 +21,7 @@ ZULIP_API_KEY = "0123456789abcdef0123456789abcdef"
def commit_notice_destination(path: str, commit: str) -> Optional[Dict[str, str]]:
repo = path.split("/")[-1]
if repo not in ["evil-master-plan", "my-super-secret-repository"]:
return dict(stream="commits", subject="%s" % (repo,))
return dict(stream="commits", subject=f"{repo}")
# Return None for cases where you don't want a notice sent
return None

24
zulip/integrations/trac/zulip_trac.py
View file

@ -38,7 +38,7 @@ client = zulip.Client(
def markdown_ticket_url(ticket: Any, heading: str = "ticket") -> str:
return "[%s #%s](%s/%s)" % (heading, ticket.id, config.TRAC_BASE_TICKET_URL, ticket.id)
return f"[{heading} #{ticket.id}]({config.TRAC_BASE_TICKET_URL}/{ticket.id})"
def markdown_block(desc: str) -> str:
@ -52,7 +52,7 @@ def truncate(string: str, length: int) -> str:
def trac_subject(ticket: Any) -> str:
return truncate("#%s: %s" % (ticket.id, ticket.values.get("summary")), 60)
return truncate("#{}: {}".format(ticket.id, ticket.values.get("summary")), 60)
def send_update(ticket: Any, content: str) -> None:
@ -71,7 +71,7 @@ class ZulipPlugin(Component):
def ticket_created(self, ticket: Any) -> None:
"""Called when a ticket is created."""
content = "%s created %s in component **%s**, priority **%s**:\n" % (
content = "{} created {} in component **{}**, priority **{}**:\n".format(
ticket.values.get("reporter"),
markdown_ticket_url(ticket),
ticket.values.get("component"),
@ -79,9 +79,9 @@ class ZulipPlugin(Component):
)
# Include the full subject if it will be truncated
if len(ticket.values.get("summary")) > 60:
content += "**%s**\n" % (ticket.values.get("summary"),)
content += "**{}**\n".format(ticket.values.get("summary"))
if ticket.values.get("description") != "":
content += "%s" % (markdown_block(ticket.values.get("description")),)
content += "{}".format(markdown_block(ticket.values.get("description")))
send_update(ticket, content)
def ticket_changed(
@ -98,26 +98,26 @@ class ZulipPlugin(Component):
):
return
content = "%s updated %s" % (author, markdown_ticket_url(ticket))
content = f"{author} updated {markdown_ticket_url(ticket)}"
if comment:
content += " with comment: %s\n\n" % (markdown_block(comment),)
content += f" with comment: {markdown_block(comment)}\n\n"
else:
content += ":\n\n"
field_changes = []
for key, value in old_values.items():
if key == "description":
content += "- Changed %s from %s\n\nto %s" % (
content += "- Changed {} from {}\n\nto {}".format(
key,
markdown_block(value),
markdown_block(ticket.values.get(key)),
)
elif old_values.get(key) == "":
field_changes.append("%s: => **%s**" % (key, ticket.values.get(key)))
field_changes.append(f"{key}: => **{ticket.values.get(key)}**")
elif ticket.values.get(key) == "":
field_changes.append('%s: **%s** => ""' % (key, old_values.get(key)))
field_changes.append(f'{key}: **{old_values.get(key)}** => ""')
else:
field_changes.append(
"%s: **%s** => **%s**" % (key, old_values.get(key), ticket.values.get(key))
f"{key}: **{old_values.get(key)}** => **{ticket.values.get(key)}**"
)
content += ", ".join(field_changes)
@ -125,5 +125,5 @@ class ZulipPlugin(Component):
def ticket_deleted(self, ticket: Any) -> None:
"""Called when a ticket is deleted."""
content = "%s was deleted." % (markdown_ticket_url(ticket, heading="Ticket"),)
content = "{} was deleted.".format(markdown_ticket_url(ticket, heading="Ticket"))
send_update(ticket, content)

4
zulip/integrations/trello/zulip_trello.py
View file

@ -25,7 +25,7 @@ def get_model_id(options):
"""
trello_api_url = "https://api.trello.com/1/board/{}".format(options.trello_board_id)
trello_api_url = f"https://api.trello.com/1/board/{options.trello_board_id}"
params = {
"key": options.trello_api_key,
@ -88,7 +88,7 @@ def create_webhook(options):
"""
# first, we need to get the idModel
print("Getting Trello idModel for the {} board...".format(options.trello_board_name))
print(f"Getting Trello idModel for the {options.trello_board_name} board...")
id_model = get_model_id(options)

4
zulip/integrations/twitter/twitter-bot
View file

@ -202,8 +202,8 @@ for status in statuses[::-1][: opts.limit_tweets]:
continue # Continue with the loop for the next tweet
# https://twitter.com/eatevilpenguins/status/309995853408530432
composed = "%s (%s)" % (status.user.name, status.user.screen_name)
url = "https://twitter.com/%s/status/%s" % (status.user.screen_name, status.id)
composed = f"{status.user.name} ({status.user.screen_name})"
url = f"https://twitter.com/{status.user.screen_name}/status/{status.id}"
# This contains all strings that could have caused the tweet to match our query.
text_to_check = [status.text, status.user.screen_name]
text_to_check.extend(url.expanded_url for url in status.urls)

6
zulip/integrations/zephyr/check-mirroring
View file

@ -143,7 +143,7 @@ for tries in range(10):
missing = 0
for elt in zephyr_subs_to_add:
if elt not in zephyr_subs:
logging.error("Failed to subscribe to %s" % (elt,))
logging.error(f"Failed to subscribe to {elt}")
missing += 1
if missing == 0:
actually_subscribed = True
@ -220,9 +220,7 @@ for key, (stream, test) in zhkeys.items():
)
print_status_and_exit(1)
else:
logging.warning(
"Replaced key %s with %s due to Zephyr server failure." % (key, new_key)
)
logging.warning(f"Replaced key {key} with {new_key} due to Zephyr server failure.")
receive_zephyrs()
receive_zephyrs()

10
zulip/integrations/zephyr/process_ccache
View file

@ -9,19 +9,19 @@ api_key = sys.argv[2]
ccache_data_encoded = sys.argv[3]
# Update the Kerberos ticket cache file
program_name = "zmirror-%s" % (short_user,)
with open("/home/zulip/ccache/%s" % (program_name,), "wb") as f:
program_name = f"zmirror-{short_user}"
with open(f"/home/zulip/ccache/{program_name}", "wb") as f:
f.write(base64.b64decode(ccache_data_encoded))
# Setup API key
api_key_path = "/home/zulip/api-keys/%s" % (program_name,)
api_key_path = f"/home/zulip/api-keys/{program_name}"
open(api_key_path, "w").write(api_key + "\n")
# Setup supervisord configuration
supervisor_path = "/etc/supervisor/conf.d/zulip/%s.conf" % (program_name,)
supervisor_path = f"/etc/supervisor/conf.d/zulip/{program_name}.conf"
template = os.path.join(os.path.dirname(__file__), "zmirror_private.conf.template")
template_data = open(template).read()
session_path = "/home/zulip/zephyr_sessions/%s" % (program_name,)
session_path = f"/home/zulip/zephyr_sessions/{program_name}"
# Preserve mail zephyrs forwarding setting across rewriting the config file

2
zulip/integrations/zephyr/zephyr_mirror.py
View file

@ -42,7 +42,7 @@ if options.forward_class_messages and not options.noshard:
jobs = list("0123456789abcdef")
def run_job(shard: str) -> int:
subprocess.call(args + ["--shard=%s" % (shard,)])
subprocess.call(args + [f"--shard={shard}"])
return 0
for (status, job) in run_parallel(run_job, jobs, threads=16):

72
zulip/integrations/zephyr/zephyr_mirror_backend.py
View file

@ -54,7 +54,7 @@ def to_zephyr_username(zulip_username: str) -> str:
return user.lower() + "@ATHENA.MIT.EDU"
match_user = re.match(r"([a-zA-Z0-9_]+)\|(.+)", user)
if not match_user:
raise Exception("Could not parse Zephyr realm for cross-realm user %s" % (zulip_username,))
raise Exception(f"Could not parse Zephyr realm for cross-realm user {zulip_username}")
return match_user.group(1).lower() + "@" + match_user.group(2).upper()
@ -134,10 +134,10 @@ def send_zulip(zeph: ZephyrDict) -> Dict[str, Any]:
# Forward messages sent to -c foo -i bar to stream bar subject "instance"
if zeph["stream"] == "message":
message["to"] = zeph["subject"].lower()
message["subject"] = "instance %s" % (zeph["subject"],)
message["subject"] = "instance {}".format(zeph["subject"])
elif zeph["stream"] == "tabbott-test5":
message["to"] = zeph["subject"].lower()
message["subject"] = "test instance %s" % (zeph["subject"],)
message["subject"] = "test instance {}".format(zeph["subject"])
else:
message["to"] = zeph["stream"]
else:
@ -145,7 +145,7 @@ def send_zulip(zeph: ZephyrDict) -> Dict[str, Any]:
message["content"] = unwrap_lines(zeph["content"])
if options.test_mode and options.site == DEFAULT_SITE:
logger.debug("Message is: %s" % (str(message),))
logger.debug(f"Message is: {str(message)}")
return {"result": "success"}
return zulip_client.send_message(message)
@ -174,7 +174,7 @@ def zephyr_bulk_subscribe(subs: List[Tuple[str, str, str]]) -> None:
# retrying the next time the bot checks its subscriptions are
# up to date.
logger.exception("Error subscribing to streams (will retry automatically):")
logger.warning("Streams were: %s" % ([cls for cls, instance, recipient in subs],))
logger.warning(f"Streams were: {[cls for cls, instance, recipient in subs]}")
return
try:
actual_zephyr_subs = [cls for (cls, _, _) in zephyr._z.getSubscriptions()]
@ -186,7 +186,7 @@ def zephyr_bulk_subscribe(subs: List[Tuple[str, str, str]]) -> None:
return
for (cls, instance, recipient) in subs:
if cls not in actual_zephyr_subs:
logger.error("Zephyr failed to subscribe us to %s; will retry" % (cls,))
logger.error(f"Zephyr failed to subscribe us to {cls}; will retry")
try:
# We'll retry automatically when we next check for
# streams to subscribe to (within 15 seconds), but
@ -317,7 +317,7 @@ def parse_zephyr_body(zephyr_data: str, notice_format: str) -> Tuple[str, str]:
# Logic based off of owl_zephyr_get_message in barnowl
fields = body.split("\x00")
if len(fields) == 5:
body = "New transaction [%s] entered in %s\nFrom: %s (%s)\nSubject: %s" % (
body = "New transaction [{}] entered in {}\nFrom: {} ({})\nSubject: {}".format(
fields[0],
fields[1],
fields[2],
@ -419,7 +419,7 @@ def process_notice(notice: "zephyr.ZNotice", log: Optional[IO[str]]) -> None:
if is_personal and not options.forward_personals:
return
if (zephyr_class not in current_zephyr_subs) and not is_personal:
logger.debug("Skipping ... %s/%s/%s" % (zephyr_class, notice.instance, is_personal))
logger.debug(f"Skipping ... {zephyr_class}/{notice.instance}/{is_personal}")
return
if notice.format.startswith("Zephyr error: See") or notice.format.endswith("@(@color(blue))"):
logger.debug("Skipping message we got from Zulip!")
@ -471,23 +471,21 @@ def process_notice(notice: "zephyr.ZNotice", log: Optional[IO[str]]) -> None:
if notice.instance.strip() != "":
zeph["subject"] = notice.instance
else:
zeph["subject"] = '(instance "%s")' % (notice.instance,)
zeph["subject"] = f'(instance "{notice.instance}")'
# Add instances in for instanced personals
if is_personal:
if notice.cls.lower() != "message" and notice.instance.lower != "personal":
heading = "[-c %s -i %s]\n" % (notice.cls, notice.instance)
heading = f"[-c {notice.cls} -i {notice.instance}]\n"
elif notice.cls.lower() != "message":
heading = "[-c %s]\n" % (notice.cls,)
heading = f"[-c {notice.cls}]\n"
elif notice.instance.lower() != "personal":
heading = "[-i %s]\n" % (notice.instance,)
heading = f"[-i {notice.instance}]\n"
else:
heading = ""
zeph["content"] = heading + zeph["content"]
logger.info(
"Received a message on %s/%s from %s..." % (zephyr_class, notice.instance, notice.sender)
)
logger.info(f"Received a message on {zephyr_class}/{notice.instance} from {notice.sender}...")
if log is not None:
log.write(json.dumps(zeph) + "\n")
log.flush()
@ -499,7 +497,7 @@ def process_notice(notice: "zephyr.ZNotice", log: Optional[IO[str]]) -> None:
try:
res = send_zulip(zeph)
if res.get("result") != "success":
logger.error("Error relaying zephyr:\n%s\n%s" % (zeph, res))
logger.error(f"Error relaying zephyr:\n{zeph}\n{res}")
except Exception:
logger.exception("Error relaying zephyr:")
finally:
@ -630,7 +628,7 @@ def send_zephyr(zwrite_args: List[str], content: str) -> Tuple[int, str]:
logger.info("stdout: " + stdout)
elif stderr:
logger.warning(
"zwrite command '%s' printed the following warning:" % (" ".join(zwrite_args),)
"zwrite command '{}' printed the following warning:".format(" ".join(zwrite_args))
)
if stderr:
logger.warning("stderr: " + stderr)
@ -712,7 +710,7 @@ Feedback button or at support@zulip.com."""
# Forward messages sent to '(instance "WHITESPACE")' back to the
# appropriate WHITESPACE instance for bidirectional mirroring
instance = match_whitespace_instance.group(1)
elif instance == "instance %s" % (zephyr_class,) or instance == "test instance %s" % (
elif instance == f"instance {zephyr_class}" or instance == "test instance {}".format(
zephyr_class,
):
# Forward messages to e.g. -c -i white-magic back from the
@ -724,7 +722,7 @@ Feedback button or at support@zulip.com."""
instance = zephyr_class
zephyr_class = "message"
zwrite_args.extend(["-c", zephyr_class, "-i", instance])
logger.info("Forwarding message to class %s, instance %s" % (zephyr_class, instance))
logger.info(f"Forwarding message to class {zephyr_class}, instance {instance}")
elif message["type"] == "private":
if len(message["display_recipient"]) == 1:
recipient = to_zephyr_username(message["display_recipient"][0]["email"])
@ -744,7 +742,7 @@ Feedback button or at support@zulip.com."""
to_zephyr_username(user["email"]).replace("@ATHENA.MIT.EDU", "")
for user in message["display_recipient"]
]
logger.info("Forwarding message to %s" % (recipients,))
logger.info(f"Forwarding message to {recipients}")
zwrite_args.extend(recipients)
if message.get("invite_only_stream"):
@ -769,7 +767,7 @@ Zulip users (like you) received it, Zephyr users did not.
zwrite_args.extend(["-O", "crypt"])
if options.test_mode:
logger.debug("Would have forwarded: %s\n%s" % (zwrite_args, wrapped_content))
logger.debug(f"Would have forwarded: {zwrite_args}\n{wrapped_content}")
return
(code, stderr) = send_authed_zephyr(zwrite_args, wrapped_content)
@ -849,7 +847,7 @@ def maybe_forward_to_zephyr(message: Dict[str, Any]) -> None:
timestamp_now = int(time.time())
if float(message["timestamp"]) < timestamp_now - 15:
logger.warning(
"Skipping out of order message: %s < %s" % (message["timestamp"], timestamp_now)
"Skipping out of order message: {} < {}".format(message["timestamp"], timestamp_now)
)
return
try:
@ -932,7 +930,7 @@ def add_zulip_subscriptions(verbose: bool) -> None:
authorization_errors_fatal=False,
)
if res.get("result") != "success":
logger.error("Error subscribing to streams:\n%s" % (res["msg"],))
logger.error("Error subscribing to streams:\n{}".format(res["msg"]))
return
already = res.get("already_subscribed")
@ -940,10 +938,12 @@ def add_zulip_subscriptions(verbose: bool) -> None:
unauthorized = res.get("unauthorized")
if verbose:
if already is not None and len(already) > 0:
logger.info("\nAlready subscribed to: %s" % (", ".join(list(already.values())[0]),))
logger.info(
"\nAlready subscribed to: {}".format(", ".join(list(already.values())[0]))
)
if new is not None and len(new) > 0:
logger.info(
"\nSuccessfully subscribed to: %s" % (", ".join(list(new.values())[0]),)
"\nSuccessfully subscribed to: {}".format(", ".join(list(new.values())[0]))
)
if unauthorized is not None and len(unauthorized) > 0:
logger.info(
@ -962,7 +962,7 @@ on these streams and already use Zulip. They can subscribe you to them via the
"""
)
)
+ "\n\n %s" % (", ".join(unauthorized),)
+ "\n\n {}".format(", ".join(unauthorized))
)
if len(skipped) > 0:
@ -989,9 +989,9 @@ Zulip subscription to these lines in ~/.zephyr.subs:
for (cls, instance, recipient, reason) in skipped:
if verbose:
if reason != "":
logger.info(" [%s,%s,%s] (%s)" % (cls, instance, recipient, reason))
logger.info(f" [{cls},{instance},{recipient}] ({reason})")
else:
logger.info(" [%s,%s,%s]" % (cls, instance, recipient))
logger.info(f" [{cls},{instance},{recipient}]")
if len(skipped) > 0:
if verbose:
logger.info(
@ -1032,11 +1032,11 @@ def parse_zephyr_subs(verbose: bool = False) -> Set[Tuple[str, str, str]]:
recipient = recipient.replace("%me%", options.user)
if not valid_stream_name(cls):
if verbose:
logger.error("Skipping subscription to unsupported class name: [%s]" % (line,))
logger.error(f"Skipping subscription to unsupported class name: [{line}]")
continue
except Exception:
if verbose:
logger.error("Couldn't parse ~/.zephyr.subs line: [%s]" % (line,))
logger.error(f"Couldn't parse ~/.zephyr.subs line: [{line}]")
continue
zephyr_subscriptions.add((cls.strip(), instance.strip(), recipient.strip()))
return zephyr_subscriptions
@ -1051,7 +1051,7 @@ def open_logger() -> logging.Logger:
else:
log_file = "/var/log/zulip/mirror-log"
else:
f = tempfile.NamedTemporaryFile(prefix="zulip-log.%s." % (options.user,), delete=False)
f = tempfile.NamedTemporaryFile(prefix=f"zulip-log.{options.user}.", delete=False)
log_file = f.name
# Close the file descriptor, since the logging system will
# reopen it anyway.
@ -1230,10 +1230,10 @@ or specify the --api-key-file option."""
pgrep_query = "python.*zephyr_mirror"
if options.shard is not None:
# sharded class mirror
pgrep_query = "%s.*--shard=%s" % (pgrep_query, options.shard)
pgrep_query = f"{pgrep_query}.*--shard={options.shard}"
elif options.user is not None:
# Personals mirror on behalf of another user.
pgrep_query = "%s.*--user=%s" % (pgrep_query, options.user)
pgrep_query = f"{pgrep_query}.*--user={options.user}"
proc = subprocess.Popen(
["pgrep", "-U", os.environ["USER"], "-f", pgrep_query],
stdout=subprocess.PIPE,
@ -1245,7 +1245,7 @@ or specify the --api-key-file option."""
continue
# Another copy of zephyr_mirror.py! Kill it.
logger.info("Killing duplicate zephyr_mirror process %s" % (pid,))
logger.info(f"Killing duplicate zephyr_mirror process {pid}")
try:
os.kill(pid, signal.SIGINT)
except OSError:
@ -1261,7 +1261,7 @@ or specify the --api-key-file option."""
options.forward_mail_zephyrs = subscribed_to_mail_messages()
if options.session_path is None:
options.session_path = "/var/tmp/%s" % (options.user,)
options.session_path = f"/var/tmp/{options.user}"
if options.forward_from_zulip:
child_pid = os.fork() # type: Optional[int]
@ -1278,7 +1278,7 @@ or specify the --api-key-file option."""
logger_name = "zephyr=>zulip"
if options.shard is not None:
logger_name += "(%s)" % (options.shard,)
logger_name += f"({options.shard})"
configure_logger(logger, logger_name)
# Have the kernel reap children for when we fork off processes to send Zulips
signal.signal(signal.SIGCHLD, signal.SIG_IGN)

84
zulip/zulip/__init__.py
View file

@ -102,7 +102,7 @@ class RandomExponentialBackoff(CountingBackoff):
# between x and 2x where x is growing exponentially
delay_scale = int(2 ** (self.number_of_retries / 2.0 - 1)) + 1
delay = min(delay_scale + random.randint(1, delay_scale), self.delay_cap)
message = "Sleeping for %ss [max %s] before retrying." % (delay, delay_scale * 2)
message = f"Sleeping for {delay}s [max {delay_scale * 2}] before retrying."
try:
logger.warning(message)
except NameError:
@ -124,7 +124,7 @@ def add_default_arguments(
def custom_error_handling(self: argparse.ArgumentParser, message: str) -> None:
self.print_help(sys.stderr)
self.exit(2, "{}: error: {}\n".format(self.prog, message))
self.exit(2, f"{self.prog}: error: {message}\n")
parser.error = types.MethodType(custom_error_handling, parser) # type: ignore # patching function
@ -200,22 +200,22 @@ def generate_option_group(parser: optparse.OptionParser, prefix: str = "") -> op
)
group = optparse.OptionGroup(parser, "Zulip API configuration")
group.add_option(f"--{prefix}site", dest="zulip_site", help="Zulip server URI", default=None)
group.add_option(f"--{prefix}api-key", dest="zulip_api_key", action="store")
group.add_option(
"--%ssite" % (prefix,), dest="zulip_site", help="Zulip server URI", default=None
)
group.add_option("--%sapi-key" % (prefix,), dest="zulip_api_key", action="store")
group.add_option(
"--%suser" % (prefix,), dest="zulip_email", help="Email address of the calling bot or user."
f"--{prefix}user",
dest="zulip_email",
help="Email address of the calling bot or user.",
)
group.add_option(
"--%sconfig-file" % (prefix,),
f"--{prefix}config-file",
action="store",
dest="zulip_config_file",
help="Location of an ini file containing the\nabove information. (default ~/.zuliprc)",
)
group.add_option("-v", "--verbose", action="store_true", help="Provide detailed output.")
group.add_option(
"--%sclient" % (prefix,),
f"--{prefix}client",
action="store",
default=None,
dest="zulip_client",
@ -428,7 +428,7 @@ class Client:
elif None in (api_key, email):
raise ConfigNotFoundError(
"api_key or email not specified and file %s does not exist" % (config_file,)
f"api_key or email not specified and file {config_file} does not exist"
)
assert api_key is not None and email is not None
@ -461,7 +461,7 @@ class Client:
self.tls_verification = False # type: Union[bool, str]
elif cert_bundle is not None:
if not os.path.isfile(cert_bundle):
raise ConfigNotFoundError("tls bundle '%s' does not exist" % (cert_bundle,))
raise ConfigNotFoundError(f"tls bundle '{cert_bundle}' does not exist")
self.tls_verification = cert_bundle
else:
# Default behavior: verify against system CA certificates
@ -475,12 +475,10 @@ class Client:
)
else: # we have a client cert
if not os.path.isfile(client_cert):
raise ConfigNotFoundError("client cert '%s' does not exist" % (client_cert,))
raise ConfigNotFoundError(f"client cert '{client_cert}' does not exist")
if client_cert_key is not None:
if not os.path.isfile(client_cert_key):
raise ConfigNotFoundError(
"client cert key '%s' does not exist" % (client_cert_key,)
)
raise ConfigNotFoundError(f"client cert key '{client_cert_key}' does not exist")
self.client_cert = client_cert
self.client_cert_key = client_cert_key
@ -631,7 +629,7 @@ class Client:
# On 50x errors, try again after a short sleep
if str(res.status_code).startswith("5"):
if error_retry(" (server %s)" % (res.status_code,)):
if error_retry(f" (server {res.status_code})"):
continue
# Otherwise fall through and process the python-requests error normally
except (requests.exceptions.Timeout, requests.exceptions.SSLError) as e:
@ -650,7 +648,7 @@ class Client:
else:
end_error_retry(False)
return {
"msg": "Connection error:\n%s" % (traceback.format_exc(),),
"msg": f"Connection error:\n{traceback.format_exc()}",
"result": "connection-error",
}
except requests.exceptions.ConnectionError:
@ -665,13 +663,13 @@ class Client:
continue
end_error_retry(False)
return {
"msg": "Connection error:\n%s" % (traceback.format_exc(),),
"msg": f"Connection error:\n{traceback.format_exc()}",
"result": "connection-error",
}
except Exception:
# We'll split this out into more cases as we encounter new bugs.
return {
"msg": "Unexpected error:\n%s" % (traceback.format_exc(),),
"msg": f"Unexpected error:\n{traceback.format_exc()}",
"result": "unexpected-error",
}
@ -737,7 +735,7 @@ class Client:
res = self.register(event_types, narrow, **kwargs)
if "error" in res["result"]:
if self.verbose:
print("Server returned error:\n%s" % (res["msg"],))
print("Server returned error:\n{}".format(res["msg"]))
time.sleep(1)
else:
return (res["queue_id"], res["last_event_id"])
@ -762,7 +760,7 @@ class Client:
)
else:
if self.verbose:
print("Server returned error:\n%s" % (res["msg"],))
print("Server returned error:\n{}".format(res["msg"]))
# Eventually, we'll only want the
# BAD_EVENT_QUEUE_ID check, but we check for the
# old string to support legacy Zulip servers. We
@ -821,7 +819,7 @@ class Client:
"""
See examples/get-raw-message for example usage
"""
return self.call_endpoint(url="messages/{}".format(message_id), method="GET")
return self.call_endpoint(url=f"messages/{message_id}", method="GET")
def send_message(self, message_data: Dict[str, Any]) -> Dict[str, Any]:
"""
@ -861,7 +859,7 @@ class Client:
"""
See examples/delete-message for example usage.
"""
return self.call_endpoint(url="messages/{}".format(message_id), method="DELETE")
return self.call_endpoint(url=f"messages/{message_id}", method="DELETE")
def update_message_flags(self, update_data: Dict[str, Any]) -> Dict[str, Any]:
"""
@ -914,7 +912,7 @@ class Client:
"""
See examples/message-history for example usage.
"""
return self.call_endpoint(url="messages/{}/history".format(message_id), method="GET")
return self.call_endpoint(url=f"messages/{message_id}/history", method="GET")
def add_reaction(self, reaction_data: Dict[str, Any]) -> Dict[str, Any]:
"""
@ -965,9 +963,7 @@ class Client:
>>> client.upload_custom_emoji(emoji_name, file_obj)
{'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
"realm/emoji/{}".format(emoji_name), method="POST", files=[file_obj]
)
return self.call_endpoint(f"realm/emoji/{emoji_name}", method="POST", files=[file_obj])
def delete_custom_emoji(self, emoji_name: str) -> Dict[str, Any]:
"""
@ -977,7 +973,7 @@ class Client:
{'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
url="realm/emoji/{}".format(emoji_name),
url=f"realm/emoji/{emoji_name}",
method="DELETE",
)
@ -1027,7 +1023,7 @@ class Client:
{'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
url="realm/filters/{}".format(filter_id),
url=f"realm/filters/{filter_id}",
method="DELETE",
)
@ -1064,7 +1060,7 @@ class Client:
{'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
url="realm/profile_fields/{}".format(field_id),
url=f"realm/profile_fields/{field_id}",
method="DELETE",
)
@ -1089,7 +1085,7 @@ class Client:
{'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
url="realm/profile_fields/{}".format(field_id),
url=f"realm/profile_fields/{field_id}",
method="PATCH",
request=request,
)
@ -1181,7 +1177,7 @@ class Client:
{'presence': {'website': {'timestamp': 1486799122, 'status': 'active'}}, 'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
url="users/%s/presence" % (email,),
url=f"users/{email}/presence",
method="GET",
)
@ -1240,7 +1236,7 @@ class Client:
See examples/delete-stream for example usage.
"""
return self.call_endpoint(
url="streams/{}".format(stream_id),
url=f"streams/{stream_id}",
method="DELETE",
)
@ -1267,7 +1263,7 @@ class Client:
{'result': 'success', 'msg': '', 'user': [{...}, {...}]}
"""
return self.call_endpoint(
url="users/{}".format(user_id),
url=f"users/{user_id}",
method="GET",
request=request,
)
@ -1281,7 +1277,7 @@ class Client:
{'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
url="users/{}".format(user_id),
url=f"users/{user_id}",
method="DELETE",
)
@ -1294,7 +1290,7 @@ class Client:
{'result': 'success', 'msg': ''}
"""
return self.call_endpoint(
url="users/{}/reactivate".format(user_id),
url=f"users/{user_id}/reactivate",
method="POST",
)
@ -1310,7 +1306,7 @@ class Client:
for key, value in request.items():
request[key] = json.dumps(value)
return self.call_endpoint(url="users/{}".format(user_id), method="PATCH", request=request)
return self.call_endpoint(url=f"users/{user_id}", method="PATCH", request=request)
def get_users(self, request: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
"""
@ -1399,7 +1395,7 @@ class Client:
{'result': 'success', 'msg': '', 'is_subscribed': False}
"""
return self.call_endpoint(
url="users/{}/subscriptions/{}".format(user_id, stream_id),
url=f"users/{user_id}/subscriptions/{stream_id}",
method="GET",
)
@ -1456,7 +1452,7 @@ class Client:
Example usage: client.get_stream_id('devel')
"""
stream_encoded = urllib.parse.quote(stream, safe="")
url = "get_stream_id?stream=%s" % (stream_encoded,)
url = f"get_stream_id?stream={stream_encoded}"
return self.call_endpoint(
url=url,
method="GET",
@ -1467,7 +1463,7 @@ class Client:
"""
See examples/get-stream-topics for example usage.
"""
return self.call_endpoint(url="users/me/{}/topics".format(stream_id), method="GET")
return self.call_endpoint(url=f"users/me/{stream_id}/topics", method="GET")
def get_user_groups(self) -> Dict[str, Any]:
"""
@ -1521,7 +1517,7 @@ class Client:
{'msg': '', 'result': 'success'}
"""
return self.call_endpoint(
url="user_groups/{}".format(group_id),
url=f"user_groups/{group_id}",
method="DELETE",
)
@ -1538,7 +1534,7 @@ class Client:
{'msg': '', 'result': 'success'}
"""
return self.call_endpoint(
url="user_groups/{}/members".format(user_group_id),
url=f"user_groups/{user_group_id}/members",
method="POST",
request=group_data,
)
@ -1683,7 +1679,7 @@ class Client:
return result
if len(result["messages"]) <= 0:
return {"result": "error", "msg": 'No messages found in topic: "{}"'.format(topic)}
return {"result": "error", "msg": f'No messages found in topic: "{topic}"'}
message_id = result["messages"][0]["id"]
@ -1696,7 +1692,7 @@ class Client:
"send_notification_to_new_thread": notify_new_topic,
}
return self.call_endpoint(
url="messages/{}".format(message_id),
url=f"messages/{message_id}",
method="PATCH",
request=request,
)

2
zulip/zulip/examples/edit-stream
View file

@ -15,7 +15,7 @@ Example: edit-stream --stream-id=3 --history-public-to-subscribers
def quote(string: str) -> str:
return '"{}"'.format(string)
return f'"{string}"'
parser = zulip.add_default_arguments(argparse.ArgumentParser(usage=usage))

2
zulip/zulip/examples/upload-file
View file

@ -38,4 +38,4 @@ response = client.upload_file(file)
try:
print("File URI: {}".format(response["uri"]))
except KeyError:
print("Error! API response was: {}".format(response))
print(f"Error! API response was: {response}")

2
zulip/zulip/send.py
View file

@ -22,7 +22,7 @@ def do_send_message(client: zulip.Client, message_data: Dict[str, Any]) -> bool:
% (message_data["to"], message_data["subject"])
)
else:
log.info("Sending message to %s... " % (message_data["to"],))
log.info("Sending message to {}... ".format(message_data["to"]))
response = client.send_message(message_data)
if response["result"] == "success":
log.info("Message sent.")

4
zulip_bots/setup.py
View file

@ -90,11 +90,11 @@ except ImportError:
except (ImportError, AssertionError):
if version is not None:
print(
"{name}>={version} is not installed.".format(name=module_name, version=version),
f"{module_name}>={version} is not installed.",
file=sys.stderr,
)
else:
print("{name} is not installed.".format(name=module_name), file=sys.stderr)
print(f"{module_name} is not installed.", file=sys.stderr)
sys.exit(1)
check_dependency_manually("zulip")

10
zulip_bots/zulip_bots/bots/baremetrics/baremetrics.py
View file

@ -73,7 +73,7 @@ class BaremetricsHandler:
if content == ["list-commands"]:
response = "**Available Commands:** \n"
for command, description in zip(self.commands, self.descriptions):
response += " - {} : {}\n".format(command, description)
response += f" - {command} : {description}\n"
bot_handler.send_reply(message, response)
return
@ -148,7 +148,7 @@ class BaremetricsHandler:
return response
def get_plans(self, source_id: str) -> str:
url = "https://api.baremetrics.com/v1/{}/plans".format(source_id)
url = f"https://api.baremetrics.com/v1/{source_id}/plans"
plans_response = requests.get(url, headers=self.auth_header)
plans_data = plans_response.json()
@ -174,7 +174,7 @@ class BaremetricsHandler:
return "\n".join(response)
def get_customers(self, source_id: str) -> str:
url = "https://api.baremetrics.com/v1/{}/customers".format(source_id)
url = f"https://api.baremetrics.com/v1/{source_id}/customers"
customers_response = requests.get(url, headers=self.auth_header)
customers_data = customers_response.json()
@ -203,7 +203,7 @@ class BaremetricsHandler:
return "\n".join(response)
def get_subscriptions(self, source_id: str) -> str:
url = "https://api.baremetrics.com/v1/{}/subscriptions".format(source_id)
url = f"https://api.baremetrics.com/v1/{source_id}/subscriptions"
subscriptions_response = requests.get(url, headers=self.auth_header)
subscriptions_data = subscriptions_response.json()
@ -250,7 +250,7 @@ class BaremetricsHandler:
"interval_count": int(parameters[6]),
} # type: Any
url = "https://api.baremetrics.com/v1/{}/plans".format(parameters[0])
url = f"https://api.baremetrics.com/v1/{parameters[0]}/plans"
create_plan_response = requests.post(url, data=data_header, headers=self.auth_header)
if "error" not in create_plan_response.json():
return "Plan Created."

2
zulip_bots/zulip_bots/bots/beeminder/beeminder.py
View file

@ -70,7 +70,7 @@ at syntax by: @mention-botname help"
r.status_code
) # Occures in case of unprocessable entity
else:
datapoint_link = "https://www.beeminder.com/{}/{}".format(username, goalname)
datapoint_link = f"https://www.beeminder.com/{username}/{goalname}"
return "[Datapoint]({}) created.".format(
datapoint_link
) # Handles the case of successful datapoint creation

4
zulip_bots/zulip_bots/bots/chessbot/chessbot.py
View file

@ -376,7 +376,7 @@ def make_draw_response(reason: str) -> str:
Returns: The draw response string.
"""
return "It's a draw because of {}!".format(reason)
return f"It's a draw because of {reason}!"
def make_loss_response(board: chess.Board, reason: str) -> str:
@ -525,7 +525,7 @@ def make_str(board: chess.Board, is_white_on_bottom: bool) -> str:
replaced_and_guided_str if is_white_on_bottom else replaced_and_guided_str[::-1]
)
trimmed_str = trim_whitespace_before_newline(properly_flipped_str)
monospaced_str = "```\n{}\n```".format(trimmed_str)
monospaced_str = f"```\n{trimmed_str}\n```"
return monospaced_str

2
zulip_bots/zulip_bots/bots/define/define.py
View file

@ -51,7 +51,7 @@ class DefineHandler:
if not to_define_lower:
return self.EMPTY_WORD_REQUEST_ERROR_MESSAGE
else:
response = "**{}**:\n".format(to_define)
response = f"**{to_define}**:\n"
try:
# Use OwlBot API to fetch definition.

2
zulip_bots/zulip_bots/bots/dialogflow/dialogflow.py
View file

@ -36,7 +36,7 @@ def get_bot_result(message_content: str, config: Dict[str, str], sender_id: str)
return res_json["result"]["fulfillment"]["speech"]
except Exception as e:
logging.exception(str(e))
return "Error. {}.".format(str(e))
return f"Error. {str(e)}."
class DialogFlowHandler:

4
zulip_bots/zulip_bots/bots/dropbox_share/dropbox_share.py
View file

@ -117,7 +117,7 @@ def syntax_help(cmd_name: str) -> str:
cmd = cmd_name + " " + arg_syntax
else:
cmd = cmd_name
return "syntax: {}".format(cmd)
return f"syntax: {cmd}"
def dbx_help(client: Any, cmd_name: str) -> str:
@ -197,7 +197,7 @@ def dbx_read(client: Any, fn: str) -> str:
try:
result = client.files_download(fn)
msg = "**{}** :\n{}".format(result[0].name, result[1].text)
msg = f"**{result[0].name}** :\n{result[1].text}"
except Exception:
msg = (
"Please provide a correct file path\nUsage: `read <filename>` to read content of a file"

4
zulip_bots/zulip_bots/bots/file_uploader/file_uploader.py
View file

@ -27,14 +27,14 @@ class FileUploaderHandler:
path = Path(os.path.expanduser(content))
if not path.is_file():
bot_handler.send_reply(message, "File `{}` not found".format(content))
bot_handler.send_reply(message, f"File `{content}` not found")
return
path = path.resolve()
upload = bot_handler.upload_file_from_path(str(path))
if upload["result"] != "success":
msg = upload["msg"]
bot_handler.send_reply(message, "Failed to upload `{}` file: {}".format(path, msg))
bot_handler.send_reply(message, f"Failed to upload `{path}` file: {msg}")
return
uploaded_file_reply = "[{}]({})".format(path.name, upload["uri"])

2
zulip_bots/zulip_bots/bots/followup/followup.py
View file

@ -52,7 +52,7 @@ class FollowupHandler:
def get_bot_followup_response(self, message: Dict[str, str]) -> str:
original_content = message["content"]
original_sender = message["sender_email"]
temp_content = "from %s: " % (original_sender,)
temp_content = f"from {original_sender}: "
new_content = temp_content + original_content
return new_content

2
zulip_bots/zulip_bots/bots/front/front.py
View file

@ -35,7 +35,7 @@ class FrontHandler:
def help(self, bot_handler: BotHandler) -> str:
response = ""
for command, description in self.COMMANDS:
response += "`{}` {}\n".format(command, description)
response += f"`{command}` {description}\n"
return response

4
zulip_bots/zulip_bots/bots/front/test_front.py
View file

@ -78,9 +78,9 @@ class TestFrontBot(BotTestCase, DefaultTests):
def _test_command_error(self, command_name: str, command_arg: Optional[str] = None) -> None:
bot_command = command_name
if command_arg:
bot_command += " {}".format(command_arg)
bot_command += f" {command_arg}"
with self.mock_config_info({"api_key": "TEST"}):
with self.mock_http_conversation("{}_error".format(command_name)):
with self.mock_http_conversation(f"{command_name}_error"):
self.verify_reply(bot_command, "Something went wrong.")

7
zulip_bots/zulip_bots/bots/game_handler_bot/test_game_handler_bot.py
View file

@ -1,6 +1,5 @@
from typing import Any, Dict, List
from mock import patch
from unittest.mock import patch
from zulip_bots.game_handler import GameInstance
from zulip_bots.test_lib import BotTestCase, DefaultTests
@ -66,8 +65,8 @@ class TestGameHandlerBot(BotTestCase, DefaultTests):
if bot is None:
bot, bot_handler = self._get_handlers()
message = {
"sender_email": "{}@example.com".format(name),
"sender_full_name": "{}".format(name),
"sender_email": f"{name}@example.com",
"sender_full_name": f"{name}",
}
bot.add_user_to_cache(message)
return bot

4
zulip_bots/zulip_bots/bots/github_detail/github_detail.py
View file

@ -42,8 +42,8 @@ class GithubHandler:
status = details["state"].title()
message_string = (
"**[{owner}/{repo}#{id}]".format(owner=owner, repo=repo, id=number),
"({link}) - {title}**\n".format(title=title, link=link),
f"**[{owner}/{repo}#{number}]",
f"({link}) - {title}**\n",
"Created by **[{author}](https://github.com/{author})**\n".format(author=author),
"Status - **{status}**\n```quote\n{description}\n```".format(
status=status, description=description

4
zulip_bots/zulip_bots/bots/google_search/google_search.py
View file

@ -32,7 +32,7 @@ def google_search(keywords: str) -> List[Dict[str, str]]:
if a.text.strip() == "Cached" and "webcache.googleusercontent.com" in a["href"]:
continue
# a.text: The name of the page
result = {"url": "https://www.google.com{}".format(link), "name": a.text}
result = {"url": f"https://www.google.com{link}", "name": a.text}
results.append(result)
return results
@ -61,7 +61,7 @@ def get_google_result(search_keywords: str) -> str:
return "Found Result: [{}]({})".format(results[0]["name"], results[0]["url"])
except Exception as e:
logging.exception(str(e))
return "Error: Search failed. {}.".format(e)
return f"Error: Search failed. {e}."
class GoogleSearchHandler:

8
zulip_bots/zulip_bots/bots/google_translate/google_translate.py
View file

@ -107,12 +107,12 @@ def get_translate_bot_response(message_content, config_file, author, all_languag
text_to_translate, config_file["key"], target_language, source_language
)
except requests.exceptions.ConnectionError as conn_err:
return "Could not connect to Google Translate. {}.".format(conn_err)
return f"Could not connect to Google Translate. {conn_err}."
except TranslateError as tr_err:
return "Translate Error. {}.".format(tr_err)
return f"Translate Error. {tr_err}."
except Exception as err:
return "Error. {}.".format(err)
return "{} (from {})".format(translated_text, author)
return f"Error. {err}."
return f"{translated_text} (from {author})"
handler_class = GoogleTranslateHandler

6
zulip_bots/zulip_bots/bots/idonethis/idonethis.py
View file

@ -64,12 +64,12 @@ def api_list_team() -> List[Dict[str, str]]:
def api_show_team(hash_id: str) -> Dict[str, str]:
return make_API_request("/teams/{}".format(hash_id))
return make_API_request(f"/teams/{hash_id}")
# NOTE: This function is not currently used
def api_show_users(hash_id: str) -> Any:
return make_API_request("/teams/{}/members".format(hash_id))
return make_API_request(f"/teams/{hash_id}/members")
def api_list_entries(team_id: Optional[str] = None) -> List[Dict[str, Any]]:
@ -105,7 +105,7 @@ def team_info(team_name: str) -> str:
def entries_list(team_name: str) -> str:
if team_name:
data = api_list_entries(get_team_hash(team_name))
response = "Entries for {}:".format(team_name)
response = f"Entries for {team_name}:"
else:
data = api_list_entries()
response = "Entries for all teams:"

16
zulip_bots/zulip_bots/bots/incident/incident.py
View file

@ -39,7 +39,7 @@ class IncidentHandler:
bot_response = "Invalid answer format"
bot_handler.send_reply(message, bot_response)
return
bot_response = "Incident %s\n status = %s" % (ticket_id, answer)
bot_response = f"Incident {ticket_id}\n status = {answer}"
bot_handler.send_reply(message, bot_response)
else:
bot_response = 'type "new <description>" for a new incident'
@ -125,15 +125,13 @@ def format_incident_for_widget(ticket_id: str, incident: Dict[str, Any]) -> str:
def format_incident_for_markdown(ticket_id: str, incident: Dict[str, Any]) -> str:
answer_list = "\n".join(
[
"* **{code}** {answer}".format(
code=code,
answer=ANSWERS[code],
)
for code in "1234"
]
"* **{code}** {answer}".format(
code=code,
answer=ANSWERS[code],
)
for code in "1234"
)
how_to_respond = """**reply**: answer {ticket_id} <code>""".format(ticket_id=ticket_id)
how_to_respond = f"""**reply**: answer {ticket_id} <code>"""
content = """
Incident: {incident}

10
zulip_bots/zulip_bots/bots/jira/jira.py
View file

@ -183,7 +183,7 @@ class JiraHandler:
UNKNOWN_VAL = "*unknown*"
jira_response = requests.get(
self.domain_with_protocol
+ "/rest/api/2/search?jql={}&fields=key,summary,status".format(jql_query),
+ f"/rest/api/2/search?jql={jql_query}&fields=key,summary,status",
headers={"Authorization": self.auth},
).json()
@ -194,7 +194,7 @@ class JiraHandler:
if errors:
response = "Oh no! Jira raised an error:\n > " + ", ".join(errors)
else:
response = "*Found {} results*\n\n".format(results)
response = f"*Found {results} results*\n\n"
for issue in jira_response.get("issues", []):
fields = issue.get("fields", {})
summary = fields.get("summary", UNKNOWN_VAL)
@ -314,12 +314,12 @@ class JiraHandler:
response = "Issue *" + key + "* was edited! " + url
elif search_match:
search_term = search_match.group("search_term")
search_results = self.jql_search("summary ~ {}".format(search_term))
response = '**Search results for "{}"**\n\n{}'.format(search_term, search_results)
search_results = self.jql_search(f"summary ~ {search_term}")
response = f'**Search results for "{search_term}"**\n\n{search_results}'
elif jql_match:
jql_query = jql_match.group("jql_query")
search_results = self.jql_search(jql_query)
response = '**Search results for "{}"**\n\n{}'.format(jql_query, search_results)
response = f'**Search results for "{jql_query}"**\n\n{search_results}'
elif help_match:
response = HELP_RESPONSE
else:

2
zulip_bots/zulip_bots/bots/merels/libraries/game.py
View file

@ -197,5 +197,5 @@ def check_win(topic_name, merels_storage):
win = mechanics.who_won(topic_name, merels_storage)
if win != "None":
merels.remove_game(topic_name)
return "{} wins the game!".format(win)
return f"{win} wins the game!"
return ""

6
zulip_bots/zulip_bots/bots/merels/libraries/mechanics.py
View file

@ -278,7 +278,7 @@ def create_room(topic_name, merels_storage):
if merels.create_new_game(topic_name):
response = ""
response += "A room has been created in {0}. Starting game now.\n".format(topic_name)
response += f"A room has been created in {topic_name}. Starting game now.\n"
response += display_game(topic_name, merels_storage)
return response
@ -404,7 +404,7 @@ def put_man(topic_name, v, h, merels_storage):
data.hill_uid,
data.take_mode,
)
return "Put a man to ({}, {}) for {}.".format(v, h, data.turn)
return f"Put a man to ({v}, {h}) for {data.turn}."
else:
raise BadMoveException("Failed: That's not a legal put. Please try again.")
@ -448,7 +448,7 @@ def take_man(topic_name, v, h, merels_storage):
data.hill_uid,
data.take_mode,
)
return "Taken a man from ({}, {}) for {}.".format(v, h, data.turn)
return f"Taken a man from ({v}, {h}) for {data.turn}."
else:
raise BadMoveException("Failed: That's not a legal take. Please try again.")

2
zulip_bots/zulip_bots/bots/merels/merels.py
View file

@ -44,7 +44,7 @@ class MerelsModel:
if self.storage.get(self.topic) == '["X", 0, 0, "NNNNNNNNNNNNNNNNNNNNNNNN", "", 0]':
self.storage.put(
self.topic,
'["{}", 0, 0, "NNNNNNNNNNNNNNNNNNNNNNNN", "", 0]'.format(self.token[player_number]),
f'["{self.token[player_number]}", 0, 0, "NNNNNNNNNNNNNNNNNNNNNNNN", "", 0]',
)
self.current_board, same_player_move = game.beat(move, self.topic, self.storage)
if same_player_move != "":

4
zulip_bots/zulip_bots/bots/merels/test_merels.py
View file

@ -60,8 +60,8 @@ class TestMerelsBot(BotTestCase, DefaultTests):
if bot is None:
bot, bot_handler = self._get_handlers()
message = {
"sender_email": "{}@example.com".format(name),
"sender_full_name": "{}".format(name),
"sender_email": f"{name}@example.com",
"sender_full_name": f"{name}",
}
bot.add_user_to_cache(message)
return bot

14
zulip_bots/zulip_bots/bots/monkeytestit/lib/report.py
View file

@ -25,15 +25,15 @@ def compose(results: Dict) -> str:
response = ""
response += "{}\n".format(print_status(results))
response += f"{print_status(results)}\n"
if "success" in response.lower():
response += "{}".format(print_test_id(results))
response += f"{print_test_id(results)}"
return response
response += "{}\n".format(print_enabled_checkers(results))
response += "{}\n".format(print_failures_checkers(results))
response += "{}".format(print_more_info_url(results))
response += f"{print_enabled_checkers(results)}\n"
response += f"{print_failures_checkers(results)}\n"
response += f"{print_more_info_url(results)}"
return response
@ -81,11 +81,11 @@ def print_failures_checkers(results: Dict) -> str:
] # [('seo', 3), ..]
failures_checkers_messages = [
"{} ({})".format(fail_checker[0], fail_checker[1]) for fail_checker in failures_checkers
f"{fail_checker[0]} ({fail_checker[1]})" for fail_checker in failures_checkers
]
failures_checkers_message = ", ".join(failures_checkers_messages)
return "Failures from checkers: {}".format(failures_checkers_message)
return f"Failures from checkers: {failures_checkers_message}"
def get_enabled_checkers(results: Dict) -> List:

12
zulip_bots/zulip_bots/bots/salesforce/salesforce.py
View file

@ -57,17 +57,17 @@ def format_result(
output += "**[{}]({}{})**\n".format(record["Name"], login_url, record["Id"])
for key, value in record.items():
if key not in exclude_keys:
output += ">**{}**: {}\n".format(key, value)
output += f">**{key}**: {value}\n"
else:
for i, record in enumerate(result["records"]):
if rank_output:
output += "{}) ".format(i + 1)
output += f"{i + 1}) "
output += "**[{}]({}{})**\n".format(record["Name"], login_url, record["Id"])
added_keys = False
for key, value in record.items():
if key in force_keys or (show_all_keys and key not in exclude_keys):
added_keys = True
output += ">**{}**: {}\n".format(key, value)
output += f">**{key}**: {value}\n"
if added_keys:
output += "\n"
return output
@ -88,7 +88,7 @@ def query_salesforce(
limit = re_limit.search(raw_arg)
if limit:
limit_num = int(limit.group().rsplit(" ", 1)[1])
logging.info("Searching with limit {}".format(limit_num))
logging.info(f"Searching with limit {limit_num}")
query = default_query
if "query" in command.keys():
query = command["query"]
@ -170,14 +170,14 @@ class SalesforceHandler:
security_token=self.config_info["security_token"],
)
except simple_salesforce.exceptions.SalesforceAuthenticationFailed as err:
bot_handler.quit("Failed to log in to Salesforce. {} {}".format(err.code, err.message))
bot_handler.quit(f"Failed to log in to Salesforce. {err.code} {err.message}")
def handle_message(self, message: Dict[str, Any], bot_handler: BotHandler) -> None:
try:
bot_response = self.get_salesforce_response(message["content"])
bot_handler.send_reply(message, bot_response)
except Exception as e:
bot_handler.send_reply(message, "Error. {}.".format(e), bot_response)
bot_handler.send_reply(message, f"Error. {e}.", bot_response)
handler_class = SalesforceHandler

4
zulip_bots/zulip_bots/bots/tictactoe/test_tictactoe.py
View file

@ -151,8 +151,8 @@ class TestTicTacToeBot(BotTestCase, DefaultTests):
if bot is None:
bot, bot_handler = self._get_handlers()
message = {
"sender_email": "{}@example.com".format(name),
"sender_full_name": "{}".format(name),
"sender_email": f"{name}@example.com",
"sender_full_name": f"{name}",
}
bot.add_user_to_cache(message)
return bot

6
zulip_bots/zulip_bots/bots/tictactoe/tictactoe.py
View file

@ -241,14 +241,14 @@ class TicTacToeMessageHandler:
def parse_board(self, board: Any) -> str:
"""Takes the board as a nested list and returns a nice version for the user."""
return "".join([self.parse_row(r, r_num) for r_num, r in enumerate(board)])
return "".join(self.parse_row(r, r_num) for r_num, r in enumerate(board))
def get_player_color(self, turn: int) -> str:
return self.tokens[turn]
def alert_move_message(self, original_player: str, move_info: str) -> str:
move_info = move_info.replace("move ", "")
return "{} put a token at {}".format(original_player, move_info)
return f"{original_player} put a token at {move_info}"
def game_start_message(self) -> str:
return (
@ -299,7 +299,7 @@ def coords_from_command(cmd: str) -> str:
"""As there are various ways to input a coordinate (with/without parentheses, with/without spaces, etc.) the
input is stripped to just the numbers before being used in the program."""
cmd_num = int(cmd.replace("move ", "")) - 1
cmd = "{},{}".format((cmd_num % 3) + 1, (cmd_num // 3) + 1)
cmd = f"{(cmd_num % 3) + 1},{(cmd_num // 3) + 1}"
return cmd

12
zulip_bots/zulip_bots/bots/trello/trello.py
View file

@ -30,7 +30,7 @@ class TrelloHandler:
def check_access_token(self, bot_handler: BotHandler) -> None:
test_query_response = requests.get(
"https://api.trello.com/1/members/{}/".format(self.user_name), params=self.auth_params
f"https://api.trello.com/1/members/{self.user_name}/", params=self.auth_params
)
if test_query_response.text == "invalid key":
@ -75,12 +75,12 @@ class TrelloHandler:
def get_all_supported_commands(self) -> str:
bot_response = "**Commands:** \n"
for index, (command, desc) in enumerate(supported_commands):
bot_response += "{}. **{}**: {}\n".format(index + 1, command, desc)
bot_response += f"{index + 1}. **{command}**: {desc}\n"
return bot_response
def get_all_boards(self) -> str:
get_board_ids_url = "https://api.trello.com/1/members/{}/".format(self.user_name)
get_board_ids_url = f"https://api.trello.com/1/members/{self.user_name}/"
board_ids_response = requests.get(get_board_ids_url, params=self.auth_params)
try:
@ -112,7 +112,7 @@ class TrelloHandler:
return INVALID_ARGUMENTS_ERROR_MESSAGE
board_id = content[1]
get_cards_url = "https://api.trello.com/1/boards/{}/cards".format(board_id)
get_cards_url = f"https://api.trello.com/1/boards/{board_id}/cards"
cards_response = requests.get(get_cards_url, params=self.auth_params)
try:
@ -133,7 +133,7 @@ class TrelloHandler:
return INVALID_ARGUMENTS_ERROR_MESSAGE
card_id = content[1]
get_checklists_url = "https://api.trello.com/1/cards/{}/checklists/".format(card_id)
get_checklists_url = f"https://api.trello.com/1/cards/{card_id}/checklists/"
checklists_response = requests.get(get_checklists_url, params=self.auth_params)
try:
@ -160,7 +160,7 @@ class TrelloHandler:
return INVALID_ARGUMENTS_ERROR_MESSAGE
board_id = content[1]
get_lists_url = "https://api.trello.com/1/boards/{}/lists".format(board_id)
get_lists_url = f"https://api.trello.com/1/boards/{board_id}/lists"
lists_response = requests.get(get_lists_url, params=self.auth_params)
try:

14
zulip_bots/zulip_bots/bots/trivia_quiz/trivia_quiz.py
View file

@ -191,15 +191,13 @@ def format_quiz_for_markdown(quiz_id: str, quiz: Dict[str, Any]) -> str:
question = quiz["question"]
answers = quiz["answers"]
answer_list = "\n".join(
[
"* **{letter}** {answer}".format(
letter=letter,
answer=answers[letter],
)
for letter in "ABCD"
]
"* **{letter}** {answer}".format(
letter=letter,
answer=answers[letter],
)
for letter in "ABCD"
)
how_to_respond = """**reply**: answer {quiz_id} <letter>""".format(quiz_id=quiz_id)
how_to_respond = f"""**reply**: answer {quiz_id} <letter>"""
content = """
Q: {question}

2
zulip_bots/zulip_bots/bots/twitpost/twitpost.py
View file

@ -48,7 +48,7 @@ class TwitpostBot:
status = self.post(" ".join(content[1:]))
screen_name = status["user"]["screen_name"]
id_str = status["id_str"]
bot_reply = "https://twitter.com/{}/status/{}".format(screen_name, id_str)
bot_reply = f"https://twitter.com/{screen_name}/status/{id_str}"
bot_reply = "Tweet Posted\n" + bot_reply
bot_handler.send_reply(message, bot_reply)

28
zulip_bots/zulip_bots/bots/virtual_fs/virtual_fs.py
View file

@ -25,7 +25,7 @@ class VirtualFsHandler:
recipient = message["display_recipient"]
if isinstance(recipient, list): # If not a stream, then hash on list of emails
recipient = " ".join([x["email"] for x in recipient])
recipient = " ".join(x["email"] for x in recipient)
storage = bot_handler.storage
if not storage.contains(recipient):
@ -34,7 +34,7 @@ class VirtualFsHandler:
if sender not in fs["user_paths"]:
fs["user_paths"][sender] = "/"
fs, msg = fs_command(fs, sender, command)
prependix = "{}:\n".format(sender)
prependix = f"{sender}:\n"
msg = prependix + msg
storage.put(recipient, fs)
@ -170,7 +170,7 @@ def syntax_help(cmd_name: str) -> str:
cmd = cmd_name + " " + arg_syntax
else:
cmd = cmd_name
return "syntax: {}".format(cmd)
return f"syntax: {cmd}"
def fs_new() -> Dict[str, Any]:
@ -190,7 +190,7 @@ def fs_mkdir(fs: Dict[str, Any], user: str, fn: str) -> Tuple[Dict[str, Any], An
return fs, "ERROR: file already exists"
dir_path = os.path.dirname(path)
if not is_directory(fs, dir_path):
msg = "ERROR: {} is not a directory".format(dir_path)
msg = f"ERROR: {dir_path} is not a directory"
return fs, msg
new_fs = fs.copy()
new_dir = directory({path}.union(fs[dir_path]["fns"]))
@ -211,7 +211,7 @@ def fs_ls(fs: Dict[str, Any], user: str, fn: str) -> Tuple[Dict[str, Any], Any]:
msg = "ERROR: file does not exist"
return fs, msg
if not is_directory(fs, path):
return fs, "ERROR: {} is not a directory".format(path)
return fs, f"ERROR: {path} is not a directory"
fns = fs[path]["fns"]
if not fns:
return fs, "WARNING: directory is empty"
@ -233,7 +233,7 @@ def fs_rm(fs: Dict[str, Any], user: str, fn: str) -> Tuple[Dict[str, Any], Any]:
msg = "ERROR: file does not exist"
return fs, msg
if fs[path]["kind"] == "dir":
msg = "ERROR: {} is a directory, file required".format(nice_path(fs, path))
msg = f"ERROR: {nice_path(fs, path)} is a directory, file required"
return fs, msg
new_fs = fs.copy()
new_fs.pop(path)
@ -251,7 +251,7 @@ def fs_rmdir(fs: Dict[str, Any], user: str, fn: str) -> Tuple[Dict[str, Any], An
msg = "ERROR: directory does not exist"
return fs, msg
if fs[path]["kind"] == "text":
msg = "ERROR: {} is a file, directory required".format(nice_path(fs, path))
msg = f"ERROR: {nice_path(fs, path)} is a file, directory required"
return fs, msg
new_fs = fs.copy()
new_fs.pop(path)
@ -273,7 +273,7 @@ def fs_write(fs: Dict[str, Any], user: str, fn: str, content: str) -> Tuple[Dict
return fs, msg
dir_path = os.path.dirname(path)
if not is_directory(fs, dir_path):
msg = "ERROR: {} is not a directory".format(dir_path)
msg = f"ERROR: {dir_path} is not a directory"
return fs, msg
new_fs = fs.copy()
new_dir = directory({path}.union(fs[dir_path]["fns"]))
@ -291,7 +291,7 @@ def fs_read(fs: Dict[str, Any], user: str, fn: str) -> Tuple[Dict[str, Any], Any
msg = "ERROR: file does not exist"
return fs, msg
if fs[path]["kind"] == "dir":
msg = "ERROR: {} is a directory, file required".format(nice_path(fs, path))
msg = f"ERROR: {nice_path(fs, path)} is a directory, file required"
return fs, msg
val = fs[path]["content"]
return fs, val
@ -305,17 +305,17 @@ def fs_cd(fs: Dict[str, Any], user: str, fn: str) -> Tuple[Dict[str, Any], Any]:
msg = "ERROR: invalid path"
return fs, msg
if fs[path]["kind"] == "text":
msg = "ERROR: {} is a file, directory required".format(nice_path(fs, path))
msg = f"ERROR: {nice_path(fs, path)} is a file, directory required"
return fs, msg
fs["user_paths"][user] = path
return fs, "Current path: {}".format(nice_path(fs, path))
return fs, f"Current path: {nice_path(fs, path)}"
def make_path(fs: Dict[str, Any], user: str, leaf: str) -> List[str]:
if leaf == "/":
return ["/", ""]
if leaf.endswith("/"):
return ["", "ERROR: {} is not a valid name".format(leaf)]
return ["", f"ERROR: {leaf} is not a valid name"]
if leaf.startswith("/"):
return [leaf, ""]
path = fs["user_paths"][user]
@ -331,9 +331,9 @@ def nice_path(fs: Dict[str, Any], path: str) -> str:
if path not in fs:
return "ERROR: the current directory does not exist"
if fs[path]["kind"] == "text":
path_nice = "{}*{}*".format(path[: slash + 1], path[slash + 1 :])
path_nice = f"{path[: slash + 1]}*{path[slash + 1 :]}*"
elif path != "/":
path_nice = "{}/".format(path)
path_nice = f"{path}/"
return path_nice

12
zulip_bots/zulip_bots/bots/xkcd/xkcd.py
View file

@ -79,19 +79,15 @@ def get_xkcd_bot_response(message: Dict[str, str], quoted_name: str) -> str:
elif command.isdigit():
fetched = fetch_xkcd_query(XkcdBotCommand.COMIC_ID, command)
else:
return commands_help % (
"xkcd bot only supports these commands, not `%s`:" % (command,),
)
return commands_help % (f"xkcd bot only supports these commands, not `{command}`:",)
except (requests.exceptions.ConnectionError, XkcdServerError):
logging.exception("Connection error occurred when trying to connect to xkcd server")
return "Sorry, I cannot process your request right now, please try again later!"
except XkcdNotFoundError:
logging.exception(
"XKCD server responded 404 when trying to fetch comic with id %s" % (command,)
)
return "Sorry, there is likely no xkcd comic strip with id: #%s" % (command,)
logging.exception(f"XKCD server responded 404 when trying to fetch comic with id {command}")
return f"Sorry, there is likely no xkcd comic strip with id: #{command}"
else:
return "#%s: **%s**\n[%s](%s)" % (
return "#{}: **{}**\n[{}]({})".format(
fetched["num"],
fetched["title"],
fetched["alt"],

2
zulip_bots/zulip_bots/bots/youtube/youtube.py
View file

@ -130,7 +130,7 @@ def get_bot_response(
).strip()
for title, id in video_list:
reply = reply + "\n * %s - [Watch now](https://www.youtube.com/watch/%s)" % (title, id)
reply = reply + f"\n * {title} - [Watch now](https://www.youtube.com/watch/{id})"
# Using link https://www.youtube.com/watch/<id> to
# prevent showing multiple previews
return reply

30
zulip_bots/zulip_bots/game_handler.py
View file

@ -229,7 +229,7 @@ class GameAdapter:
if sender not in self.user_cache.keys():
self.add_user_to_cache(message)
logging.info("Added {} to user cache".format(sender))
logging.info(f"Added {sender} to user cache")
if self.is_single_player:
if content.lower().startswith("start game with") or content.lower().startswith(
@ -300,7 +300,7 @@ class GameAdapter:
self.send_reply(message, self.help_message())
except Exception as e:
logging.exception(str(e))
self.bot_handler.send_reply(message, "Error {}.".format(e))
self.bot_handler.send_reply(message, f"Error {e}.")
def is_user_in_game(self, user_email: str) -> str:
for instance in self.instances.values():
@ -344,7 +344,7 @@ class GameAdapter:
self.send_reply(message, self.confirm_invitation_accepted(game_id))
self.broadcast(
game_id,
"@**{}** has accepted the invitation.".format(self.get_username_by_email(sender)),
f"@**{self.get_username_by_email(sender)}** has accepted the invitation.",
)
self.start_game_if_ready(game_id)
@ -365,7 +365,7 @@ class GameAdapter:
if len(users) + 1 > self.max_players:
self.send_reply(
message,
"The maximum number of players for this game is {}.".format(self.max_players),
f"The maximum number of players for this game is {self.max_players}.",
)
return
game_id = self.generate_game_id()
@ -411,7 +411,7 @@ class GameAdapter:
self.broadcast(game_id, "Wait... That's me!", include_private=True)
if message["type"] == "stream":
self.broadcast(
game_id, "@**{}** accept".format(self.get_bot_username()), include_private=False
game_id, f"@**{self.get_bot_username()}** accept", include_private=False
)
game_id = self.set_invite_by_user(self.email, True, {"type": "stream"})
self.start_game_if_ready(game_id)
@ -427,7 +427,7 @@ class GameAdapter:
self.send_reply(message, self.confirm_invitation_declined(game_id))
self.broadcast(
game_id,
"@**{}** has declined the invitation.".format(self.get_username_by_email(sender)),
f"@**{self.get_username_by_email(sender)}** has declined the invitation.",
)
if len(self.get_players(game_id, parameter="")) < self.min_players:
self.cancel_game(game_id)
@ -440,7 +440,7 @@ class GameAdapter:
if game_id == "":
self.send_reply(message, "You are not in a game. Type `help` for all commands.")
sender_name = self.get_username_by_email(sender)
self.cancel_game(game_id, reason="**{}** quit.".format(sender_name))
self.cancel_game(game_id, reason=f"**{sender_name}** quit.")
def command_join(self, message: Dict[str, Any], sender: str, content: str) -> None:
if not self.is_user_not_player(sender, message):
@ -472,7 +472,7 @@ class GameAdapter:
else:
self.send_reply(
message,
"Join {} more players to start the game".format(self.max_players - num_players),
f"Join {self.max_players - num_players} more players to start the game",
)
def command_leaderboard(self, message: Dict[str, Any], sender: str, content: str) -> None:
@ -483,9 +483,9 @@ class GameAdapter:
raw_headers = ["games_won", "games_drawn", "games_lost", "total_games"]
headers = ["Player"] + [key.replace("_", " ").title() for key in raw_headers]
response += " | ".join(headers)
response += "\n" + " | ".join([" --- " for header in headers])
response += "\n" + " | ".join(" --- " for header in headers)
for player, stat in top_stats:
response += "\n **{}** | ".format(self.get_username_by_email(player))
response += f"\n **{self.get_username_by_email(player)}** | "
values = [str(stat[key]) for key in raw_headers]
response += " | ".join(values)
self.send_reply(message, response)
@ -536,7 +536,7 @@ class GameAdapter:
self.instances[game_id] = GameInstance(self, False, subject, game_id, players, stream)
self.broadcast(
game_id,
"The game has started in #{} {}".format(stream, self.instances[game_id].subject)
f"The game has started in #{stream} {self.instances[game_id].subject}"
+ "\n"
+ self.get_formatted_game_object(game_id),
)
@ -564,7 +564,7 @@ class GameAdapter:
return
self.invites[game_id].update({user_email: "a"})
self.broadcast(
game_id, "@**{}** has joined the game".format(self.get_username_by_email(user_email))
game_id, f"@**{self.get_username_by_email(user_email)}** has joined the game"
)
self.start_game_if_ready(game_id)
@ -873,7 +873,7 @@ class GameInstance:
def get_player_text(self) -> str:
player_text = ""
for player in self.players:
player_text += " @**{}**".format(self.gameAdapter.get_username_by_email(player))
player_text += f" @**{self.gameAdapter.get_username_by_email(player)}**"
return player_text
def get_start_message(self) -> str:
@ -890,7 +890,7 @@ class GameInstance:
def handle_message(self, content: str, player_email: str) -> None:
if content == "forfeit":
player_name = self.gameAdapter.get_username_by_email(player_email)
self.broadcast("**{}** forfeited!".format(player_name))
self.broadcast(f"**{player_name}** forfeited!")
self.end_game("except:" + player_email)
return
if content == "draw":
@ -1032,7 +1032,7 @@ class GameInstance:
loser = winner.lstrip("except:")
else:
winner_name = self.gameAdapter.get_username_by_email(winner)
self.broadcast("**{}** won! :tada:".format(winner_name))
self.broadcast(f"**{winner_name}** won! :tada:")
for u in self.players:
values = {"total_games": 1, "games_won": 0, "games_lost": 0, "games_drawn": 0}
if loser == "":

14
zulip_bots/zulip_bots/lib.py
View file

@ -139,13 +139,13 @@ class StateHandler:
self._client = client
self.marshal = lambda obj: json.dumps(obj)
self.demarshal = lambda obj: json.loads(obj)
self.state_ = dict()
self.state_: Dict[str, Any] = dict()
def put(self, key: str, value: Any) -> None:
self.state_[key] = self.marshal(value)
response = self._client.update_storage({"storage": {key: self.state_[key]}})
if response["result"] != "success":
raise StateHandlerError("Error updating state: {}".format(str(response)))
raise StateHandlerError(f"Error updating state: {str(response)}")
def get(self, key: str) -> Any:
if key in self.state_:
@ -423,8 +423,8 @@ def is_private_message_but_not_group_pm(
def display_config_file_errors(error_msg: str, config_file: str) -> None:
file_contents = open(config_file).read()
print("\nERROR: {} seems to be broken:\n\n{}".format(config_file, file_contents))
print("\nMore details here:\n\n{}\n".format(error_msg))
print(f"\nERROR: {config_file} seems to be broken:\n\n{file_contents}")
print(f"\nMore details here:\n\n{error_msg}\n")
def prepare_message_handler(bot: str, bot_handler: BotHandler, bot_lib_module: Any) -> Any:
@ -459,7 +459,7 @@ def run_message_handler_for_bot(
bot_details.update(getattr(lib_module.handler_class, "META", {}))
# Make sure you set up your ~/.zuliprc
client_name = "Zulip{}Bot".format(bot_name.capitalize())
client_name = f"Zulip{bot_name.capitalize()}Bot"
try:
client = Client(config_file=config_file, client=client_name)
@ -479,9 +479,7 @@ def run_message_handler_for_bot(
if hasattr(message_handler, "usage"):
print(message_handler.usage())
else:
print(
"WARNING: {} is missing usage handler, please add one eventually".format(bot_name)
)
print(f"WARNING: {bot_name} is missing usage handler, please add one eventually")
def handle_message(message: Dict[str, Any], flags: List[str]) -> None:
logging.info("waiting for next message")

2
zulip_bots/zulip_bots/provision.py
View file

@ -21,7 +21,7 @@ def provision_bot(path_to_bot: str, force: bool) -> None:
req_path = os.path.join(path_to_bot, "requirements.txt")
if os.path.isfile(req_path):
bot_name = os.path.basename(path_to_bot)
logging.info("Installing dependencies for {}...".format(bot_name))
logging.info(f"Installing dependencies for {bot_name}...")
# pip install -r $BASEDIR/requirements.txt -t $BASEDIR/bot_dependencies --quiet
rcode = subprocess.call(["pip", "install", "-r", req_path])

2
zulip_bots/zulip_bots/run.py
View file

@ -63,7 +63,7 @@ def exit_gracefully_if_zulip_config_is_missing(config_file: Optional[str]) -> No
# but we'll catch those later.
return
else:
error_msg = "ERROR: %s does not exist." % (config_file,)
error_msg = f"ERROR: {config_file} does not exist."
else:
if zulip_env_vars_are_present():

6
zulip_bots/zulip_bots/simple_lib.py
View file

@ -33,15 +33,13 @@ class MockMessageServer:
return message
def add_reaction(self, reaction_data):
return dict(
result="success", msg="", uri="https://server/messages/{}/reactions".format(uuid4())
)
return dict(result="success", msg="", uri=f"https://server/messages/{uuid4()}/reactions")
def update(self, message):
self.messages[message["message_id"]] = message
def upload_file(self, file):
return dict(result="success", msg="", uri="https://server/user_uploads/{}".format(uuid4()))
return dict(result="success", msg="", uri=f"https://server/user_uploads/{uuid4()}")
class TerminalBotHandler:

2
zulip_bots/zulip_bots/terminal.py
View file

@ -44,7 +44,7 @@ def main():
if lib_module is None:
raise OSError
except OSError:
print("Could not find and import bot '{}'".format(bot_name))
print(f"Could not find and import bot '{bot_name}'")
sys.exit(1)
try:

2
zulip_bots/zulip_bots/test_file_utils.py
View file

@ -27,7 +27,7 @@ def read_bot_fixture_data(bot_name: str, test_name: str) -> Dict[str, Any]:
base_path = os.path.realpath(
os.path.join(os.path.dirname(os.path.abspath(__file__)), "bots", bot_name, "fixtures")
)
http_data_path = os.path.join(base_path, "{}.json".format(test_name))
http_data_path = os.path.join(base_path, f"{test_name}.json")
with open(http_data_path, encoding="utf-8") as f:
content = f.read()
http_data = json.loads(content)

4
zulip_botserver/setup.py
View file

@ -72,11 +72,11 @@ except ImportError:
except (ImportError, AssertionError):
if version is not None:
print(
"{name}>={version} is not installed.".format(name=module_name, version=version),
f"{module_name}>={version} is not installed.",
file=sys.stderr,
)
else:
print("{name} is not installed.".format(name=module_name), file=sys.stderr)
print(f"{module_name} is not installed.", file=sys.stderr)
sys.exit(1)
check_dependency_manually("zulip")

4
zulip_botserver/tests/server_test_lib.py
View file

@ -1,9 +1,7 @@
import configparser
import json
from typing import Any, Dict, List, Optional
from unittest import TestCase
import mock
from unittest import TestCase, mock
from zulip_botserver import server

3
zulip_botserver/tests/test_server.py
View file

@ -6,8 +6,7 @@ from importlib import import_module
from pathlib import Path
from types import ModuleType
from typing import Any, Dict
import mock
from unittest import mock
from zulip_bots.lib import BotHandler
from zulip_botserver import server

4
zulip_botserver/zulip_botserver/server.py
View file

@ -98,7 +98,7 @@ def read_config_file(
ignored_sections = parser.sections()[1:]
if len(ignored_sections) > 0:
logging.warning("Sections except the '{}' will be ignored".format(bot_section))
logging.warning(f"Sections except the '{bot_section}' will be ignored")
return bots_config
@ -106,7 +106,7 @@ def read_config_file(
def parse_config_file(config_file_path: str) -> configparser.ConfigParser:
config_file_path = os.path.abspath(os.path.expanduser(config_file_path))
if not os.path.isfile(config_file_path):
raise OSError("Could not read config file {}: File not found.".format(config_file_path))
raise OSError(f"Could not read config file {config_file_path}: File not found.")
parser = configparser.ConfigParser()
parser.read(config_file_path)
return parser