ruff: Fix N803 Argument name should be lowercase.

Signed-off-by: Anders Kaseorg <[email protected]>

Author: andersk

zulip/integrations/jabber/jabber_mirror_backend.py

@@ -97,8 +97,8 @@ def __init__(self, jid: JID, password: str, rooms: List[str]) -> None:
         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 @@ def private(self, msg: JabberMessage) -> None:
             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 @@ def group(self, msg: JabberMessage) -> None:
             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 @@ def process_subscription(self, event: Dict[str, Any]) -> None:
                 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_stream_infos(key: str, method: Callable[[], Dict[str, Any]]) -> Any:
         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:

zulip_bots/zulip_bots/bots/connect_four/test_connect_four.py

@@ -88,13 +88,13 @@ def test_game_message_handler_responses(self) -> None:
 :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!",
         )

zulip_bots/zulip_bots/bots/game_of_fifteen/test_game_of_fifteen.py

@@ -58,10 +58,10 @@ def test_static_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:"
         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> ...`",
         )

zulip_bots/zulip_bots/bots/merels/test_merels.py

@@ -78,7 +78,7 @@ def setup_game(self) -> None:
 
     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()

zulip_bots/zulip_bots/bots/tictactoe/test_tictactoe.py

@@ -169,4 +169,4 @@ def setup_game(self) -> None:
 
     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

zulip_bots/zulip_bots/game_handler.py

@@ -43,7 +43,7 @@ def __init__(
         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 @@ def __init__(
         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 @@ def change_subject(self, stream: str, subject: str) -> None:
     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 @@ def handle_message(self, content: str, player_email: str) -> None:
                 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 @@ def handle_message(self, content: str, player_email: str) -> None:
         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 @@ def check_draw(self) -> bool:
         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 @@ def make_move(self, content: str, is_computer: bool) -> None:
             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 @@ def is_turn_of(self, player_email: str) -> bool:
     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 @@ def same_player_turn(self, content: str, message: str, is_computer: bool) -> Non
             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 @@ def broadcast_current_message(self) -> None:
         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 @@ def end_game(self, winner: str) -> None:
         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 @@ def end_game(self, winner: str) -> None:
                     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!")

zulip_botserver/tests/server_test_lib.py

@@ -17,7 +17,7 @@ def setUp(self) -> None:
     @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 @@ def assert_bot_server_response(
             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])

zulip_botserver/tests/test_server.py

@@ -127,7 +127,7 @@ def test_wrong_bot_token(self) -> None:
     @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 = {