game_handler: add widget_content support

Author: fremiller

zulip_bots/zulip_bots/game_handler.py

@@ -3,7 +3,7 @@
 import random
 import logging
 from copy import deepcopy
-from typing import Any, Dict, Tuple, List
+from typing import Any, Dict, Tuple, List, Union
 from zulip_bots.test_lib import BotTestCase
 import operator
 import random
@@ -16,13 +16,15 @@ def __init__(self, message: str) -> None:
     def __str__(self) -> str:
         return self.message
 
+
 class SamePlayerMove(Exception):
     def __init__(self, message: str) -> None:
         self.message = message
 
     def __str__(self) -> str:
         return self.message
 
+
 class GameAdapter(object):
     '''
     Class that serves as a template to easily
@@ -40,9 +42,9 @@ def __init__(
         model: Any,
         gameMessageHandler: Any,
         rules: str,
-        max_players: int=2,
-        min_players: int=2,
-        supports_computer: bool=False
+        max_players: int = 2,
+        min_players: int = 2,
+        supports_computer: bool = False
     ) -> None:
         self.game_name = game_name
         self.bot_name = bot_name
@@ -155,16 +157,17 @@ def confirm_invitation_declined(self, game_id: str) -> str:
         host = self.invites[game_id]['host']
         return 'Declined invitation to play **{}** from @**{}**.'.format(self.game_name, self.get_username_by_email(host))
 
-    def send_message(self, to: str, content: str, is_private: bool, subject: str='') -> None:
+    def send_message(self, to: str, content: str, is_private: bool, subject: str = '', widget_content: str = '') -> None:
         self.bot_handler.send_message(dict(
             type='private' if is_private else 'stream',
             to=to,
             content=content,
-            subject=subject
+            subject=subject,
+            widget_content=widget_content
         ))
 
-    def send_reply(self, original_message: Dict[str, Any], content: str) -> None:
-        self.bot_handler.send_reply(original_message, content)
+    def send_reply(self, original_message: Dict[str, Any], content: str, widget_content: str = '') -> None:
+        self.bot_handler.send_reply(original_message, content, widget_content)
 
     def usage(self) -> str:
         return '''
@@ -280,7 +283,8 @@ def command_start_game_with(self, message: Dict[str, Any], sender: str, content:
     def command_start_game(self, message: Dict[str, Any], sender: str, content: str) -> None:
         if message['type'] == 'private':
             if self.is_single_player:
-                self.send_reply(message, 'You are not allowed to play games in private messages.')
+                self.send_reply(
+                    message, 'You are not allowed to play games in private messages.')
                 return
             else:
                 self.send_reply(
@@ -309,7 +313,7 @@ def command_accept(self, message: Dict[str, Any], sender: str, content: str) ->
             game_id, '@**{}** has accepted the invitation.'.format(self.get_username_by_email(sender)))
         self.start_game_if_ready(game_id)
 
-    def create_game_lobby(self, message: Dict[str, Any], users: List[str]=[]) -> None:
+    def create_game_lobby(self, message: Dict[str, Any], users: List[str] = []) -> None:
         if self.is_game_in_subject(message['subject'], message['display_recipient']):
             self.send_reply(message, 'There is already a game in this stream.')
             return
@@ -379,14 +383,16 @@ def command_decline(self, message: Dict[str, Any], sender: str, content: str) ->
     def command_quit(self, message: Dict[str, Any], sender: str, content: str) -> None:
         game_id = self.get_game_id_by_email(sender)
         if message['type'] == 'private' and self.is_single_player:
-            self.send_reply(message, 'You are not allowed to play games in private messages.')
+            self.send_reply(
+                message, 'You are not allowed to play games in private messages.')
             return
         if game_id is '':
             self.send_reply(
                 message, 'You are not in a game. Type `help` for all commands.')
         sender_avatar = "!avatar({})".format(sender)
         sender_name = self.get_username_by_email(sender)
-        self.cancel_game(game_id, reason='{} **{}** quit.'.format(sender_avatar, sender_name))
+        self.cancel_game(
+            game_id, reason='{} **{}** quit.'.format(sender_avatar, sender_name))
 
     def command_join(self, message: Dict[str, Any], sender: str, content: str) -> None:
         if not self.is_user_not_player(sender, message):
@@ -417,7 +423,8 @@ def command_play(self, message: Dict[str, Any], sender: str, content: str) -> No
             self.start_game(game_id)
         else:
             self.send_reply(
-                message, 'Join {} more players to start the game'.format(self.max_players-num_players)
+                message, 'Join {} more players to start the game'.format(
+                    self.max_players-num_players)
             )
 
     def command_leaderboard(self, message: Dict[str, Any], sender: str, content: str) -> None:
@@ -451,13 +458,13 @@ def get_sorted_player_statistics(self) -> List[Tuple[str, Dict[str, int]]]:
             reverse=True
         )
 
-    def send_invite(self, game_id: str, user_email: str, message: Dict[str, Any]={}) -> None:
+    def send_invite(self, game_id: str, user_email: str, message: Dict[str, Any] = {}) -> None:
         self.invites[game_id].update({user_email.lower(): 'p'})
         self.send_message(user_email, self.alert_new_invitation(game_id), True)
         if message != {}:
             self.send_reply(message, self.confirm_new_invitation(user_email))
 
-    def cancel_game(self, game_id: str, reason: str='') -> None:
+    def cancel_game(self, game_id: str, reason: str = '') -> None:
         if game_id in self.invites.keys():
             self.broadcast(game_id, 'Game cancelled.\n' + reason)
             del self.invites[game_id]
@@ -497,7 +504,7 @@ def get_formatted_game_object(self, game_id: str) -> str:
                     instance.stream, instance.subject)
         return object
 
-    def join_game(self, game_id: str, user_email: str, message: Dict[str, Any]={}) -> None:
+    def join_game(self, game_id: str, user_email: str, message: Dict[str, Any] = {}) -> None:
         if len(self.get_players(game_id)) >= self.max_players:
             if message != {}:
                 self.send_reply(message, 'This game is full.')
@@ -507,7 +514,7 @@ def join_game(self, game_id: str, user_email: str, message: Dict[str, Any]={}) -
             game_id, '@**{}** has joined the game'.format(self.get_username_by_email(user_email)))
         self.start_game_if_ready(game_id)
 
-    def get_players(self, game_id: str, parameter: str='a') -> List[str]:
+    def get_players(self, game_id: str, parameter: str = 'a') -> List[str]:
         if game_id in self.invites.keys():
             players = []  # type: List[str]
             if (self.invites[game_id]['subject'] == '###private###' and 'p' in parameter) or 'p' not in parameter:
@@ -590,7 +597,7 @@ def change_game_subject(
         game_id: str,
         stream_name: str,
         subject_name: str,
-        message: Dict[str, Any]={}
+        message: Dict[str, Any] = {}
     ) -> None:
         if self.get_game_instance_by_subject(stream_name, subject_name) is not None:
             if message != {}:
@@ -645,7 +652,7 @@ def get_user_cache(self) -> Dict[str, Any]:
         self.user_cache = json.loads(user_cache_str)
         return self.user_cache
 
-    def verify_users(self, users: List[str], message: Dict[str, Any]={}) -> List[str]:
+    def verify_users(self, users: List[str], message: Dict[str, Any] = {}) -> List[str]:
         verified_users = []
         failed = False
         for u in users:
@@ -687,7 +694,7 @@ def is_game_in_subject(self, subject_name: str, stream_name: str) -> bool:
             self.get_game_instance_by_subject(
                 subject_name, stream_name) is not None
 
-    def is_user_not_player(self, user_email: str, message: Dict[str, Any]={}) -> bool:
+    def is_user_not_player(self, user_email: str, message: Dict[str, Any] = {}) -> bool:
         user = self.get_user_by_email(user_email)
         if user == {}:
             if message != {}:
@@ -713,20 +720,20 @@ def generate_game_id(self) -> str:
             id += valid_characters[random.randrange(0, len(valid_characters))]
         return id
 
-    def broadcast(self, game_id: str, content: str, include_private: bool=True) -> bool:
+    def broadcast(self, game_id: str, content: str, include_private: bool = True, widget_content: str = '') -> bool:
         if include_private:
             private_recipients = self.get_players(game_id, parameter='p')
             if private_recipients is not None:
                 for user in private_recipients:
-                    self.send_message(user, content, True)
+                    self.send_message(user, content, True, '', widget_content)
         if game_id in self.invites.keys():
             if self.invites[game_id]['subject'] != '###private###':
                 self.send_message(
-                    self.invites[game_id]['stream'], content, False, self.invites[game_id]['subject'])
+                    self.invites[game_id]['stream'], content, False, self.invites[game_id]['subject'], widget_content)
                 return True
         if game_id in self.instances.keys():
             self.send_message(
-                self.instances[game_id].stream, content, False, self.instances[game_id].subject)
+                self.instances[game_id].stream, content, False, self.instances[game_id].subject, widget_content)
             return True
         return False
 
@@ -774,7 +781,7 @@ def __init__(self, gameAdapter: GameAdapter, is_private: bool, subject: str, gam
         self.board = self.model.current_board
         self.turn = random.randrange(0, len(players)) - 1
         self.current_draw = {}  # type: Dict[str, bool]
-        self.current_messages = []  # type: List[str]
+        self.current_messages = []  # type: List[Union[str, Tuple[str, str]]]
         self.is_changing_subject = False
 
     def start(self) -> None:
@@ -828,20 +835,21 @@ def handle_message(self, content: str, player_email: str) -> None:
             if self.gameAdapter.is_single_player:
                 self.broadcast('It\'s your turn')
             else:
-                user_turn_avatar = "!avatar({})".format(self.players[self.turn])
+                user_turn_avatar = "!avatar({})".format(
+                    self.players[self.turn])
                 if self.gameAdapter.gameMessageHandler.get_player_color(self.turn) is None:
                     self.broadcast('{} It\'s **{}**\'s turn.'.format(
-                    user_turn_avatar,
-                    self.gameAdapter.get_username_by_email(
-                        self.players[self.turn])))
+                        user_turn_avatar,
+                        self.gameAdapter.get_username_by_email(
+                            self.players[self.turn])))
                 else:
                     self.broadcast('{} It\'s **{}**\'s ({}) turn.'.format(
                         user_turn_avatar,
                         self.gameAdapter.get_username_by_email(
                             self.players[self.turn]),
                         self.gameAdapter.gameMessageHandler.get_player_color(self.turn)))
 
-    def broadcast(self, content: str) -> None:
+    def broadcast(self, content: str, widget_content: str = '') -> None:
         self.gameAdapter.broadcast(self.game_id, content)
 
     def check_draw(self) -> bool:
@@ -866,7 +874,11 @@ def make_move(self, content: str, is_computer: bool) -> None:
             return
         except BadMoveException as e:
             self.broadcast(e.message)
-            self.broadcast(self.parse_current_board())
+            current_board_message = self.parse_current_board
+            if isinstance(current_board_message, tuple):
+                self.broadcast(
+                    current_board_message[0], current_board_message[1])
+            self.broadcast(str(current_board_message))
             return
         if not is_computer:
             self.current_messages.append(self.gameAdapter.gameMessageHandler.alert_move_message(
@@ -918,16 +930,24 @@ def next_turn(self) -> None:
             user_turn_avatar = "!avatar({})".format(self.players[self.turn])
             self.current_messages.append('{} It\'s **{}**\'s ({}) turn.'.format(
                 user_turn_avatar,
-                self.gameAdapter.get_username_by_email(self.players[self.turn]),
+                self.gameAdapter.get_username_by_email(
+                    self.players[self.turn]),
                 self.gameAdapter.gameMessageHandler.get_player_color(self.turn)
             ))
         self.broadcast_current_message()
         if self.players[self.turn] == self.gameAdapter.email:
             self.make_move('', True)
 
     def broadcast_current_message(self) -> None:
-        content = '\n\n'.join(self.current_messages)
-        self.broadcast(content)
+        # if there are no widgets, send all the messages all at once
+        if len(list(filter(lambda x: isinstance(x, tuple), self.current_messages))) == 0:
+            self.broadcast("\n\n".join(str(m) for m in self.current_messages))
+        else:
+            for message in self.current_messages:
+                if isinstance(message, tuple):
+                    self.broadcast(message[0], message[1])
+                else:
+                    self.broadcast(str(message))
         self.current_messages = []
 
     def parse_current_board(self) -> Any:
@@ -942,7 +962,8 @@ def end_game(self, winner: str) -> None:
         else:
             winner_avatar = "!avatar({})".format(winner)
             winner_name = self.gameAdapter.get_username_by_email(winner)
-            self.broadcast('{} **{}** won! :tada:'.format(winner_avatar, winner_name))
+            self.broadcast(
+                '{} **{}** won! :tada:'.format(winner_avatar, winner_name))
         for u in self.players:
             values = {'total_games': 1, 'games_won': 0,
                       'games_lost': 0, 'games_drawn': 0}