janek/mostr-zulip-bot
1
0
Fork 0
Code Issues Pull requests Releases Activity

ruff: Fix N803 Argument name should be lowercase.

Browse source 
Signed-off-by: Anders Kaseorg <anders@zulip.com>
This commit is contained in:
Anders Kaseorg 2023-10-30 10:28:39 -07:00
parent d5ad3300c7
commit 5e708e3661
8 changed files with 53 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -97,8 +97,8 @@ class JabberToZulipBot(ClientXMPP):
self.register_plugin("xep_0045") # Jabber chatrooms self.register_plugin("xep_0045") # Jabber chatrooms
self.register_plugin("xep_0199") # XMPP Ping self.register_plugin("xep_0199") # XMPP Ping
def set_zulip_client(self, zulipToJabberClient: "ZulipToJabberBot") -> None: def set_zulip_client(self, zulip_to_jabber_client: "ZulipToJabberBot") -> None:
self.zulipToJabber = zulipToJabberClient self.zulip_to_jabber = zulip_to_jabber_client
def session_start(self, event: Dict[str, Any]) -> None: def session_start(self, event: Dict[str, Any]) -> None:
self.get_roster() self.get_roster()
@ -161,7 +161,7 @@ class JabberToZulipBot(ClientXMPP):
to=recipient, to=recipient,
content=msg["body"], content=msg["body"],
) )
ret = self.zulipToJabber.client.send_message(zulip_message) ret = self.zulip_to_jabber.client.send_message(zulip_message)
if ret.get("result") != "success": if ret.get("result") != "success":
logging.error(str(ret)) logging.error(str(ret))
@ -188,7 +188,7 @@ class JabberToZulipBot(ClientXMPP):
to=stream, to=stream,
content=msg["body"], content=msg["body"],
) )
ret = self.zulipToJabber.client.send_message(zulip_message) ret = self.zulip_to_jabber.client.send_message(zulip_message)
if ret.get("result") != "success": if ret.get("result") != "success":
logging.error(str(ret)) logging.error(str(ret))
@ -267,7 +267,7 @@ class ZulipToJabberBot:
self.jabber.leave_muc(stream_to_room(stream)) self.jabber.leave_muc(stream_to_room(stream))
def get_rooms(zulipToJabber: ZulipToJabberBot) -> List[str]: def get_rooms(zulip_to_jabber: ZulipToJabberBot) -> List[str]:
def get_stream_infos(key: str, method: Callable[[], Dict[str, Any]]) -> Any: def get_stream_infos(key: str, method: Callable[[], Dict[str, Any]]) -> Any:
ret = method() ret = method()
if ret.get("result") != "success": if ret.get("result") != "success":
@ -276,9 +276,9 @@ def get_rooms(zulipToJabber: ZulipToJabberBot) -> List[str]:
return ret[key] return ret[key]
if options.mode == "public": if options.mode == "public":
stream_infos = get_stream_infos("streams", zulipToJabber.client.get_streams) stream_infos = get_stream_infos("streams", zulip_to_jabber.client.get_streams)
else: else:
stream_infos = get_stream_infos("subscriptions", zulipToJabber.client.get_subscriptions) stream_infos = get_stream_infos("subscriptions", zulip_to_jabber.client.get_subscriptions)
rooms: List[str] = [] rooms: List[str] = []
for stream_info in stream_infos: for stream_info in stream_infos:

8
zulip_bots/zulip_bots/bots/connect_four/test_connect_four.py
View file

@ -88,13 +88,13 @@ class TestConnectFourBot(BotTestCase, DefaultTests):
:white_circle: :white_circle: " :white_circle: :white_circle: "
) )
bot, bot_handler = self._get_handlers() bot, bot_handler = self._get_handlers()
self.assertEqual(bot.gameMessageHandler.parse_board(self.almost_win_board), board) self.assertEqual(bot.game_message_handler.parse_board(self.almost_win_board), board)
self.assertEqual(bot.gameMessageHandler.get_player_color(1), ":red_circle:") self.assertEqual(bot.game_message_handler.get_player_color(1), ":red_circle:")
self.assertEqual( self.assertEqual(
bot.gameMessageHandler.alert_move_message("foo", "move 6"), "foo moved in column 6" bot.game_message_handler.alert_move_message("foo", "move 6"), "foo moved in column 6"
) )
self.assertEqual( self.assertEqual(
bot.gameMessageHandler.game_start_message(), bot.game_message_handler.game_start_message(),
"Type `move <column-number>` or `<column-number>` to place a token.\n\ "Type `move <column-number>` or `<column-number>` to place a token.\n\
The first player to get 4 in a row wins!\n Good Luck!", The first player to get 4 in a row wins!\n Good Luck!",
) )

6
zulip_bots/zulip_bots/bots/game_of_fifteen/test_game_of_fifteen.py
View file

@ -58,10 +58,10 @@ class TestGameOfFifteenBot(BotTestCase, DefaultTests):
def test_game_message_handler_responses(self) -> None: def test_game_message_handler_responses(self) -> None:
board = "\n\n:grey_question::one::two:\n\n:three::four::five:\n\n:six::seven::eight:" board = "\n\n:grey_question::one::two:\n\n:three::four::five:\n\n:six::seven::eight:"
bot, bot_handler = self._get_handlers() bot, bot_handler = self._get_handlers()
self.assertEqual(bot.gameMessageHandler.parse_board(self.winning_board), board) self.assertEqual(bot.game_message_handler.parse_board(self.winning_board), board)
self.assertEqual(bot.gameMessageHandler.alert_move_message("foo", "move 1"), "foo moved 1") self.assertEqual(bot.game_message_handler.alert_move_message("foo", "move 1"), "foo moved 1")
self.assertEqual( self.assertEqual(
bot.gameMessageHandler.game_start_message(), bot.game_message_handler.game_start_message(),
"Welcome to Game of Fifteen!" "Welcome to Game of Fifteen!"
"To make a move, type @-mention `move <tile1> <tile2> ...`", "To make a move, type @-mention `move <tile1> <tile2> ...`",
) )

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

@ -78,7 +78,7 @@ class TestMerelsBot(BotTestCase, DefaultTests):
def _get_game_handlers(self) -> Tuple[Any, Any]: def _get_game_handlers(self) -> Tuple[Any, Any]:
bot, bot_handler = self._get_handlers() bot, bot_handler = self._get_handlers()
return bot.model, bot.gameMessageHandler return bot.model, bot.game_message_handler
def _test_parse_board(self, board: str, expected_response: str) -> None: def _test_parse_board(self, board: str, expected_response: str) -> None:
model, message_handler = self._get_game_handlers() model, message_handler = self._get_game_handlers()

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

@ -169,4 +169,4 @@ class TestTicTacToeBot(BotTestCase, DefaultTests):
def _get_game_handlers(self) -> Tuple[Any, Any]: def _get_game_handlers(self) -> Tuple[Any, Any]:
bot, bot_handler = self._get_handlers() bot, bot_handler = self._get_handlers()
return bot.model, bot.gameMessageHandler return bot.model, bot.game_message_handler

66
zulip_bots/zulip_bots/game_handler.py
View file

@ -43,7 +43,7 @@ class GameAdapter:
move_help_message: str, move_help_message: str,
move_regex: str, move_regex: str,
model: Any, model: Any,
gameMessageHandler: Any, game_message_handler: Any,
rules: str, rules: str,
max_players: int = 2, max_players: int = 2,
min_players: int = 2, min_players: int = 2,
@ -58,7 +58,7 @@ class GameAdapter:
self.min_players = min_players self.min_players = min_players
self.is_single_player = self.min_players == self.max_players == 1 self.is_single_player = self.min_players == self.max_players == 1
self.supports_computer = supports_computer self.supports_computer = supports_computer
self.gameMessageHandler = gameMessageHandler() self.game_message_handler = game_message_handler()
self.invites: Dict[str, Dict[str, str]] = {} self.invites: Dict[str, Dict[str, str]] = {}
self.instances: Dict[str, Any] = {} self.instances: Dict[str, Any] = {}
self.user_cache: Dict[str, Dict[str, Any]] = {} self.user_cache: Dict[str, Dict[str, Any]] = {}
@ -824,20 +824,20 @@ class GameInstance:
def __init__( def __init__(
self, self,
gameAdapter: GameAdapter, game_adapter: GameAdapter,
is_private: bool, is_private: bool,
subject: str, subject: str,
game_id: str, game_id: str,
players: List[str], players: List[str],
stream: str, stream: str,
) -> None: ) -> None:
self.gameAdapter = gameAdapter self.game_adapter = game_adapter
self.is_private = is_private self.is_private = is_private
self.subject = subject self.subject = subject
self.game_id = game_id self.game_id = game_id
self.players = players self.players = players
self.stream = stream self.stream = stream
self.model = deepcopy(self.gameAdapter.model()) self.model = deepcopy(self.game_adapter.model())
self.board = self.model.current_board self.board = self.model.current_board
self.turn = random.randrange(0, len(players)) - 1 self.turn = random.randrange(0, len(players)) - 1
self.current_draw: Dict[str, bool] = {} self.current_draw: Dict[str, bool] = {}
@ -858,23 +858,23 @@ class GameInstance:
def get_player_text(self) -> str: def get_player_text(self) -> str:
player_text = "" player_text = ""
for player in self.players: for player in self.players:
player_text += f" @**{self.gameAdapter.get_username_by_email(player)}**" player_text += f" @**{self.game_adapter.get_username_by_email(player)}**"
return player_text return player_text
def get_start_message(self) -> str: def get_start_message(self) -> str:
start_message = "Game `{}` started.\n*Remember to start your message with* @**{}**".format( start_message = "Game `{}` started.\n*Remember to start your message with* @**{}**".format(
self.game_id, self.gameAdapter.get_bot_username() self.game_id, self.game_adapter.get_bot_username()
) )
if not self.is_private: if not self.is_private:
player_text = "\n**Players**" player_text = "\n**Players**"
player_text += self.get_player_text() player_text += self.get_player_text()
start_message += player_text start_message += player_text
start_message += "\n" + self.gameAdapter.gameMessageHandler.game_start_message() start_message += "\n" + self.game_adapter.game_message_handler.game_start_message()
return start_message return start_message
def handle_message(self, content: str, player_email: str) -> None: def handle_message(self, content: str, player_email: str) -> None:
if content == "forfeit": if content == "forfeit":
player_name = self.gameAdapter.get_username_by_email(player_email) player_name = self.game_adapter.get_username_by_email(player_email)
self.broadcast(f"**{player_name}** forfeited!") self.broadcast(f"**{player_name}** forfeited!")
self.end_game("except:" + player_email) self.end_game("except:" + player_email)
return return
@ -885,7 +885,7 @@ class GameInstance:
self.current_draw = {p: False for p in self.players} self.current_draw = {p: False for p in self.players}
self.broadcast( self.broadcast(
"**{}** has voted for a draw!\nType `draw` to accept".format( "**{}** has voted for a draw!\nType `draw` to accept".format(
self.gameAdapter.get_username_by_email(player_email) self.game_adapter.get_username_by_email(player_email)
) )
) )
self.current_draw[player_email] = True self.current_draw[player_email] = True
@ -895,18 +895,18 @@ class GameInstance:
if self.is_turn_of(player_email): if self.is_turn_of(player_email):
self.handle_current_player_command(content) self.handle_current_player_command(content)
else: else:
if self.gameAdapter.is_single_player: if self.game_adapter.is_single_player:
self.broadcast("It's your turn") self.broadcast("It's your turn")
else: else:
self.broadcast( self.broadcast(
"It's **{}**'s ({}) turn.".format( "It's **{}**'s ({}) turn.".format(
self.gameAdapter.get_username_by_email(self.players[self.turn]), self.game_adapter.get_username_by_email(self.players[self.turn]),
self.gameAdapter.gameMessageHandler.get_player_color(self.turn), self.game_adapter.game_message_handler.get_player_color(self.turn),
) )
) )
def broadcast(self, content: str) -> None: def broadcast(self, content: str) -> None:
self.gameAdapter.broadcast(self.game_id, content) self.game_adapter.broadcast(self.game_id, content)
def check_draw(self) -> bool: def check_draw(self) -> bool:
for d in self.current_draw.values(): for d in self.current_draw.values():
@ -915,9 +915,9 @@ class GameInstance:
return len(self.current_draw.values()) > 0 return len(self.current_draw.values()) > 0
def handle_current_player_command(self, content: str) -> None: def handle_current_player_command(self, content: str) -> None:
re_result = self.gameAdapter.move_regex.match(content) re_result = self.game_adapter.move_regex.match(content)
if re_result is None: if re_result is None:
self.broadcast(self.gameAdapter.move_help_message) self.broadcast(self.game_adapter.move_help_message)
return return
self.make_move(content, False) self.make_move(content, False)
@ -934,8 +934,8 @@ class GameInstance:
return return
if not is_computer: if not is_computer:
self.current_messages.append( self.current_messages.append(
self.gameAdapter.gameMessageHandler.alert_move_message( self.game_adapter.game_message_handler.alert_move_message(
f"**{self.gameAdapter.get_username_by_email(self.players[self.turn])}**", f"**{self.game_adapter.get_username_by_email(self.players[self.turn])}**",
content, content,
) )
) )
@ -955,8 +955,8 @@ class GameInstance:
def same_player_turn(self, content: str, message: str, is_computer: bool) -> None: def same_player_turn(self, content: str, message: str, is_computer: bool) -> None:
if not is_computer: if not is_computer:
self.current_messages.append( self.current_messages.append(
self.gameAdapter.gameMessageHandler.alert_move_message( self.game_adapter.game_message_handler.alert_move_message(
f"**{self.gameAdapter.get_username_by_email(self.players[self.turn])}**", f"**{self.game_adapter.get_username_by_email(self.players[self.turn])}**",
content, content,
) )
) )
@ -972,29 +972,29 @@ class GameInstance:
return return
self.current_messages.append( self.current_messages.append(
"It's **{}**'s ({}) turn.".format( "It's **{}**'s ({}) turn.".format(
self.gameAdapter.get_username_by_email(self.players[self.turn]), self.game_adapter.get_username_by_email(self.players[self.turn]),
self.gameAdapter.gameMessageHandler.get_player_color(self.turn), self.game_adapter.game_message_handler.get_player_color(self.turn),
) )
) )
self.broadcast_current_message() self.broadcast_current_message()
if self.players[self.turn] == self.gameAdapter.email: if self.players[self.turn] == self.game_adapter.email:
self.make_move("", True) self.make_move("", True)
def next_turn(self) -> None: def next_turn(self) -> None:
self.turn += 1 self.turn += 1
if self.turn >= len(self.players): if self.turn >= len(self.players):
self.turn = 0 self.turn = 0
if self.gameAdapter.is_single_player: if self.game_adapter.is_single_player:
self.current_messages.append("It's your turn.") self.current_messages.append("It's your turn.")
else: else:
self.current_messages.append( self.current_messages.append(
"It's **{}**'s ({}) turn.".format( "It's **{}**'s ({}) turn.".format(
self.gameAdapter.get_username_by_email(self.players[self.turn]), self.game_adapter.get_username_by_email(self.players[self.turn]),
self.gameAdapter.gameMessageHandler.get_player_color(self.turn), self.game_adapter.game_message_handler.get_player_color(self.turn),
) )
) )
self.broadcast_current_message() self.broadcast_current_message()
if self.players[self.turn] == self.gameAdapter.email: if self.players[self.turn] == self.game_adapter.email:
self.make_move("", True) self.make_move("", True)
def broadcast_current_message(self) -> None: def broadcast_current_message(self) -> None:
@ -1003,7 +1003,7 @@ class GameInstance:
self.current_messages = [] self.current_messages = []
def parse_current_board(self) -> Any: def parse_current_board(self) -> Any:
return self.gameAdapter.gameMessageHandler.parse_board(self.model.current_board) return self.game_adapter.game_message_handler.parse_board(self.model.current_board)
def end_game(self, winner: str) -> None: def end_game(self, winner: str) -> None:
loser = "" loser = ""
@ -1012,7 +1012,7 @@ class GameInstance:
elif winner.startswith("except:"): elif winner.startswith("except:"):
loser = winner.lstrip("except:") loser = winner.lstrip("except:")
else: else:
winner_name = self.gameAdapter.get_username_by_email(winner) winner_name = self.game_adapter.get_username_by_email(winner)
self.broadcast(f"**{winner_name}** won! :tada:") self.broadcast(f"**{winner_name}** won! :tada:")
for u in self.players: for u in self.players:
values = {"total_games": 1, "games_won": 0, "games_lost": 0, "games_drawn": 0} values = {"total_games": 1, "games_won": 0, "games_lost": 0, "games_drawn": 0}
@ -1028,13 +1028,13 @@ class GameInstance:
values.update({"games_lost": 1}) values.update({"games_lost": 1})
else: else:
values.update({"games_won": 1}) values.update({"games_won": 1})
self.gameAdapter.add_user_statistics(u, values) self.game_adapter.add_user_statistics(u, values)
if self.gameAdapter.email in self.players: if self.game_adapter.email in self.players:
self.send_win_responses(winner) self.send_win_responses(winner)
self.gameAdapter.cancel_game(self.game_id) self.game_adapter.cancel_game(self.game_id)
def send_win_responses(self, winner: str) -> None: def send_win_responses(self, winner: str) -> None:
if winner == self.gameAdapter.email: if winner == self.game_adapter.email:
self.broadcast("I won! Well Played!") self.broadcast("I won! Well Played!")
elif winner == "draw": elif winner == "draw":
self.broadcast("It was a draw! Well Played!") self.broadcast("It was a draw! Well Played!")

6
zulip_botserver/tests/server_test_lib.py
View file

@ -17,7 +17,7 @@ class BotServerTestCase(TestCase):
@mock.patch("zulip_bots.lib.ExternalBotHandler") @mock.patch("zulip_bots.lib.ExternalBotHandler")
def assert_bot_server_response( def assert_bot_server_response(
self, self,
mock_ExternalBotHandler: mock.Mock, mock_external_bot_handler: mock.Mock,
available_bots: Optional[List[str]] = None, available_bots: Optional[List[str]] = None,
bots_config: Optional[Dict[str, Dict[str, str]]] = None, bots_config: Optional[Dict[str, Dict[str, str]]] = None,
bot_handlers: Optional[Dict[str, Any]] = None, bot_handlers: Optional[Dict[str, Any]] = None,
@ -40,13 +40,13 @@ class BotServerTestCase(TestCase):
server.app.config["BOT_HANDLERS"] = bot_handlers server.app.config["BOT_HANDLERS"] = bot_handlers
server.app.config["MESSAGE_HANDLERS"] = message_handlers server.app.config["MESSAGE_HANDLERS"] = message_handlers
mock_ExternalBotHandler.return_value.full_name = "test" mock_external_bot_handler.return_value.full_name = "test"
response = self.app.post(data=json.dumps(event)) response = self.app.post(data=json.dumps(event))
# NOTE: Currently, assert_bot_server_response can only check the expected_response # NOTE: Currently, assert_bot_server_response can only check the expected_response
# for bots that use send_reply. However, the vast majority of bots use send_reply. # for bots that use send_reply. However, the vast majority of bots use send_reply.
# Therefore, the Botserver can be still be effectively tested. # Therefore, the Botserver can be still be effectively tested.
bot_send_reply_call = mock_ExternalBotHandler.return_value.send_reply bot_send_reply_call = mock_external_bot_handler.return_value.send_reply
if expected_response is not None: if expected_response is not None:
self.assertTrue(bot_send_reply_call.called) self.assertTrue(bot_send_reply_call.called)
self.assertEqual(expected_response, bot_send_reply_call.call_args[0][1]) self.assertEqual(expected_response, bot_send_reply_call.call_args[0][1])

2
zulip_botserver/tests/test_server.py
View file

@ -127,7 +127,7 @@ class BotServerTests(BotServerTestCase):
@mock.patch("logging.error") @mock.patch("logging.error")
@mock.patch("zulip_bots.lib.StateHandler") @mock.patch("zulip_bots.lib.StateHandler")
def test_wrong_bot_credentials( def test_wrong_bot_credentials(
self, mock_StateHandler: mock.Mock, mock_LoggingError: mock.Mock self, mock_state_handler: mock.Mock, mock_logging_error: mock.Mock
) -> None: ) -> None:
available_bots = ["nonexistent-bot"] available_bots = ["nonexistent-bot"]
bots_config = { bots_config = {