code style reformatting using black

This commit is contained in:
Goffi 2018-06-27 20:14:46 +02:00
commit 744cb0c503

View file

@ -20,6 +20,7 @@
from sat.core.i18n import _
from sat.core.constants import Const as C
from sat.core.log import getLogger
log = getLogger(__name__)
from twisted.words.protocols.jabber import jid
from twisted.words.xish import domish
@ -28,6 +29,7 @@ from time import time
from wokkel import disco, iwokkel
from zope.interface import implements
import copy
try:
from twisted.words.protocols.xmlstream import XMPPHandler
except ImportError:
@ -44,12 +46,13 @@ PLUGIN_INFO = {
C.PI_DEPENDENCIES: ["XEP-0045", "XEP-0249"],
C.PI_MAIN: "RoomGame",
C.PI_HANDLER: "no", # handler MUST be "no" (dynamic inheritance)
C.PI_DESCRIPTION: _("""Base class for MUC games""")
C.PI_DESCRIPTION: _("""Base class for MUC games"""),
}
# FIXME: this plugin is broken, need to be fixed
class RoomGame(object):
"""This class is used to help launching a MUC game.
@ -69,7 +72,7 @@ class RoomGame(object):
# Values for ready_mode (how to turn a MUC user into a player)
ASK, FORCE = xrange(0, 2)
MESSAGE = '/message'
MESSAGE = "/message"
REQUEST = '%s/%s[@xmlns="%s"]'
def __init__(self, host):
@ -165,8 +168,13 @@ class RoomGame(object):
# Important: do not add the referee to 'players' yet. For a
# <players /> message to be emitted whenever a new player is joining,
# it is necessary to not modify 'players' outside of _updatePlayers.
referee_jid = jid.JID(room_jid.userhost() + '/' + referee_nick)
self.games[room_jid] = {'referee': referee_jid, 'players': [], 'started': False, 'status': {}}
referee_jid = jid.JID(room_jid.userhost() + "/" + referee_nick)
self.games[room_jid] = {
"referee": referee_jid,
"players": [],
"started": False,
"status": {},
}
self.games[room_jid].update(copy.deepcopy(self.game_init))
self.invitations.setdefault(room_jid, [])
@ -175,7 +183,7 @@ class RoomGame(object):
@param started: if False, the game must be initialized to return True,
otherwise it must be initialized and started with createGame.
@return: True if a game is initialized/started in that room"""
return room_jid in self.games and (not started or self.games[room_jid]['started'])
return room_jid in self.games and (not started or self.games[room_jid]["started"])
def _checkJoinAuth(self, room_jid, user_jid=None, nick="", verbose=False):
"""Checks if this profile is allowed to join the game.
@ -209,7 +217,14 @@ class RoomGame(object):
break
if not auth and (verbose or _DEBUG):
log.debug(_(u"%(user)s not allowed to join the game %(game)s in %(room)s") % {'user': user_jid.userhost() or nick, 'game': self.name, 'room': room_jid.userhost()})
log.debug(
_(u"%(user)s not allowed to join the game %(game)s in %(room)s")
% {
"user": user_jid.userhost() or nick,
"game": self.name,
"room": room_jid.userhost(),
}
)
return auth
def _updatePlayers(self, room_jid, nicks, sync, profile):
@ -224,20 +239,26 @@ class RoomGame(object):
if nicks == []:
return
# this is better than set(nicks).difference(...) as it keeps the order
new_nicks = [nick for nick in nicks if nick not in self.games[room_jid]['players']]
new_nicks = [
nick for nick in nicks if nick not in self.games[room_jid]["players"]
]
if len(new_nicks) == 0:
return
def setStatus(status):
for nick in new_nicks:
self.games[room_jid]['status'][nick] = status
self.games[room_jid]["status"][nick] = status
sync = sync and self._gameExists(room_jid, True) and len(self.games[room_jid]['players']) > 0
setStatus('desync' if sync else 'init')
self.games[room_jid]['players'].extend(new_nicks)
sync = (
sync
and self._gameExists(room_jid, True)
and len(self.games[room_jid]["players"]) > 0
)
setStatus("desync" if sync else "init")
self.games[room_jid]["players"].extend(new_nicks)
self._synchronizeRoom(room_jid, [room_jid], profile)
if sync:
setStatus('init')
setStatus("init")
def _synchronizeRoom(self, room_jid, recipients, profile):
"""Communicate the list of players to the whole room or only to some users,
@ -249,15 +270,17 @@ class RoomGame(object):
@param profile (unicode): %(doc_profile)s
"""
if self._gameExists(room_jid, started=True):
element = self._createStartElement(self.games[room_jid]['players'])
element = self._createStartElement(self.games[room_jid]["players"])
else:
element = self._createStartElement(self.games[room_jid]['players'], name="players")
element = self._createStartElement(
self.games[room_jid]["players"], name="players"
)
elements = [(element, None, None)]
sync_args = []
sync_data = self._getSyncData(room_jid)
for nick in sync_data:
user_jid = jid.JID(room_jid.userhost() + '/' + nick)
user_jid = jid.JID(room_jid.userhost() + "/" + nick)
if user_jid in recipients:
user_elements = copy.deepcopy(elements)
for child in sync_data[nick]:
@ -265,7 +288,7 @@ class RoomGame(object):
recipients.remove(user_jid)
else:
user_elements = [(child, None, None) for child in sync_data[nick]]
sync_args.append(([user_jid, user_elements], {'profile': profile}))
sync_args.append(([user_jid, user_elements], {"profile": profile}))
for recipient in recipients:
self._sendElements(recipient, elements, profile=profile)
@ -283,8 +306,8 @@ class RoomGame(object):
if not self._gameExists(room_jid):
return {}
data = {}
status = self.games[room_jid]['status']
nicks = [nick for nick in status if status[nick] == 'desync']
status = self.games[room_jid]["status"]
nicks = [nick for nick in status if status[nick] == "desync"]
if force_nicks is None:
force_nicks = []
for nick in force_nicks:
@ -316,13 +339,19 @@ class RoomGame(object):
if not self._checkInviteAuth(room_jid, nick):
return []
# TODO: remove invitation waiting for too long, using the time data
self.invitations[room_jid].append((time(), [player.userhostJID() for player in other_players]))
self.invitations[room_jid].append(
(time(), [player.userhostJID() for player in other_players])
)
nicks = []
for player_jid in [player.userhostJID() for player in other_players]:
# TODO: find a way to make it secure
other_nick = self.host.plugins["XEP-0045"].getRoomEntityNick(room_jid, player_jid, secure=self.testing)
other_nick = self.host.plugins["XEP-0045"].getRoomEntityNick(
room_jid, player_jid, secure=self.testing
)
if other_nick is None:
self.host.plugins["XEP-0249"].invite(player_jid, room_jid, {"game": self.name}, profile)
self.host.plugins["XEP-0249"].invite(
player_jid, room_jid, {"game": self.name}, profile
)
else:
nicks.append(other_nick)
return nicks
@ -339,13 +368,18 @@ class RoomGame(object):
if self.invite_mode == self.FROM_ALL or not self._gameExists(room_jid):
auth = True
elif self.invite_mode == self.FROM_NONE:
auth = not self._gameExists(room_jid, started=True) and self.isReferee(room_jid, nick)
auth = not self._gameExists(room_jid, started=True) and self.isReferee(
room_jid, nick
)
elif self.invite_mode == self.FROM_REFEREE:
auth = self.isReferee(room_jid, nick)
elif self.invite_mode == self.FROM_PLAYERS:
auth = self.isPlayer(room_jid, nick)
if not auth and (verbose or _DEBUG):
log.debug(_(u"%(user)s not allowed to invite for the game %(game)s in %(room)s") % {'user': nick, 'game': self.name, 'room': room_jid.userhost()})
log.debug(
_(u"%(user)s not allowed to invite for the game %(game)s in %(room)s")
% {"user": nick, "game": self.name, "room": room_jid.userhost()}
)
return auth
def isReferee(self, room_jid, nick):
@ -356,7 +390,9 @@ class RoomGame(object):
"""
if not self._gameExists(room_jid):
return False
return jid.JID(room_jid.userhost() + '/' + nick) == self.games[room_jid]['referee']
return (
jid.JID(room_jid.userhost() + "/" + nick) == self.games[room_jid]["referee"]
)
def isPlayer(self, room_jid, nick):
"""Checks if the user with this nick is a player for the game in this room.
@ -368,7 +404,7 @@ class RoomGame(object):
return False
# Important: the referee is not in the 'players' list right after
# the game initialization, that's why we do also check with isReferee
return nick in self.games[room_jid]['players'] or self.isReferee(room_jid, nick)
return nick in self.games[room_jid]["players"] or self.isReferee(room_jid, nick)
def _checkWaitAuth(self, room, other_players, verbose=False):
"""Check if we must wait for other players before starting the game.
@ -388,10 +424,21 @@ class RoomGame(object):
result = (False, [], other_players)
else:
# TODO: find a way to make it secure
(nicks, missing) = self.host.plugins["XEP-0045"].getRoomNicksOfUsers(room, other_players, secure=False)
(nicks, missing) = self.host.plugins["XEP-0045"].getRoomNicksOfUsers(
room, other_players, secure=False
)
result = (len(nicks) == len(other_players), nicks, missing)
if not result[0] and (verbose or _DEBUG):
log.debug(_(u"Still waiting for %(users)s before starting the game %(game)s in %(room)s") % {'users': result[2], 'game': self.name, 'room': room.occupantJID.userhost()})
log.debug(
_(
u"Still waiting for %(users)s before starting the game %(game)s in %(room)s"
)
% {
"users": result[2],
"game": self.name,
"room": room.occupantJID.userhost(),
}
)
return result
def getUniqueName(self, muc_service=None, profile_key=C.PROF_KEY_NONE):
@ -406,7 +453,9 @@ class RoomGame(object):
room = self.host.plugins["XEP-0045"].getUniqueName(client, muc_service)
return jid.JID("sat_%s_%s" % (self.name.lower(), room.userhost()))
def _prepareRoom(self, other_players=None, room_jid_s='', profile_key=C.PROF_KEY_NONE):
def _prepareRoom(
self, other_players=None, room_jid_s="", profile_key=C.PROF_KEY_NONE
):
room_jid = jid.JID(room_jid_s) if room_jid_s else None
other_players = [jid.JID(player).userhostJID() for player in other_players]
return self.prepareRoom(other_players, room_jid, profile_key)
@ -420,7 +469,7 @@ class RoomGame(object):
"""
# FIXME: need to be refactored
client = self.host.getClient(profile_key)
log.debug(_(u'Preparing room for %s game') % self.name)
log.debug(_(u"Preparing room for %s game") % self.name)
profile = self.host.memory.getProfileName(profile_key)
if not profile:
log.error(_("Unknown profile"))
@ -438,7 +487,9 @@ class RoomGame(object):
user_jid = self.host.getJidNStream(profile)[0]
d = self.host.plugins["XEP-0045"].join(room_jid, user_jid.user, {}, profile)
return d.addCallback(lambda dummy: self._createOrInvite(client, room_jid, other_players))
return d.addCallback(
lambda dummy: self._createOrInvite(client, room_jid, other_players)
)
def userJoinedTrigger(self, room, user, profile):
"""This trigger is used to check if the new user can take part of a game, create the game if we were waiting for him or just update the players list.
@ -451,15 +502,22 @@ class RoomGame(object):
profile_nick = room.occupantJID.resource
if not self.isReferee(room_jid, profile_nick):
return True # profile is not the referee
if not self._checkJoinAuth(room_jid, user.entity if user.entity else None, user.nick):
if not self._checkJoinAuth(
room_jid, user.entity if user.entity else None, user.nick
):
# user not allowed but let him know that we are playing :p
self._synchronizeRoom(room_jid, [jid.JID(room_jid.userhost() + '/' + user.nick)], profile)
self._synchronizeRoom(
room_jid, [jid.JID(room_jid.userhost() + "/" + user.nick)], profile
)
return True
if self.wait_mode == self.FOR_ALL:
# considering the last batch of invitations
batch = len(self.invitations[room_jid]) - 1
if batch < 0:
log.error(u"Invitations from %s to play %s in %s have been lost!" % (profile_nick, self.name, room_jid.userhost()))
log.error(
u"Invitations from %s to play %s in %s have been lost!"
% (profile_nick, self.name, room_jid.userhost())
)
return True
other_players = self.invitations[room_jid][batch][1]
(auth, nicks, dummy) = self._checkWaitAuth(room, other_players)
@ -485,10 +543,10 @@ class RoomGame(object):
return True # profile is not the referee
if self.isPlayer(room_jid, user.nick):
try:
self.games[room_jid]['players'].remove(user.nick)
self.games[room_jid]["players"].remove(user.nick)
except ValueError:
pass
if len(self.games[room_jid]['players']) == 0:
if len(self.games[room_jid]["players"]) == 0:
return True
if self.wait_mode == self.FOR_ALL:
# allow this user to join the game again
@ -513,15 +571,24 @@ class RoomGame(object):
"""
user_nick = self.host.plugins["XEP-0045"].getRoomNick(room_jid, profile)
if not user_nick:
log.error(u'Internal error: profile %s has not joined the room %s' % (profile, room_jid.userhost()))
log.error(
u"Internal error: profile %s has not joined the room %s"
% (profile, room_jid.userhost())
)
return False, False
if self._gameExists(room_jid):
is_referee = self.isReferee(room_jid, user_nick)
if self._gameExists(room_jid, started=True):
log.info(_(u"%(game)s game already created in room %(room)s") % {'game': self.name, 'room': room_jid.userhost()})
log.info(
_(u"%(game)s game already created in room %(room)s")
% {"game": self.name, "room": room_jid.userhost()}
)
return False, is_referee
elif not is_referee:
log.info(_(u"%(game)s game in room %(room)s can only be created by %(user)s") % {'game': self.name, 'room': room_jid.userhost(), 'user': user_nick})
log.info(
_(u"%(game)s game in room %(room)s can only be created by %(user)s")
% {"game": self.name, "room": room_jid.userhost(), "user": user_nick}
)
return False, False
else:
self._initGame(room_jid, user_nick)
@ -539,7 +606,10 @@ class RoomGame(object):
@param nicks (list[unicode]): list of players nicks in the room (referee included, in first position)
@param profile_key (unicode): %(doc_profile_key)s
"""
log.debug(_(u"Creating %(game)s game in room %(room)s") % {'game': self.name, 'room': room_jid})
log.debug(
_(u"Creating %(game)s game in room %(room)s")
% {"game": self.name, "room": room_jid}
)
profile = self.host.memory.getProfileName(profile_key)
if not profile:
log.error(_(u"profile %s is unknown") % profile_key)
@ -551,14 +621,16 @@ class RoomGame(object):
if sync:
self._updatePlayers(room_jid, nicks, True, profile)
return
self.games[room_jid]['started'] = True
self.games[room_jid]["started"] = True
self._updatePlayers(room_jid, nicks, False, profile)
if self.player_init:
# specific data to each player (score, private data)
self.games[room_jid].setdefault('players_data', {})
self.games[room_jid].setdefault("players_data", {})
for nick in nicks:
# The dict must be COPIED otherwise it is shared between all users
self.games[room_jid]['players_data'][nick] = copy.deepcopy(self.player_init)
self.games[room_jid]["players_data"][nick] = copy.deepcopy(
self.player_init
)
def _playerReady(self, player_nick, referee_jid_s, profile_key=C.PROF_KEY_NONE):
self.playerReady(player_nick, jid.JID(referee_jid_s), profile_key)
@ -573,9 +645,9 @@ class RoomGame(object):
if not profile:
log.error(_(u"profile %s is unknown") % profile_key)
return
log.debug(u'new player ready: %s' % profile)
log.debug(u"new player ready: %s" % profile)
# TODO: we probably need to add the game and room names in the sent message
self.send(referee_jid, 'player_ready', {'player': player_nick}, profile=profile)
self.send(referee_jid, "player_ready", {"player": player_nick}, profile=profile)
def newRound(self, room_jid, data, profile):
"""Launch a new round (reinit the user data)
@ -586,18 +658,22 @@ class RoomGame(object):
- msg_elts: dict to map each user to his specific initialization message
@param profile
"""
log.debug(_(u'new round for %s game') % self.name)
log.debug(_(u"new round for %s game") % self.name)
game_data = self.games[room_jid]
players = game_data['players']
players_data = game_data['players_data']
game_data['stage'] = "init"
players = game_data["players"]
players_data = game_data["players_data"]
game_data["stage"] = "init"
common_data, msg_elts = copy.deepcopy(data) if data is not None else (None, None)
if isinstance(msg_elts, dict):
for player in players:
to_jid = jid.JID(room_jid.userhost() + "/" + player) # FIXME: gof:
elem = msg_elts[player] if isinstance(msg_elts[player], domish.Element) else None
elem = (
msg_elts[player]
if isinstance(msg_elts[player], domish.Element)
else None
)
self.send(to_jid, elem, profile=profile)
elif isinstance(msg_elts, domish.Element):
self.send(room_jid, msg_elts, profile=profile)
@ -612,7 +688,7 @@ class RoomGame(object):
@return: the created element
"""
type_ = "normal" if to_jid.resource else "groupchat"
elt = domish.Element((None, 'message'))
elt = domish.Element((None, "message"))
elt["to"] = to_jid.full()
elt["type"] = type_
elt.addElement(self.ns_tag)
@ -632,9 +708,9 @@ class RoomGame(object):
return started_elt
idx = 0
for player in players:
player_elt = domish.Element((None, 'player'))
player_elt = domish.Element((None, "player"))
player_elt.addContent(player)
player_elt['index'] = str(idx)
player_elt["index"] = str(idx)
idx += 1
started_elt.addChild(player_elt)
return started_elt
@ -687,7 +763,7 @@ class RoomGame(object):
return RoomGameHandler(self)
class RoomGameHandler (XMPPHandler):
class RoomGameHandler(XMPPHandler):
implements(iwokkel.IDisco)
def __init__(self, plugin_parent):
@ -695,10 +771,14 @@ class RoomGameHandler (XMPPHandler):
self.host = plugin_parent.host
def connectionInitialized(self):
self.xmlstream.addObserver(self.plugin_parent.request, self.plugin_parent.room_game_cmd, profile=self.parent.profile)
self.xmlstream.addObserver(
self.plugin_parent.request,
self.plugin_parent.room_game_cmd,
profile=self.parent.profile,
)
def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
return [disco.DiscoFeature(self.plugin_parent.ns_tag[0])]
def getDiscoItems(self, requestor, target, nodeIdentifier=''):
def getDiscoItems(self, requestor, target, nodeIdentifier=""):
return []