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_0199") # XMPP Ping
def set_zulip_client(self, zulipToJabberClient: "ZulipToJabberBot") -> None:
self.zulipToJabber = zulipToJabberClient
def set_zulip_client(self, zulip_to_jabber_client: "ZulipToJabberBot") -> None:
self.zulip_to_jabber = zulip_to_jabber_client
def session_start(self, event: Dict[str, Any]) -> None:
self.get_roster()
@ -161,7 +161,7 @@ class JabberToZulipBot(ClientXMPP):
to=recipient,
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":
logging.error(str(ret))
@ -188,7 +188,7 @@ class JabberToZulipBot(ClientXMPP):
to=stream,
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":
logging.error(str(ret))
@ -267,7 +267,7 @@ class ZulipToJabberBot:
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:
ret = method()
if ret.get("result") != "success":
@ -276,9 +276,9 @@ def get_rooms(zulipToJabber: ZulipToJabberBot) -> List[str]:
return ret[key]
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:
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] = []
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: "
)
bot, bot_handler = self._get_handlers()
self.assertEqual(bot.gameMessageHandler.parse_board(self.almost_win_board), board)
self.assertEqual(bot.gameMessageHandler.get_player_color(1), ":red_circle:")
self.assertEqual(bot.game_message_handler.parse_board(self.almost_win_board), board)
self.assertEqual(bot.game_message_handler.get_player_color(1), ":red_circle:")
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(
bot.gameMessageHandler.game_start_message(),
bot.game_message_handler.game_start_message(),
"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!",
)

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:
board = "\n\n:grey_question::one::two:\n\n:three::four::five:\n\n:six::seven::eight:"
bot, bot_handler = self._get_handlers()
self.assertEqual(bot.gameMessageHandler.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.parse_board(self.winning_board), board)
self.assertEqual(bot.game_message_handler.alert_move_message("foo", "move 1"), "foo moved 1")
self.assertEqual(
bot.gameMessageHandler.game_start_message(),
bot.game_message_handler.game_start_message(),
"Welcome to Game of Fifteen!"
"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]:
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:
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]:
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_regex: str,
model: Any,
gameMessageHandler: Any,
game_message_handler: Any,
rules: str,
max_players: int = 2,
min_players: int = 2,
@ -58,7 +58,7 @@ class GameAdapter:
self.min_players = min_players
self.is_single_player = self.min_players == self.max_players == 1
self.supports_computer = supports_computer
self.gameMessageHandler = gameMessageHandler()
self.game_message_handler = game_message_handler()
self.invites: Dict[str, Dict[str, str]] = {}
self.instances: Dict[str, Any] = {}
self.user_cache: Dict[str, Dict[str, Any]] = {}
@ -824,20 +824,20 @@ class GameInstance:
def __init__(
self,
gameAdapter: GameAdapter,
game_adapter: GameAdapter,
is_private: bool,
subject: str,
game_id: str,
players: List[str],
stream: str,
) -> None:
self.gameAdapter = gameAdapter
self.game_adapter = game_adapter
self.is_private = is_private
self.subject = subject
self.game_id = game_id
self.players = players
self.stream = stream
self.model = deepcopy(self.gameAdapter.model())
self.model = deepcopy(self.game_adapter.model())
self.board = self.model.current_board
self.turn = random.randrange(0, len(players)) - 1
self.current_draw: Dict[str, bool] = {}
@ -858,23 +858,23 @@ class GameInstance:
def get_player_text(self) -> str:
player_text = ""
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
def get_start_message(self) -> str:
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:
player_text = "\n**Players**"
player_text += self.get_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
def handle_message(self, content: str, player_email: str) -> None:
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.end_game("except:" + player_email)
return
@ -885,7 +885,7 @@ class GameInstance:
self.current_draw = {p: False for p in self.players}
self.broadcast(
"**{}** 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
@ -895,18 +895,18 @@ class GameInstance:
if self.is_turn_of(player_email):
self.handle_current_player_command(content)
else:
if self.gameAdapter.is_single_player:
if self.game_adapter.is_single_player:
self.broadcast("It's your turn")
else:
self.broadcast(
"It's **{}**'s ({}) turn.".format(
self.gameAdapter.get_username_by_email(self.players[self.turn]),
self.gameAdapter.gameMessageHandler.get_player_color(self.turn),
self.game_adapter.get_username_by_email(self.players[self.turn]),
self.game_adapter.game_message_handler.get_player_color(self.turn),
)
)
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:
for d in self.current_draw.values():
@ -915,9 +915,9 @@ class GameInstance:
return len(self.current_draw.values()) > 0
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:
self.broadcast(self.gameAdapter.move_help_message)
self.broadcast(self.game_adapter.move_help_message)
return
self.make_move(content, False)
@ -934,8 +934,8 @@ class GameInstance:
return
if not is_computer:
self.current_messages.append(
self.gameAdapter.gameMessageHandler.alert_move_message(
f"**{self.gameAdapter.get_username_by_email(self.players[self.turn])}**",
self.game_adapter.game_message_handler.alert_move_message(
f"**{self.game_adapter.get_username_by_email(self.players[self.turn])}**",
content,
)
)
@ -955,8 +955,8 @@ class GameInstance:
def same_player_turn(self, content: str, message: str, is_computer: bool) -> None:
if not is_computer:
self.current_messages.append(
self.gameAdapter.gameMessageHandler.alert_move_message(
f"**{self.gameAdapter.get_username_by_email(self.players[self.turn])}**",
self.game_adapter.game_message_handler.alert_move_message(
f"**{self.game_adapter.get_username_by_email(self.players[self.turn])}**",
content,
)
)
@ -972,29 +972,29 @@ class GameInstance:
return
self.current_messages.append(
"It's **{}**'s ({}) turn.".format(
self.gameAdapter.get_username_by_email(self.players[self.turn]),
self.gameAdapter.gameMessageHandler.get_player_color(self.turn),
self.game_adapter.get_username_by_email(self.players[self.turn]),
self.game_adapter.game_message_handler.get_player_color(self.turn),
)
)
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)
def next_turn(self) -> None:
self.turn += 1
if self.turn >= len(self.players):
self.turn = 0
if self.gameAdapter.is_single_player:
if self.game_adapter.is_single_player:
self.current_messages.append("It's your turn.")
else:
self.current_messages.append(
"It's **{}**'s ({}) turn.".format(
self.gameAdapter.get_username_by_email(self.players[self.turn]),
self.gameAdapter.gameMessageHandler.get_player_color(self.turn),
self.game_adapter.get_username_by_email(self.players[self.turn]),
self.game_adapter.game_message_handler.get_player_color(self.turn),
)
)
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)
def broadcast_current_message(self) -> None:
@ -1003,7 +1003,7 @@ class GameInstance:
self.current_messages = []
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:
loser = ""
@ -1012,7 +1012,7 @@ class GameInstance:
elif winner.startswith("except:"):
loser = winner.lstrip("except:")
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:")
for u in self.players:
values = {"total_games": 1, "games_won": 0, "games_lost": 0, "games_drawn": 0}
@ -1028,13 +1028,13 @@ class GameInstance:
values.update({"games_lost": 1})
else:
values.update({"games_won": 1})
self.gameAdapter.add_user_statistics(u, values)
if self.gameAdapter.email in self.players:
self.game_adapter.add_user_statistics(u, values)
if self.game_adapter.email in self.players:
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:
if winner == self.gameAdapter.email:
if winner == self.game_adapter.email:
self.broadcast("I won! Well Played!")
elif winner == "draw":
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")
def assert_bot_server_response(
self,
mock_ExternalBotHandler: mock.Mock,
mock_external_bot_handler: mock.Mock,
available_bots: Optional[List[str]] = None,
bots_config: Optional[Dict[str, Dict[str, str]]] = 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["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))
# 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.
# 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:
self.assertTrue(bot_send_reply_call.called)
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("zulip_bots.lib.StateHandler")
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:
available_bots = ["nonexistent-bot"]
bots_config = {