def shortcutAnimation(self, animation): """directly set the end value of the animation""" if animation.debug: logDebug('shortcut {}: UTile {}: clear queuedAnimations'.format(animation, self.name())) setattr(self, animation.pName(), animation.endValue()) self.queuedAnimations = [] self.setDrawingOrder()
def start(self, dummyResults='DIREKT'): """start the animation, returning its deferred""" if not isAlive(self): return fail() assert self.state() != QAbstractAnimation.Running for animation in self.animations: graphicsObject = animation.targetObject() if not isAlive(animation) or not isAlive(graphicsObject): return fail() graphicsObject.setActiveAnimation(animation) self.addAnimation(animation) propName = animation.pName() animation.setStartValue(graphicsObject.getValue(propName)) if propName == 'rotation': # change direction if that makes the difference smaller endValue = animation.endValue() currValue = graphicsObject.rotation if endValue - currValue > 180: animation.setStartValue(currValue + 360) if currValue - endValue > 180: animation.setStartValue(currValue - 360) for animation in self.animations: animation.targetObject().setDrawingOrder() self.finished.connect(self.allFinished) scene = Internal.scene scene.focusRect.hide() QParallelAnimationGroup.start( self, QAbstractAnimation.DeleteWhenStopped) if self.debug: logDebug('%s started with speed %d (%s)' % ( self, Internal.Preferences.animationSpeed, ','.join('A%s' % id4(x) for x in self.animations))) return succeed(None).addErrback(logException)
def setupAnimations(self): """move the item to its new place. This puts new Animation objects into the queue to be animated by calling animate()""" for pName, newValue in self.moveDict().items(): if self.scene() != Internal.scene: # not part of the playing scene, like tiles in tilesetselector setattr(self, pName, newValue) continue animation = self.queuedAnimation(pName) if animation: curValue = animation.endValue() if curValue != newValue: # change a queued animation if self.name() in Debug.animation: logDebug('setEndValue for {}: {}: {}->{}'.format( animation, pName, animation.formatValue(curValue), animation.formatValue(newValue))) animation.setEndValue(newValue) else: animation = self.activeAnimation.get(pName, None) if isAlive(animation): curValue = animation.endValue() else: curValue = self.getValue(pName) if pName != 'scale' or abs(curValue - newValue) > 0.00001: # ignore rounding differences for scale if curValue != newValue: Animation(self, pName, newValue)
def cancelAll(): """cancel all animations""" if Debug.quit: logDebug('Cancelling all animations') for group in ParallelAnimationGroup.running: if isAlive(group): group.clear()
def __init__(self, statement, args=None, silent=False, mayFail=False, failSilent=False): """we take one sql statement. Do prepared queries by passing the parameters in args. If args is a list of lists, execute the prepared query for every sublist. Use Internal.db for db access. Else if the default dbHandle (Internal.db) is defined, use it.""" # pylint: disable=too-many-branches silent |= not Debug.sql self.msg = None self.records = [] self.statement = statement self.args = args if Internal.db: self.cursor = Internal.db.cursor( DBCursor) # pylint: disable=no-member self.cursor.execute( statement, args, silent=silent, mayFail=mayFail, failSilent=failSilent) self.failure = self.cursor.failure self.records = list(self.cursor.fetchall()) if not Internal.db.inTransaction: Internal.db.commit() else: # may happen at shutdown self.cursor = None self.failure = None self.records = list() if self.records and Debug.sql: logDebug('result set:{}'.format(self.records))
def createRule(self, name, definition='', **kwargs): """shortcut for simpler definition of predefined rulesets""" name = unicodeString(name) definition = unicodeString(definition) defParts = definition.split(u'||') rule = None description = kwargs.get('description', '') for cls in [IntRule, BoolRule, StrRule]: if defParts[0].startswith(cls.prefix): rule = cls( name, definition, description=description, parameter=kwargs['parameter']) break if not rule: if 'parameter' in kwargs: del kwargs['parameter'] ruleType = type(str(ruleKey(name)) + 'Rule', (Rule, ), {}) rule = ruleType(name, definition, **kwargs) if defParts[0] == 'FCallingHand': parts1 = defParts[1].split('=') assert parts1[0] == 'Ohand', definition ruleClassName = parts1[1] + 'Rule' if ruleClassName not in RuleBase.ruleClasses: logDebug( u'we want %s, definition:%s' % (ruleClassName, definition)) logDebug(u'we have %s' % RuleBase.ruleClasses.keys()) ruleType.limitHand = RuleBase.ruleClasses[ruleClassName] self.add(rule)
def remote_newTables(self, tables): """update table list""" newTables = list(ClientTable(self, *x) for x in tables) self.tables.extend(newTables) if Debug.table: _ = u', '.join(unicode(ClientTable(self, *x)) for x in tables) logDebug(u'%s got new tables:%s' % (self.name, _))
def __init__(self, paginaId, moduleConfig): self.teamId = [] self.sqStatus = "" self.sqKpis = "" log.logDebug('Processing Sonarqube module for ' + str(paginaId) + ' con config ' + str(moduleConfig)) self.doRequest(moduleConfig)
def clientAction(self, dummyClient, move): """server sent us voice sounds about somebody else""" move.player.voice = Voice(move.md5sum, move.source) if Debug.sound: logDebug( '%s gets voice data %s from server, language=%s' % (move.player, move.player.voice, move.player.voice.language()))
def availableVoices(): """a list of all voice directories""" if not Voice.__availableVoices: result = [] directories = QStandardPaths.locateAll( QStandardPaths.AppDataLocation, 'voices', QStandardPaths.LocateDirectory) directories.insert(0, os.path.join('share', 'kajongg', 'voices')) for parentDirectory in directories: for (dirpath, _, _) in os.walk(parentDirectory, followlinks=True): if os.path.exists(os.path.join(dirpath, 's1.ogg')): result.append(Voice(dirpath)) group = Internal.kajonggrc.group('Locale') prefLanguages = uniqueList(':'.join( ['local', str(group.readEntry('Language')), 'en_US']).split(':')) prefLanguages = dict( (x[1], x[0]) for x in enumerate(prefLanguages)) result = sorted( result, key=lambda x: prefLanguages.get(x.language(), 9999)) if Debug.sound: logDebug('found voices:%s' % [str(x) for x in result]) Voice.__availableVoices = result return Voice.__availableVoices
def debug(self, msg, btIndent=None, prevHandId=False): """ Log a debug message. @param msg: The message. @type msg: A string. @param btIndent: If given, message is indented by depth(backtrace)-btIndent @type btIndent: C{int} @param prevHandId: If True, do not use current handId but previous @type prevHandId: C{bool} """ if self.belongsToRobotPlayer(): prefix = u'R' elif self.belongsToHumanPlayer(): prefix = u'C' elif self.belongsToGameServer(): prefix = u'S' else: logDebug(msg, btIndent=btIndent) return handId = self._prevHandId if prevHandId else self.handId handId = unicodeString(handId.prompt(withMoveCount=True)) logDebug( u'%s%s: %s' % (prefix, handId, unicodeString(msg)), withGamePrefix=False, btIndent=btIndent)
def clientAction(self, client, move): """violation: player may not say mah jongg""" move.player.popupMsg(self) move.player.mayWin = False if Debug.originalCall: logDebug('%s: cleared mayWin' % move.player) return client.ask(move, [Message.OK])
def remote_newTables(self, tables): """update table list""" newTables = list(ClientTable(self, *x) for x in tables) self.tables.extend(newTables) if Debug.table: _ = ', '.join(str(ClientTable(self, *x)) for x in tables) logDebug('%s got new tables:%s' % (self.name, _))
def __startLocalServer(self): """start a local server""" try: args = self.__findServerProgram() if self.useSocket or os.name == 'nt': # for nt --socket tells the server to bind to 127.0.0.1 args.append('--socket=%s' % socketName()) if removeIfExists(socketName()): logInfo( i18n('removed stale socket <filename>%1</filename>', socketName())) if not self.useSocket: args.append('--port=%d' % self.port) if self.isLocalGame: args.append('--db={}'.format( os.path.normpath(os.path.join(appdataDir(), 'local3.db')))) if Debug.argString: args.append('--debug=%s' % Debug.argString) if os.name == 'nt': startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW else: startupinfo = None process = subprocess.Popen( args, startupinfo=startupinfo) # , shell=os.name == 'nt') if Debug.connections: logDebug( i18n( 'started the local kajongg server: pid=<numid>%1</numid> %2', process.pid, ' '.join(args))) except OSError as exc: exc.filename = ' '.join(args) logException(exc)
def __initTableList(self, dummy): """first load of the list. Process options like --demo, --table, --join""" self.showTableList() if SingleshotOptions.table: Internal.autoPlay = False self.__requestNewTableFromServer(SingleshotOptions.table).addCallback( self.__showTables).addErrback(self.tableError) if Debug.table: logDebug( '%s: --table lets us open an new table %d' % (self.name, SingleshotOptions.table)) SingleshotOptions.table = False elif SingleshotOptions.join: Internal.autoPlay = False self.callServer('joinTable', SingleshotOptions.join).addCallback( self.__showTables).addErrback(self.tableError) if Debug.table: logDebug( '%s: --join lets us join table %s' % (self.name, self._tableById(SingleshotOptions.join))) SingleshotOptions.join = False elif not self.game and (Internal.autoPlay or (not self.tables and self.hasLocalServer())): self.__requestNewTableFromServer().addCallback( self.__newLocalTable).addErrback(self.tableError) else: self.__showTables()
def __init__(self, statement, args=None, silent=False, mayFail=False, failSilent=False): """we take one sql statement. Do prepared queries by passing the parameters in args. If args is a list of lists, execute the prepared query for every sublist. Use Internal.db for db access. Else if the default dbHandle (Internal.db) is defined, use it.""" # pylint: disable=too-many-branches silent |= not Debug.sql self.msg = None self.records = [] self.statement = statement self.args = args if Internal.db: self.cursor = Internal.db.cursor( DBCursor) # pylint: disable=no-member self.cursor.execute( statement, args, silent=silent, mayFail=mayFail, failSilent=failSilent) self.failure = self.cursor.failure self.records = list(self.cursor.fetchall()) if not Internal.db.inTransaction: Internal.db.commit() else: # may happen at shutdown self.cursor = None self.failure = None self.records = list() if self.records and Debug.sql: logDebug(u'result set:{}'.format(self.records))
def removeTable(self, table, reason, message=None, *args): """remove a table""" assert reason in ('silent', 'tableRemoved', 'gameOver', 'abort') # HumanClient implements methods remote_tableRemoved etc. message = message or '' if Debug.connections or reason == 'abort': logDebug('%s%s ' % (('%s:' % table.game.seed) if table.game else '', i18n(message, *args)), withGamePrefix=None) if table.tableid in self.tables: del self.tables[table.tableid] if reason == 'silent': tellUsers = [] else: tellUsers = table.users if table.running else self.srvUsers for user in tellUsers: # this may in turn call removeTable again! self.callRemote(user, reason, table.tableid, message, *args) for user in table.users: table.delUser(user) if Debug.table: logDebug('removing table %d: %s %s' % (table.tableid, i18n(message, *args), reason)) if table.game: table.game.close()
def requestAvatarId(self, cred): # pylint: disable=no-self-use """get user id from database""" cred.username = cred.username.decode('utf-8') args = cred.username.split(SERVERMARK) if len(args) > 1: if args[0] == 'adduser': cred.username = args[1] password = args[2] query = Query( 'insert or ignore into player(name,password) values(?,?)', (cred.username, password)) elif args[1] == 'deluser': pass query = Query('select id, password from player where name=?', (cred.username, )) if not len(query.records): template = 'Wrong username: %1' if Debug.connections: logDebug(i18n(template, cred.username)) return fail( credError.UnauthorizedLogin(srvMessage(template, cred.username))) userid, password = query.records[0] defer1 = maybeDeferred(cred.checkPassword, password.encode('utf-8')) defer1.addCallback(DBPasswordChecker._checkedPassword, userid) return defer1
def dictToStringManual(inputDict): salida = "'{" log.logDebug('Found ' + str(len(inputDict)) + ' items in dictionary') subSalida1 = "" for key, value in sorted(inputDict.items()): if (len(subSalida1) > 0): subSalida1 = subSalida1 + ',' subSalida1 = subSalida1 + '"' + key + '": ' if str(value) == "{}": subSalida1 = subSalida1 + '{}' continue subSalida1 = subSalida1 + '{' valueDict = ast.literal_eval(str(value)) subSalida2 = '' log.logDebug('Found ' + str(len(valueDict)) + ' items in subDictionary') for subKey, subValue in sorted(valueDict.items()): if (len(subSalida2) > 0): subSalida2 = subSalida2 + ',' subSalida2 = subSalida2 + '"' + subKey + '": ' if str(subValue) == "": subSalida2 = subSalida2 + '{""}' continue subSalida2 = subSalida2 + str(subValue) subSalida1 = subSalida1 + subSalida2 + '}' salida = salida + subSalida1 return salida + "}'"
def extractValue(pagina, paramName): paramString = pagina.find(paramName) if len(paramString) == 0: log.logError('Bad xml syntax: ' + paramName + ' missing') return "" log.logDebug('Page parameter ' + str(paramName) + ' = ' + str(paramString)) return paramString.get_text()
def sendVoiceIds(self): """tell each player what voice ids the others have. By now the client has a Game instance!""" humanPlayers = [ x for x in self.game.players if isinstance(self.remotes[x], User) ] if len(humanPlayers) < 2 or not any(self.remotes[x].voiceId for x in humanPlayers): # no need to pass around voice data self.assignVoices() return block = DeferredBlock(self) for player in humanPlayers: remote = self.remotes[player] if remote.voiceId: # send it to other human players: others = [x for x in humanPlayers if x != player] if Debug.sound: logDebug( 'telling other human players that %s has voiceId %s' % (player.name, remote.voiceId)) block.tell(player, others, Message.VoiceId, source=remote.voiceId) block.callback(self.collectVoiceData)
def buildSubvoice(self, oggName, side): """side is 'left' or 'right'.""" angleDirectory = os.path.join(cacheDir(), 'angleVoices', self.md5sum, side) stdName = os.path.join(self.directory, oggName) angleName = os.path.join(angleDirectory, oggName) if os.path.exists(stdName) and not os.path.exists(angleName): sox = which('sox') if not sox: return stdName if not os.path.exists(angleDirectory): os.makedirs(angleDirectory) args = [sox, stdName, angleName, 'remix'] if side == 'left': args.extend(['1,2', '0']) elif side == 'right': args.extend(['0', '1,2']) callResult = subprocess.call(args) if callResult: if Debug.sound: logDebug('failed to build subvoice %s: return code=%s' % (angleName, callResult)) return stdName if Debug.sound: logDebug('built subvoice %s' % angleName) return angleName
def serverDisconnected(self, dummyReference): """perspective calls us back""" if self.connection and (Debug.traffic or Debug.connections): logDebug( 'perspective notifies disconnect: %s' % self.connection.url) self.remote_serverDisconnects()
def __init__(self, names, ruleset, gameid=None, wantedGame=None, client=None, playOpen=False, autoPlay=False): """a new game instance, comes from database if gameid is set""" self.__activePlayer = None self.prevActivePlayer = None self.defaultNameBrush = None Game.__init__(self, names, ruleset, gameid, wantedGame=wantedGame, client=client) self.playOpen = playOpen self.autoPlay = autoPlay myself = self.myself if self.belongsToHumanPlayer() and myself: myself.voice = Voice.locate(myself.name) if myself.voice: if Debug.sound: logDebug('myself %s gets voice %s' % (myself.name, myself.voice)) else: if Debug.sound: logDebug('myself %s gets no voice' % (myself.name))
def startServer(self, result, waiting=0): """make sure we have a running local server or network connectivity""" if self.isLocalHost: # just wait for that server to appear if self.__serverListening(): return result else: if waiting == 0: self.__startLocalServer() elif waiting > 30: logDebug( 'Game %s: Server %s not available after 30 seconds, aborting' % (SingleshotOptions.game, self)) raise CancelledError return deferLater(Internal.reactor, 1, self.startServer, result, waiting + 1) elif which('qdbus'): try: stdoutdata, stderrdata = subprocess.Popen( [ 'qdbus', 'org.kde.kded', '/modules/networkstatus', 'org.kde.Solid.Networking.status' ], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate(timeout=1) except subprocess.TimeoutExpired: raise twisted.internet.error.ConnectError() stdoutdata = stdoutdata.strip() stderrdata = stderrdata.strip() if stderrdata == '' and stdoutdata != '4': # pylint: disable=nonstandard-exception raise twisted.internet.error.ConnectError() # if we have stderrdata, qdbus probably does not provide the # service we want, so ignore it return result
def start(self, dummyResults='DIREKT'): """start the animation, returning its deferred""" assert self.state() != QAbstractAnimation.Running for animation in self.animations: uiTile = animation.targetObject() self.debug |= uiTile.tile in Debug.animation uiTile.setActiveAnimation(animation) self.addAnimation(animation) propName = animation.pName() animation.setStartValue(uiTile.getValue(propName)) if propName == 'rotation': # change direction if that makes the difference smaller endValue = animation.unpackEndValue() currValue = uiTile.rotation if endValue - currValue > 180: animation.setStartValue(currValue + 360) if currValue - endValue > 180: animation.setStartValue(currValue - 360) for animation in self.animations: animation.targetObject().setDrawingOrder() self.finished.connect(self.allFinished) scene = Internal.scene scene.focusRect.hide() QParallelAnimationGroup.start( self, QAbstractAnimation.DeleteWhenStopped) if self.debug: logDebug(u'Animation group %d started (%s)' % ( id(self), ','.join('A%d' % (id(x) % 10000) for x in self.animations))) return succeed(None)
def serverDisconnected(self, dummyReference): """perspective calls us back""" if self.connection and (Debug.traffic or Debug.connections): logDebug( u'perspective notifies disconnect: %s' % self.connection.url) self.remote_serverDisconnects()
def collectVoiceData(self, requests): """collect voices of other players""" if not self.running: return block = DeferredBlock(self) voiceDataRequests = [] for request in requests: if request.answer == Message.ClientWantsVoiceData: # another human player requests sounds for voiceId voiceId = request.args[0] voiceFor = [ x for x in self.game.players if isinstance(self.remotes[x], User) and self.remotes[x].voiceId == voiceId ][0] voiceFor.voice = Voice(voiceId) if Debug.sound: logDebug('client %s wants voice data %s for %s' % (request.user.name, request.args[0], voiceFor)) voiceDataRequests.append((request.user, voiceFor)) if not voiceFor.voice.oggFiles(): # the server does not have it, ask the client with that # voice block.tell(voiceFor, voiceFor, Message.ServerWantsVoiceData) block.callback(self.sendVoiceData, voiceDataRequests)
def processPlugin(self): """ Create a graph for the specified component (or for all the project if is not defined) in which it shows the issues status (icebox, development, blocked and closed) in proportion :param project: Jira project :param componentId: Team to be analyzed. If empty, all project is counted :param fixVersion: If empty, all team issues are counted. :param actualSprint: If empty, all issues are counted. (Be careful, if all issues are counted it may a long time to run) :return: (str) Returns the filename of the generated image. """ health_values = {} if self.component.__len__() == 0: component_jql = '' else: component_jql = jiraSetting.component_filters[str(self.component)] issue_type = jiraSetting.type_filters["Story_Spike"] for status, value in jiraSetting.status_filters.items(): log.logDebug( "Executing request to get " + status + " issues for the team: " + component_jql + self.actualSprint) jql = 'project=' + str(self.project) + value + str(component_jql) + str(self.fixVersion) + str( self.actualSprint) + str( issue_type) res = tools.countIssue(jql, jira_connection) health_values[status] = res keys = list(health_values.keys()) values = list(health_values.values()) self.fileName = pl.generatePieChart("Sprint Health Board", self.project, self.component, self.fixVersion, keys, values) # query ALL the project return self.fileName
def __initTableList(self, dummy): """first load of the list. Process options like --demo, --table, --join""" self.showTableList() if SingleshotOptions.table: Internal.autoPlay = False self.__requestNewTableFromServer(SingleshotOptions.table).addCallback( self.__showTables).addErrback(self.tableError) if Debug.table: logDebug( u'%s: --table lets us open an new table %d' % (self.name, SingleshotOptions.table)) SingleshotOptions.table = False elif SingleshotOptions.join: Internal.autoPlay = False self.callServer('joinTable', SingleshotOptions.join).addCallback( self.__showTables).addErrback(self.tableError) if Debug.table: logDebug( u'%s: --join lets us join table %s' % (self.name, self._tableById(SingleshotOptions.join))) SingleshotOptions.join = False elif not self.game and (Internal.autoPlay or (not self.tables and self.hasLocalServer())): self.__requestNewTableFromServer().addCallback( self.__newLocalTable).addErrback(self.tableError) else: self.__showTables()
def __init__(self, paginaId, moduleConfig): self.project = "" self.component = "" self.fixVersion = "" self.actualSprint = "" log.logDebug('Processing Jira module for ' + str(paginaId) + ' con config ' + str(moduleConfig)) self.doRequest(moduleConfig)
def createRule(self, name: str, definition: str = '', **kwargs): """shortcut for simpler definition of predefined rulesets""" defParts = definition.split('||') rule = None description = kwargs.get('description', '') for cls in [IntRule, BoolRule, StrRule]: if defParts[0].startswith(cls.prefix): rule = cls(name, definition, description=description, parameter=kwargs['parameter']) break if not rule: if 'parameter' in kwargs: del kwargs['parameter'] ruleType = type(ruleKey(name) + 'Rule', (Rule, ), {}) rule = ruleType(name, definition, **kwargs) if defParts[0] == 'FCallingHand': parts1 = defParts[1].split('=') assert parts1[0] == 'Ohand', definition ruleClassName = parts1[1] + 'Rule' if ruleClassName not in RuleBase.ruleClasses: logDebug('we want %s, definition:%s' % (ruleClassName, definition)) logDebug('we have %s' % RuleBase.ruleClasses.keys()) ruleType.limitHand = RuleBase.ruleClasses[ruleClassName] self.add(rule)
def debug(self, msg, btIndent=None, prevHandId=False): """ Log a debug message. @param msg: The message. @type msg: A string. @param btIndent: If given, message is indented by depth(backtrace)-btIndent @type btIndent: C{int} @param prevHandId: If True, do not use current handId but previous @type prevHandId: C{bool} """ if self.belongsToRobotPlayer(): prefix = 'R' elif self.belongsToHumanPlayer(): prefix = 'C' elif self.belongsToGameServer(): prefix = 'S' else: logDebug(msg, btIndent=btIndent) return handId = self._prevHandId if prevHandId else self.handId handId = handId.prompt(withMoveCount=True) logDebug('%s%s: %s' % (prefix, handId, msg), withGamePrefix=False, btIndent=btIndent)
def nextHand(self, dummyResults): """next hand: maybe rotate""" if not self.running: return DeferredBlock.garbageCollection() for block in DeferredBlock.blocks: if block.table == self: logError('request left from previous hand: %s' % block.outstandingStr()) token = self.game.handId.prompt( withAI=False) # we need to send the old token until the # clients started the new hand rotateWinds = self.game.maybeRotateWinds() if self.game.finished(): self.server.removeTable(self, 'gameOver', i18nE('Game <numid>%1</numid> is over!'), self.game.seed) if Debug.process and os.name != 'nt': logDebug('MEM:%s' % resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) return self.game.sortPlayers() playerNames = list((x.wind, x.name) for x in self.game.players) self.tellAll(None, Message.ReadyForHandStart, self.startHand, playerNames=playerNames, rotateWinds=rotateWinds, token=token)
def __init__(self, paginaId, moduleConfig): self.product = "" self.name = "" self.project = "" self.branch = "" log.logDebug('Processing Adict module for ' + str(paginaId) + ' con config ' + str(moduleConfig)) self.doRequest(moduleConfig)
def clientAction(self, client, move): """violation: player may not say mah jongg""" move.player.popupMsg(self) move.player.mayWin = False if Debug.originalCall: logDebug(u'%s: cleared mayWin' % move.player) return client.ask(move, [Message.OK])
def processFixVersions(connection, arrayVersions): allFixVersions = connection.project_versions( "MJF3DP") # Jira request to get all allFixVersions for this project resultReleases = [] auxDict = dict() resultDict = dict() listArrayVersions = arrayVersions.split(",") for version in allFixVersions: for item in listArrayVersions: if str(version) == str(item): resultReleases.append(version) for release in resultReleases: frameFixVersionArray = [] try: arrayDate = release.releaseDate.split("-") frameFixVersionArray.append(str("ID: " + processIdArray(arrayDate))) log.logDebug('Transforming date: ' + str(arrayDate) + ' to ' + processIdArray(arrayDate)) except: frameFixVersionArray.append("ID: N/A") log.logDebug('Transforming date: [Null] to ID:N/A') processRelease(release, frameFixVersionArray) auxDict[str(release.name)] = frameFixVersionArray resultDict.update(auxDict) return resultDict
def _clientDiscarded4(self, dummyResults, msg, dangerousText, mustPlayDangerous): """client told us he discarded a tile. Continue, check for dangerous game""" block = DeferredBlock(self) player = msg.player if dangerousText: if mustPlayDangerous and not player.lastSource.isDiscarded: if Debug.dangerousGame: tile = Tile(msg.args[0]) logDebug( '%s claims no choice. Discarded %s, keeping %s. %s' % (player, tile, ''.join( player.concealedTiles), ' / '.join(dangerousText))) player.claimedNoChoice = True block.tellAll(player, Message.NoChoice, tiles=TileList(player.concealedTiles)) else: player.playedDangerous = True if Debug.dangerousGame: tile = Tile(msg.args[0]) logDebug( '%s played dangerous. Discarded %s, keeping %s. %s' % (player, tile, ''.join( player.concealedTiles), ' / '.join(dangerousText))) block.tellAll(player, Message.DangerousGame, tiles=TileList(player.concealedTiles)) if msg.answer == Message.OriginalCall: player.isCalling = True block.callback(self.clientMadeOriginalCall, msg) else: block.callback(self._askForClaims, msg)
def perspective_setClientProperties( self, dbIdent, voiceId, maxGameId, clientVersion=None): """perspective_* methods are to be called remotely""" self.dbIdent = dbIdent self.voiceId = voiceId self.maxGameId = maxGameId clientVersion = nativeString(clientVersion) serverVersion = Internal.defaultPort if clientVersion != serverVersion: # we assume that versions x.y.* are compatible if clientVersion is None: # client passed no version info return fail(srvError(pb.Error, m18nE( 'Your client has a version older than 4.9.0 but you need %1 for this server'), serverVersion)) else: commonDigits = len([x for x in zip( clientVersion.split(b'.'), serverVersion.split(b'.')) if x[0] == x[1]]) if commonDigits < 2: return fail(srvError(pb.Error, m18nE( 'Your client has version %1 but you need %2 for this server'), clientVersion or '<4.9.0', '.'.join(serverVersion.split('.')[:2]) + '.*')) if Debug.table: logDebug(u'client has dbIdent={} voiceId={} maxGameId={} clientVersion {}'.format( self.dbIdent, self.voiceId, self.maxGameId, clientVersion)) self.server.sendTables(self)
def rollback(self, silent=None): """rollback and log it""" try: sqlite3.Connection.rollback(self) if not silent and Debug.sql: logDebug(u'%x rollbacked transaction' % id(self)) except sqlite3.Error as exc: logWarning(u'%s cannot rollback: %s' % (self.name, exc.message))
def detached(self, dummyMind): """override pb.Avatar.detached""" if Debug.connections: logDebug( u'%s: connection detached from %s' % (self, self.source())) self.server.logout(self) self.mind = None
def addWatch(self, name, method): """If name changes, call method. method must accept 2 arguments: old value and new value.""" if method not in self.__watching[name]: self.__watching[name].append(method) if Debug.preferences: logDebug('addWatch on {}, hook {}'.format( name, method.__name__)) self.callTrigger(name) # initial change
def setEndValue(self, endValue): """wrapper with debugging code""" uiTile = self.targetObject() if uiTile.tile in Debug.animation: pName = self.pName() logDebug( u'%s: change endValue for %s: %s->%s %s' % (self.ident(), pName, self.formatValue(self.endValue()), self.formatValue(endValue), uiTile)) QPropertyAnimation.setEndValue(self, endValue)
def board(self, value): """assign and show/hide as needed""" if value and not isAlive(value): logDebug( u'assigning focusRect to a non-alive board %s/%s' % (type(value), value)) return if value: self._board = value self.refresh()
def remote_chat(self, data): """others chat to me""" chatLine = ChatMessage(data) if Debug.chat: logDebug(u'got chatLine: %s' % chatLine) table = self._tableById(chatLine.tableid) if not chatLine.isStatusMessage and not table.chatWindow: ChatWindow(table) if table.chatWindow: table.chatWindow.receiveLine(chatLine)
def serverAction(self, dummyTable, msg): """save voice sounds on the server""" voice = msg.player.voice voice.archiveContent = msg.args[0] if Debug.sound: if voice.oggFiles(): logDebug(u'%s: server got wanted voice data %s' % ( msg.player, voice)) else: logDebug(u'%s: server got empty voice data %s (arg0=%s)' % ( msg.player, voice, repr(msg.args[0][:100])))
def __generateDbIdent(): """make sure the database has a unique ident and get it""" records = Query('select ident from general').records assert len(records) < 2 if not records: dbIdent = str(random.randrange(100000000000)) Query("INSERT INTO general(ident) values(?)", (dbIdent,)) if Debug.sql: logDebug( u'generated new dbIdent %s for %s' % (dbIdent, Internal.db.path))
def cancelled(dummy): """the user does not want to start now. Back to table list""" if Debug.table: logDebug(u'%s: Readyforgamestart returns Message.NoGameStart for table %s' % ( self.name, self._tableById(tableid))) self.table = None self.beginQuestion = None if self.tableList: self.__updateTableList() self.tableList.show() return Message.NoGameStart
def clientAction(self, client, move): """mirror the original call""" player = move.player if client.thatWasMe(player): player.originalCallingHand = player.hand if Debug.originalCall: logDebug( u'%s gets originalCallingHand:%s' % (player, player.originalCallingHand)) player.originalCall = True client.game.addCsvTag('originalCall') return client.ask(move, [Message.OK])
def cleanExit(*dummyArgs): """close sqlite3 files before quitting""" if isAlive(Internal.mainWindow): if Debug.quit: logDebug(u'cleanExit calling mainWindow.close') Internal.mainWindow.close() else: # this must be very early or very late if Debug.quit: logDebug(u'cleanExit calling sys.exit(0)') # sys.exit(0) MainWindow.aboutToQuit()
def garbageCollection(): """delete completed blocks. Only to be called before inserting a new block. Assuming that block creation never overlaps.""" for block in DeferredBlock.blocks[:]: if block.callbackMethod is None: block.logBug(u'DBlock %s has no callback' % str(block)) if block.completed: DeferredBlock.blocks.remove(block) if len(DeferredBlock.blocks) > 100: logDebug( u'We have %d DeferredBlocks, they must be leaking' % len(DeferredBlock.blocks))
def __afterCurrentAnimationDo(callback, *args, **kwargs): """a helper, delaying some action until all active animations have finished""" current = ParallelAnimationGroup.current if current: deferred = Deferred() deferred.addCallback(callback, *args, **kwargs) current.doAfter.append(deferred) if current.debug: logDebug(u'after current animation %d do %s %s' % (id(current), callback, ','.join(args) if args else '')) else: callback(None, *args, **kwargs)
def callTrigger(self, name): """call registered callback for this attribute change""" newValue = getattr(self, name) if self.__oldValues[name] != newValue: if Debug.preferences: logDebug(u'{}: {} -> {} calling {}'.format( name, self.__oldValues[name], newValue, ','.join(x.__name__ for x in self.__watching[name]))) for method in self.__watching[name]: method(self.__oldValues[name], newValue) self.__oldValues[name] = newValue
def sendLine(self, line=None, isStatusMessage=False): """send line to others. Either the edited line or parameter line.""" if line is None: line = unicode(self.edit.text()) self.edit.clear() if line: if Debug.chat: logDebug(u'sending line %s to others' % line) msg = ChatMessage( self.table.tableid, self.table.client.name, line, isStatusMessage) self.table.client.sendChat(msg).addErrback(self.chatError)
def hideTableList(result): """hide it only after player says I am ready""" # set scene.game first, otherwise tableList.hide() # sees no current game and logs out if result == Message.OK: if client.game and Internal.scene: Internal.scene.game = client.game if result == Message.OK and client.tableList and client.tableList.isVisible(): if Debug.table: logDebug( u'%s hiding table list because game started' % client.name) client.tableList.hide() return result
def aboutToQuit(): """now all connections to servers are cleanly closed""" mainWindow = Internal.mainWindow Internal.mainWindow = None if mainWindow: if Debug.quit: logDebug(u'aboutToQuit starting') if mainWindow.exitWaitTime > 1000.0 or Debug.quit: logDebug( u'reactor stopped after %d ms' % (mainWindow.exitWaitTime)) else: if Debug.quit: logDebug(u'aboutToQuit: mainWindow is already None') StateSaver.saveAll() Internal.app.quit() try: # if we are killed while loading, Internal.db may not yet be # defined if Internal.db: Internal.db.close() except NameError: pass checkMemory() logging.shutdown() if Debug.quit: logDebug(u'aboutToQuit ending')
def tell(self, about, receivers, command, **kwargs): """send info about player 'about' to users 'receivers'""" def encodeKwargs(): """those values are classes like Meld, Tile etc. Convert to str(python2) or bytes(python3""" for keyword in ('tile', 'tiles', 'meld', 'melds'): if keyword in kwargs: kwargs[keyword] = str(kwargs[keyword]).encode() encodeKwargs() if about.__class__.__name__ == 'User': about = self.playerForUser(about) if not isinstance(receivers, list): receivers = list([receivers]) assert receivers, 'DeferredBlock.tell(%s) has no receiver' % command self.__enrichMessage(self.table.game, about, command, kwargs) aboutName = about.name if about else None if self.table.running and len(receivers) in [1, 4]: # messages are either identical for all 4 players # or identical for 3 players and different for 1 player. And # we want to capture each message exactly once. self.table.game.appendMove(about, command, kwargs) localDeferreds = [] for rec in self.__convertReceivers(receivers): isClient = rec.__class__.__name__.endswith('Client') if Debug.traffic and not isClient: message = u'-> {receiver:<15} about {about} {command}{kwargs}'.format( receiver=rec.name[:15], about=about, command=command, kwargs=Move.prettyKwargs(kwargs)) logDebug(message) if isClient: defer = Deferred() defer.addCallback(rec.remote_move, command, **kwargs) else: defer = self.table.server.callRemote( rec, 'move', aboutName, command.name, **kwargs) if defer: defer.command = command.name defer.notifying = 'notifying' in kwargs self.__addRequest(defer, rec, about) else: msg = m18nE('The game server lost connection to player %1') self.table.abort(msg, rec.name) if isClient: localDeferreds.append(defer) for defer in localDeferreds: defer.callback(aboutName) # callback needs an argument !
def __logCallServer(self, *args): """for Debug.traffic""" debugArgs = list(args[:]) if Debug.neutral: if debugArgs[0] == 'ping': return if debugArgs[0] == 'setClientProperties': debugArgs[1] = 'DBID' debugArgs[3] = 'GAMEID' if debugArgs[4] >= 8300: debugArgs[4] -= 300 if self.game: self.game.debug('callServer(%s)' % repr(debugArgs)) else: logDebug(u'callServer(%s)' % repr(debugArgs))
def focusTile(self, uiTile): """the uiTile of this board with focus. This is per Board!""" if uiTile is self._focusTile: return if uiTile: assert uiTile.tile.isKnown, uiTile if not isinstance(uiTile.board, DiscardBoard): assert uiTile.focusable, uiTile self.__prevPos = uiTile.sortKey() self._focusTile = uiTile if self._focusTile and self._focusTile.tile in Debug.focusable: logDebug(u'%s: new focus uiTile %s from %s' % ( self.name, self._focusTile.tile if self._focusTile else 'None', stack('')[-1])) if self.hasFocus: self.scene().focusBoard = self
def confirmed(result): """quit if the active game has been aborted""" self.exitConfirmed = bool(result) if Debug.quit: if self.exitConfirmed: logDebug(u'mainWindow.queryClose confirmed') else: logDebug(u'mainWindow.queryClose not confirmed') # start closing again. This time no question will appear, the game # is already aborted if self.exitConfirmed: assert isAlive(self) self.close() else: self.exitConfirmed = None